Pixelbin MCP

Live

OAUTH 2.1

IMAGE PROCESSING

Media

Pixelbin MCP gives agents authenticated access to image and video processing: upload assets, run predictions like background removal and upscaling, and save results to storage.

  • Per-user credentials: each call uses the actual user's token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
Pixelbin MCP
agent · Acme Q3
Run
Remove the background from this product photo and save it.
S
pixelbinmcp_create_prediction
176ms
Pixelbin agent
Background removed, prediction pred_5521 completed. Saved to storage as a permanent asset.
Sources: 1 image, 1 prediction
pixelbinmcp
1 prediction
18:29
Message Claude...

Tools your media agent reaches for on Pixelbin, scoped per user.

CALL ANY TOOL
Process images and video end to end: estimate cost, run predictions, and persist results to storage, scoped to each user's own Pixelbin account.
pixelbinmcp_list_predictions
List predictions
List available PixelBin prediction plugins and operations, with display names, credit costs, and categories.
Parameters
Name
Type
Required
Description
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.
pixelbinmcp_estimate_prediction_cost
Estimate prediction cost
pixelbinmcp_create_prediction
Create prediction
pixelbinmcp_get_prediction
Get prediction
pixelbinmcp_request_upload_url
Request upload URL
pixelbinmcp_save_prediction_to_storage
Save prediction to storage
Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Pixelbin tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["pixelbinmcp"], toolNames: [
    "pixelbinmcp_list_predictions",
    "pixelbinmcp_estimate_prediction_cost",
    "pixelbinmcp_create_prediction"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Remove the background from this product photo and save it" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["pixelbinmcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Remove the background from this product photo and save it" }],
  tools,
});

// Execute the tool call with the user's vaulted pixelbinmcp credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["pixelbinmcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Remove the background from this product photo and save it" }],
  tools,
});

// Tool call runs with the user's vaulted pixelbinmcp credential
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["pixelbinmcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "pixelbinmcp_agent",
  model: "gemini-2.5-pro",
  instruction: "Pixelbin tools scoped to this user",
  tools,
});

await agent.run("Remove the background from this product photo and save it");
Try these prompts
Copy any prompt into your agent. Each maps directly to a Pixelbin MCP tool. Click to copy, paste into your agent, done.
Run predictions
Copy the prompt
Copied
Remove the background from this product photo.
Copy the prompt
Copied
Upscale this image to 4x resolution.
Copy the prompt
Copied
Generate a short video from this still image.
Cost and discovery
Copy the prompt
Copied
List available prediction plugins for image editing.
Copy the prompt
Copied
Estimate the credit cost of upscaling 10 images.
Copy the prompt
Copied
Show the input schema for the watermark-removal plugin.
Upload and save
Copy the prompt
Copied
Upload this local photo.jpg and give me the CDN URL.
Copy the prompt
Copied
Save prediction pred_5521's result to permanent storage.
Copy the prompt
Copied
Poll the status of prediction pred_5521.
SEE HOW AUTH WORKS
Your users connect once. Their Pixelbin MCP credentials stay vaulted, every call is checked, and every action is logged.
1
Authorize
Your user connects
Pixelbin MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Pixelbin MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Pixelbin MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Pixelbin MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other media and creative connectors.
GTM
Salesforce customer insights agent
Surface Salesforce account activity, NPS signals, and renewal flags into Slack threads for the account team.
GTM
HubSpot to Slack updates agent
Watch HubSpot deal stage changes and post structured updates to the right Slack channel. Reps stop checking the CRM all day.
SALES
Deal intelligence agent
Combine Gong, Attio, and Slack signals to surface deal risks and next-best actions. Updated after every call.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
Other connector libraries treat auth as a demo afterthought. Scalekit starts with identity, scope enforcement, and audit. Connectors follow.
01.
Shared tokens break per-user analytics
A shared Pixelbin MCP token looks fine in a demo. In production every prediction looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Pixelbin MCP today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Pixelbin MCP as the user or through a shared key?
As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every Pixelbin MCP action in your audit trail is attributed to a real user, not a shared service account.
Where is the Pixelbin MCP token stored?
In an AES-256 encrypted vault with per-tenant namespacing. Tokens are resolved at request time, never enter LLM context, refresh automatically, and can be revoked from one dashboard.
Can I limit what the agent does in Pixelbin MCP?
Yes. Filter by tool name in listScopedTools to expose only what you want. Scalekit also enforces scope checks before every API call.
What happens when a user revokes access?
The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.
Does the agent spend credits without the user knowing the cost?
No. estimate_prediction_cost returns a confirmation_token that create_prediction requires, so the agent must surface the credit cost before it can spend against the user's account.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""pixelbinmcp"": {
""url"": ""https://mcp.scalekit.com/pixelbinmcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.pixelbinmcp]
url = ""https://mcp.scalekit.com/pixelbinmcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""pixelbinmcp"": {
""url"": ""https://mcp.scalekit.com/pixelbinmcp"",
""type"": ""http""
}
}
}