An MCP Server for Social Media Carousels (Supaslides MCP)

Supaslides runs a remote MCP server at https://supaslides.app/mcp (Streamable HTTP). Connected agents can extract a brand from a URL, generate carousels, export PNG, PDF or MP4 files, share decks and schedule posts to Instagram, Facebook and X. It authenticates with a personal API key and is included on every plan, including Free.

This page is the reference: tools, client configs, the typical call chain, limits and security. If you want the plain-language walkthrough with prompts to paste, read how to create and schedule carousels from Claude or ChatGPT. The short setup lives in the MCP docs.

What the server does

It exposes the whole Supaslides loop as tools. A brand is built from a website (real colors, fonts, logo and voice, the same pipeline as URL to carouselin the app). Claude writes each carousel in that brand’s voice and picks a layout per slide. Exports render the same components the editor shows, and scheduling uses the same publishing queue as the app’s Schedule page. Every call runs as the owner of the API key, inside that account’s plan.

Tools

A typical tool chain

You rarely call these by hand. An agent reads the descriptions and chains them from a request like “make a carousel from acme.com and post it Monday at 9am.” Simplified, the chain looks like this:

create_brand       { url: "https://acme.com" }
  → brandId, colors, fonts, voice, starterIdeas
generate_carousel  { brandId, brief: "3 onboarding mistakes", slideCount: 7 }
  → carouselId, caption, slides, editorUrl
export_carousel    { carouselId, format: "video", combine: true }
  → jobId, status: "queued"
check_export       { jobId }
  → status: "done", downloadUrl
list_social_accounts { brandId }
  → socialAccountId (Instagram, Facebook Page, X)
schedule_carousel  { carouselId,
                     targets: [{ socialAccountId, format: "png-set" }],
                     scheduledFor: "2026-10-06T09:00:00-04:00" }
  → groupId, posts[].status: "scheduled"

Two details matter. scheduledFor is an ISO 8601 time with an offset, so tell the agent your time zone. And each schedule target is an account plus a format: png-set for a static carousel, video-set for animated per-slide videos on Instagram, or combined-video for one MP4.

Uploading local images

MCP arguments are JSON, so binary files don’t travel through them. The API key also lives in the client config, where the model can’t see it, which means an agent holding a file path has no credential to upload with. create_image_upload closes that gap. It returns a ready-to-run curl command whose link carries its own authorization, locked to one brand and valid for 30 minutes:

create_image_upload { brandId }
  → { curl: "curl -sS -F file=@/ABSOLUTE/PATH/TO/IMAGE.jpg \"https://supaslides.app/api/public/images?ticket=...\"" }

curl -sS -F file=@/Users/me/photo.jpg \
  "https://supaslides.app/api/public/images?ticket=..."
  → { imageId }

The agent runs the command in a shell, so this works in clients with terminal access, like Claude Code or Cursor. Scripting it yourself? Send the same multipart request with your API key and an explicit brand id:

curl -F file=@photo.jpg -F brandId=YOUR_BRAND_ID \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  https://supaslides.app/api/public/images

JPG, PNG or WebP, ideally under 4 MB. Images already online go through add_image with their URL instead.

Connecting a client

Create a key in Settings, under API keys. It is shown once. Then add the server. Claude Code:

claude mcp add --transport http supaslides https://supaslides.app/mcp \
  --header "Authorization: Bearer sk_YOUR_KEY"

Cursor, in .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "supaslides": {
      "url": "https://supaslides.app/mcp",
      "headers": { "Authorization": "Bearer sk_YOUR_KEY" }
    }
  }
}

Other clients that send custom headers should work too. The configs below follow each vendor’s documented schema. VS Code, in .vscode/mcp.json:

{
  "servers": {
    "supaslides": {
      "type": "http",
      "url": "https://supaslides.app/mcp",
      "headers": { "Authorization": "Bearer sk_YOUR_KEY" }
    }
  }
}

OpenAI’s Codex CLI, in ~/.codex/config.toml, with the key in the SUPASLIDES_API_KEY environment variable:

[mcp_servers.supaslides]
url = "https://supaslides.app/mcp"
bearer_token_env_var = "SUPASLIDES_API_KEY"
tool_timeout_sec = 180

OpenAI’s Responses API, as an entry in the tools array of your request. OpenAI does not keep header values between requests, so send the key every time:

{
  "type": "mcp",
  "server_label": "supaslides",
  "server_url": "https://supaslides.app/mcp",
  "headers": { "Authorization": "Bearer sk_YOUR_KEY" }
}

Not supported yet: custom connectors in claude.ai and the Claude apps, and the ChatGPT app. Both sign in with OAuth, and the server only accepts API keys today. OAuth is planned.

Limits and timeouts

• Durations. create_brand 60 to 120 s, generate_carousel 15 to 40 s, PNG export 30 to 90 s. Video exports take a few minutes, so poll check_export. Static formats in schedule_carousel render before the call returns (30 to 90 s).
• Client timeouts. Current Claude Code versions wait long enough by default. If you set MCP_TOOL_TIMEOUT, keep it at 180000 or more. Codex CLI defaults to 60 seconds, hence tool_timeout_sec = 180 above.
• Plan quotas. The same as the app: brands (1, 3 or 10), carousels a month (3, 20 or 80), image library size (10, 50 or 200) and scheduled posts a month (0, 60 or 200) on Free, Pro and Studio. Free exports Instagram and TikTok sizes with a watermark. Errors name the limit that ran out. See pricing.
• Daily caps. Brand extraction and generation have per-account daily caps on top of the monthly quota, and share links are capped at 200 a day.
• Downloads. A PNG export link is valid for 60 minutes, and check_export issues a fresh 10-minute link. The files are deleted after 48 hours.

Security

• API keys. A key is sk_ plus 40 random characters. Only its SHA-256 hash is stored, the full key is shown once, and you can revoke it in Settings at any time, which disconnects anything using it. One key per client makes revoking painless.
• The model never sees the key. It sits in your client config as a header, not in the conversation or the tool arguments.
• Upload tickets. The links from create_image_upload are signed, work for one brand only, can only upload images, and expire after 30 minutes.
• Account scope.Every tool call runs as the key’s owner and can only reach that account’s brands, carousels, images and connected accounts.
• Public by design. Share links are public pages. revoke_share takes one down. Scheduling publishes to real accounts, so consider keeping tool approval on in your client for the schedule tools.

Ways to automate carousels, compared

An MCP server is one of three common routes. They suit different jobs:

The practical difference: template APIs render a design you already have, while the MCP route also does the brand extraction and the writing. If your look is locked in a template and you only need volume, a template API is a good fit. If you want an agent to go from a URL to a posted carousel, that is what the MCP server is for.

Try it

No account yet? Build a deck without signing up, then create a free account and an API key. Setup takes one command in Claude Code.