> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the Pixelbin MCP server

The Pixelbin MCP connector routes your AI agent's tool calls to Pixelbin's own MCP server through Scalekit. Each user signs in to Pixelbin once, and Scalekit stores and refreshes their tokens, so your agent never handles credentials. It comes with 7 tools.

**Authentication:** OAuth2.1/DCR
**Categories:** Media, Developer Tools
**Tools:** 7: 3 read, 4 write, 0 destructive
**Users sign in with:** OAuth
**OAuth app:** Scalekit's or your own
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=PIXELBINMCP)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Pixelbin MCP connection

   In **AgentKit > Connections**, create a Pixelbin MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

   Scalekit credentials are available for Pixelbin MCP server, so you don't need to register an OAuth app.

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'pixelbinmcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Pixelbin MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'pixelbinmcp_list_predictions',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "pixelbinmcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Pixelbin MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="pixelbinmcp_list_predictions",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user signs in once. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'pixelbinmcp_estimate_prediction_cost',
  toolInput: {
    operation: 'bg',
    plugin: 'erase',
  },
  connector: 'pixelbinmcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="pixelbinmcp_estimate_prediction_cost",
    tool_input={
        "operation": "bg",
        "plugin": "erase",
    },
    connection_name="pixelbinmcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `pixelbinmcp_estimate_prediction_cost`

EstimatePredictionCost · Read-only

Estimate the credits a PixelBin prediction will consume before running it. Always call this before create-prediction. Returns creditsPerOperation, totalCredits, and a confirmation_token required by create-prediction.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `operation` (`string`, required): Operation id under the plugin.
- `plugin` (`string`, required): Plugin id from list-predictions.
- `count` (`integer`, optional): Number of times this operation will run. Defaults to 1.
- `inputs` (`object`, optional): Operation-specific inputs that affect cost. Optional for fixed-cost plugins.

Example input: `{"operation":"bg","plugin":"erase"}`

### `pixelbinmcp_get_prediction`

GetPrediction · Read-only

Poll a PixelBin prediction by id. Returns status (ACCEPTED/RUNNING/SUCCESS/FAILURE) and, on SUCCESS, the result URL(s). Results are hosted ~30 days; use save-prediction-to-storage to persist permanently.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `prediction_id` (`string`, required): The prediction workflow id returned by create-prediction.

Example input: `{"prediction_id":"<prediction_id>"}`

### `pixelbinmcp_list_predictions`

ListPredictions · Read-only

List available PixelBin prediction plugins and operations. Returns a catalog with display names, credit costs, and categories. Use include_schema=true to get input schemas for create-prediction.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `categories` (`string`, optional): Optional comma-separated categories to filter (e.g. 'image-to-video,text-to-image').
- `include_schema` (`boolean`, optional): Include each plugin's input JSON Schema in the response. Default: `true`.

Example input: `{}`

### `pixelbinmcp_create_prediction`

CreatePrediction · Write

Start a PixelBin prediction (e.g. background removal, upscaling, watermark removal, image-to-video, image generation). ALWAYS call estimate-prediction-cost first to get a confirmation_token, present the credit cost to the user, and pass the token here. Image/video/PDF inputs must be public HTTPS URLs — use request-upload-url for local files or upload-asset-from-url for public URLs. Async: returns a prediction id; poll with get-prediction.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `input` (`object`, required): Operation-specific JSON input. Image/video/PDF values must be public HTTPS URLs.
- `operation` (`string`, required): Operation id under the plugin (e.g. 'bg').
- `plugin` (`string`, required): Plugin id from list-predictions (e.g. 'erase').
- `confirmation_token` (`string`, optional): Token returned by estimate-prediction-cost. Required to confirm credit spend.

Example input: `{"input":{},"operation":"bg","plugin":"erase"}`

### `pixelbinmcp_request_upload_url`

RequestUploadUrl · Write

Mint a presigned PUT URL to upload a local file to PixelBin storage. Returns uploadUrl, headers, a curl command, and hostedUrl (the permanent CDN URL). Use for local files when you have shell/curl access. For public URLs, use upload-asset-from-url instead.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `filename` (`string`, required): File name with extension (e.g. 'photo.jpg'). Supported: jpg/jpeg/png/webp/avif/gif/bmp/tiff/heic/heif, mp4/webm/mov/avi/mkv/mpeg/mpg, pdf.
- `access` (`string`, optional): Access level. Defaults to public-read. One of: `public-read`, `private`.
- `overwrite` (`boolean`, optional): Replace existing asset at same path. Defaults to false.
- `path` (`string`, optional): Optional folder path in PixelBin storage (e.g. 'mcp-uploads/'). Defaults to org root.

Example input: `{"filename":"photo.jpg"}`

### `pixelbinmcp_save_prediction_to_storage`

SavePredictionToStorage · Write

Persist a completed prediction's output to the user's PixelBin storage as a permanent asset. Use after a successful create-prediction when the user wants to keep the result beyond its ~30-day expiry.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `prediction_id` (`string`, required): The prediction workflow id whose output to persist.
- `access` (`string`, optional): Access level for the saved asset. Defaults to public-read. One of: `public-read`, `private`.
- `path` (`string`, optional): Optional folder path in PixelBin storage. Defaults to org root.

Example input: `{"prediction_id":"<prediction_id>"}`

### `pixelbinmcp_upload_asset_from_url`

UploadAssetFromUrl · Write

Ingest a publicly-reachable URL into the user's PixelBin storage. PixelBin fetches the asset server-side and returns a permanent CDN URL. Use when the user has a public URL; for local files use request-upload-url.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `url` (`string`, required): Public HTTPS URL of the asset. Must be reachable without auth.
- `access` (`string`, optional): Access level. Defaults to public-read. One of: `public-read`, `private`.
- `format` (`string`, optional): Optional file format override.
- `name` (`string`, optional): Optional asset filename without extension.
- `overwrite` (`boolean`, optional): Replace existing asset at same path. Defaults to false.
- `path` (`string`, optional): Optional folder path in PixelBin storage.

Example input: `{"url":"<url>"}`

## Related

Other Media connectors ([all 45](/agentkit/connectors/?category=media)):

- [Reddit](/agentkit/connectors/reddit/): Scalekit connector, OAuth, 105 tools
- [Diarize](/agentkit/connectors/diarize/): Scalekit connector, Access token, 3 tools
- [YouTube](/agentkit/connectors/youtube/): Scalekit connector, OAuth, 45 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
