PostNitro MCP Server

The PostNitro MCP server lets AI assistants and agents — Claude (Desktop, Code, and Cowork), Cursor, ChatGPT, and any other Model Context Protocol  client — create carousels and image posts, manage brand kits and connected social accounts, and schedule posts directly. Instead of writing REST API calls, you connect the server once and your AI assistant gets ready-made tools covering carousel and image generation, brands, social accounts, and scheduling — using the same Embed API key and credits as the REST API.

Quick Reference

Connecting

Claude Code

claude mcp add --transport http postnitro https://mcp.postnitro.ai/mcp \
  --header "Authorization: Bearer pn-your-api-key-here"

Claude Desktop / JSON configuration

Add the server to your MCP configuration file (for Claude Desktop: claude_desktop_config.json):

{
  "mcpServers": {
    "postnitro": {
      "type": "http",
      "url": "https://mcp.postnitro.ai/mcp",
      "headers": {
        "Authorization": "Bearer pn-your-api-key-here"
      }
    }
  }
}

Cursor

Cursor has native MCP support — add the same JSON configuration above to your Cursor MCP settings.

Other MCP clients

Any client that supports the Streamable HTTP transport can connect using the server URL and the Authorization: Bearer header shown above.

Replace pn-your-api-key-here with your actual API key. The key is the same one used for the Embed API — see Obtaining an API Key.

Saved defaults

Rather than passing templateId, brandId, and presetId on every call, save them once with postnitro_set_defaults. They persist across sessions and are applied automatically whenever a generate/import tool omits them.

Auto-selection: if a required ID is missing and your workspace has exactly one candidate (e.g. a single AI preset), the server selects it automatically. If several exist, the error lists the candidate IDs so the assistant can choose without a separate lookup.

Carousel identifiers — embedPostId vs designId

Generation produces two distinct IDs:

Scheduling’s designId resolves against the design table — passing an embedPostId where a designId is expected fails with 400 "Design not found." Every tool that returns a completed carousel (postnitro_get_output, postnitro_generate_and_wait, postnitro_import_and_wait) surfaces a top-level designId field to bridge generation into scheduling. The one-step postnitro_generate_and_schedule tool resolves it automatically.

Available Tools

Configuration

Discovery

Creation — carousels

Carousels are multi-slide posts (postType: "CAROUSEL").

Creation — image posts

Image posts are single-slide posts (postType: "IMAGE") — the image-maker equivalents of the carousel tools.

Status & Output

Brands

See the Brands API for full field definitions.

Social accounts

See the Social Accounts API for full field definitions.

Scheduling

postnitro_create_scheduled_post and postnitro_update_scheduled_post take a designId (from postnitro_get_output, not an embedPostId), postContent captions per platform, selectedAccounts, and per-platform settings objects. Which settings object is required depends on the platforms selected and whether a designId is attached — see Platform settings for the full reference.

One convention worth knowing: when a design’s output is PDF and the post targets LinkedIn, the correct linkedinPostSettings.postType is "document" (with a 5–90 character postTitle) rather than "carousel". postnitro_generate_and_schedule applies this automatically; the other schedule tools pass your choice through as-is.

Full CRUD for scheduling is also available via the Schedule API if you need it outside an AI assistant.

Combined helper

The generated design is attached automatically — don’t pass designId unless you want to attach a different, pre-existing design instead. If scheduling fails after generation succeeds, the tool returns the generated designId so you can retry with postnitro_create_scheduled_post without regenerating (which would re-consume credits).

Carousels vs. image posts

Both post types share the same lifecycle (initiate → poll → output), the same identifiers, and the same output shape. They differ only in the content you pass:

Image tool inputs

postnitro_generate_image / postnitro_generate_image_and_wait (AI content):

• aiGeneration (required) — { type, context, instructions }. type is one of text, article, x; context is the topic/prompt or a URL.
• templateId, brandId, presetId, responseType, requestorId — all optional if you’ve saved defaults; otherwise provide them. responseType is PDF | PNG | DESIGN.

postnitro_import_image / postnitro_import_image_and_wait (your own content):

• slide (required) — a single object, not an array, with no slide type. Only heading is required; sub_heading, description, cta_button, image, and background_image are optional.
• Infographic layout is supported: set layoutType: "infographic" and provide layoutConfig (same shape as carousel infographics — columnData with caller-provided ids, content items, etc.).
• templateId, brandId, responseType, requestorId — optional if you’ve saved defaults.

AI image generation (generateImages)

All four creation tools — postnitro_generate_carousel, postnitro_import_carousel, postnitro_generate_image, postnitro_import_image (and their _and_wait variants) — accept an optional generateImages object. When present, the server generates AI images and bakes them into the design before rendering. See the REST reference for the full behavior (best-effort, credits, plan limits).

The one difference between MCP/CLI and the direct REST API: generateImages.context is compulsory over MCP and the CLI, because the AI agent composes it for the user. On direct REST API calls the same field is optional (it falls back to aiGeneration.context on generate, or an empty string on import). Everything else about generateImages is identical across both.

Omit the generateImages object entirely to skip AI image generation (default). Image generation is best-effort and adds latency — the post still completes without images if it fails or isn’t permitted (e.g. free plan or over the org’s AI-image quota), recorded as a GENERATE_IMAGES step in postnitro_check_status.

Typical Agent Workflow

1. Discover — call postnitro_list_templates, postnitro_list_brands, and postnitro_list_ai_presets to find valid IDs (or postnitro_set_defaults once to skip this in future sessions)
2. Create — for a carousel call postnitro_generate_and_wait (AI) or postnitro_import_and_wait (your own content); for a single image call postnitro_generate_image_and_wait or postnitro_import_image_and_wait. These handle polling for you
3. Use the output — the tools return PNG URLs (one per slide) or a single PDF URL, plus a designId, ready to download, publish, or schedule
4. Schedule (optional) — call postnitro_create_scheduled_post with the designId, or skip straight there with postnitro_generate_and_schedule

For long-running generations or custom polling, use the non-waiting tool (postnitro_generate_carousel / postnitro_import_carousel / postnitro_generate_image / postnitro_import_image) followed by postnitro_check_status and postnitro_get_output.

Response conventions

• Successful tool results are JSON. Create/update tools return the affected object plus a top-level scheduledPostId (for schedule tools) so it lines up with the scheduledPostId other tools expect as input.
• Tools may include a warnings array — non-fatal advisories, e.g. a media post with no design attached, or a LinkedIn document post missing a valid postTitle.
• Errors from the API are surfaced verbatim as PostNitro API Error (<status>): <message>. See the Schedule API error reference for scheduling-specific messages.

Credits

The MCP server consumes the same credits as the Embed API:

• Content import: 1 credit per slide
• AI generation: 2 credits per slide
• Free plan: 5 credits per month (no card required) — paid plans start at $10/month for 250 credits

MCP vs. Embed API vs. Embed SDK

Support

• Email: support@postnitro.ai
• Live Chat: Available on postnitro.ai 
• More details: postnitro.ai/mcp