Docs

Preflight MCP server

The Preflight MCP server is a hosted Model Context Protocol server that lets an AI assistant — Claude, ChatGPT, Cursor, Claude Code or anything that speaks MCP — schedule, validate and publish social media posts to twelve networks from a Preflight workspace, read their figures and answer their comments. It is for teams and agencies who already write with an assistant and want it to post, and for developers building agents that publish. The endpoint is https://preflight.social/mcp (Streamable HTTP). Clients sign in with OAuth 2.1 — PKCE and dynamic client registration, so a URL is all they need — or send an API key as a bearer token. It comes with the Pro and Studio plans.

Endpoint: https://preflight.social/mcp
Transport: Streamable HTTP, JSON-RPC 2.0
Auth: OAuth 2.1 (PKCE, DCR) or API key

Connect it

OAuth clients need only the URL: the server publishes its authorization server at /.well-known/oauth-authorization-server, the client registers itself, and you sign in to Preflight and approve the scopes once. Clients with a headers field can send an API key from Settings → API keys instead.

Claude.ai and Claude Desktop

Settings → Connectors → Add custom connector. Name it Preflight, paste https://preflight.social/mcp, Add, then Connect and sign in. Claude asks for the scopes it was granted on the consent screen.

Claude Code

claude mcp add --transport http preflight https://preflight.social/mcp

Then /mcp in the session to sign in. With a key instead of OAuth, add --header "Authorization: Bearer sk_live_…".

ChatGPT

Settings → Connectors → Create (developer mode on plans that need it). MCP server URL https://preflight.social/mcp, authentication OAuth, then sign in. The tools appear in a chat once the connector is enabled for it.

Cursor and other editors

In .cursor/mcp.json (or the editor's equivalent):

{
  "mcpServers": {
    "preflight": {
      "url": "https://preflight.social/mcp",
      "headers": { "Authorization": "Bearer sk_live_…" }
    }
  }
}

Leave out headers and Cursor runs the OAuth flow instead.

How an assistant publishes

list_channels — the connected accounts; every other tool takes their ids.
create_media_upload → PUT the bytes to the signed URL(s) → complete_media_upload → get_media until it is ready. Or pass a public sourceUrl and skip the PUT.
validate_post — the same checks the composer runs: text length the way each network counts it, hashtags, files, video length and fps, per-network settings, the plan's allowance. Nothing is created.
create_post with an idempotencyKey — scheduled, into the queue, published now (with confirmPublishNow) or as a draft.
get_post — what happened on every channel; retry_post for the ones that failed.

A TikTok post needs tiktok.privacy from tiktok_creator_info; a pin needs pinterest.boardId from list_pinterest_boards. Settings a network does not take come back as warnings rather than being dropped, and a refusal for a plan limit carries limit and upgradeTo.

Every tool

26 tools, 15 of them read-only. A key or token sees only the tools its scopes allow: posts:read, posts:write (drafts), posts:publish (anything that goes live), media:read, media:write. "Changes things" is the server's destructiveHint: the tool alters what people can see or what will go out.

Tool	What it does	Scopes	Effect
`list_channels` Connected channels	The social accounts this workspace can publish to: the network each belongs to, whether it needs reconnecting, whether the plan has paused it, its time zone, and whether posts on it can be deleted from the network. channelId is what every other tool takes.	posts:read	Read-only
`list_posts` Posts	Posts, most recent first by when they went out. Filter by status, channel, network, a from/to window, or failedOnly. Each channel's status, link, error and whether it is permanent. Pages with a cursor.	posts:read	Read-only
`post_performance` How one post performed	One published post's figures on one network: views, likes, comments, and where it can be measured, how much of the video was watched, the retention curve and where the views came from.	posts:read	Read-only
`analytics_summary` Totals for a period	Totals across a recent period: how many posts went out, and what they earned.	posts:read	Read-only
`next_queue_times` Next queue slots	When the queue would next reach each channel, from its posting schedule. Null for a channel with no slots set up.	posts:read	Read-only
`draft_post` Write a text draft	Writes a text-only draft into the composer for a person to review, choose a time for and publish. It does not publish and it does not schedule. Takes an idempotencyKey so a retry does not leave two drafts.	posts:write	Writes
`create_media_upload` Start a file upload	Starts uploading a video or image. The file never passes through the server: the answer carries signed URLs to PUT the bytes to (one, or one per part for files over 16 MB). Or pass sourceUrl and the server fetches a public URL itself.	media:write	Writes
`complete_media_upload` Finish a file upload	Confirms the bytes are in, after the PUTs from create_media_upload. For a multipart upload pass every part with the ETag its PUT returned.	media:write	Writes
`get_media` File status	A file and where it is: awaiting_upload, ingesting, processing, ready, failed (with error) or deleted. A post can use it once it is ready.	media:read	Read-only
`validate_post` Check a post before creating it	A dry run of create_post with the same arguments: checks every channel, file, time and network limit, the plan's monthly allowance and paused channels, and says what the server would do. Nothing is created.	posts:read	Read-only
`create_post` Create, schedule or publish a post	Creates a real post on any mix of networks: scheduled, into the queue, published now (with confirmPublishNow) or saved as a draft. Takes files and per-network settings such as youtube.title or tiktok.privacy. idempotencyKey is required, so a retry never publishes twice.	posts:write + posts:publish	Changes things
`get_post` Post status	One post and what happened on every channel: status, link, the network's id, any error with its code and whether it is permanent, when it will be tried again, and any warning.	posts:read	Read-only
`update_post` Edit or reschedule a post	Changes a post that has not gone out yet: caption, link, files, channels, network settings and when it goes. Giving a draft a time schedules it for real, which needs posts:publish.	posts:write	Changes things
`delete_post` Delete or cancel a post	Deletes a post from Preflight: a draft, or a scheduled post that then never goes out. What is already live stays on the networks. Cannot be undone: needs confirmDelete.	posts:write	Changes things
`retry_post` Try the failed channels again	Sends a post again to the channels where it failed, straight away; channels where it went out are left alone.	posts:write + posts:publish	Changes things
`edit_published_post` Edit a post that is live	Changes the text (and, where the network has one, the title) of a post that has already gone out, on that network itself. Only where the network allows it.	posts:write + posts:publish	Changes things
`delete_published_post` Take a post down from a network	Deletes a post that has gone out from the network itself. Only where the network allows it. Preflight keeps the record, marked as deleted. Needs confirmDelete.	posts:write + posts:publish	Changes things
`list_comments` Comments on a post	The comments under one channel's copy of a published post, read live from the network, with what this account may do with them (reply, hide, like, delete, edit).	posts:read	Read-only
`act_on_comment` Reply to or moderate a comment	Acts on one comment, as the connected account and in public: reply (with an idempotencyKey), edit, hide, unhide, like, unlike, or delete (with confirmDelete).	posts:write + posts:publish	Changes things
`post_insights` Figures for one post over time	One channel's copy of a published post: its current figures, how they grew reading by reading, and on YouTube the retention curve and traffic sources.	posts:read	Read-only
`list_pinterest_boards` Pinterest boards	The boards of a Pinterest channel. Every pin needs one: pass its id as pinterest.boardId.	posts:read	Read-only
`list_youtube_playlists` YouTube playlists	A YouTube channel's playlists. Pass one's id as youtube.playlistId to add the video to it.	posts:read	Read-only
`create_youtube_playlist` Create a YouTube playlist	Creates a playlist on a YouTube channel. A playlist of the same name that already exists is returned instead of making a second.	posts:write + posts:publish	Writes
`tiktok_creator_info` What a TikTok account allows	What TikTok allows this account right now: the privacy levels it may post with, whether comments, duets or stitches are off, and the longest video it takes.	posts:read	Read-only
`audience` Followers per channel	Followers on each channel whose network reports them, as daily readings over a period, with the change across it.	posts:read	Read-only
`get_usage` Plan and what is left of it	The workspace's plan and this month's allowance: publishes used and left, channels connected and paused, bytes sent, AI rewrites and reviews, when it resets, and the plans above.	posts:read	Read-only

The same workspace is reachable over REST — see the API documentation (authentication, media uploads, posts, per-network options, webhooks, errors) and openapi.json. What each network accepts is on the limits page and as JSON at /v1/platforms. The server card for catalogues is at /.well-known/mcp.json.

Questions

The MCP server

Does Preflight have an MCP server?

Yes. https://preflight.social/mcp is a hosted MCP server over Streamable HTTP. Claude and ChatGPT connect with the URL alone and sign in through OAuth; any other client can send an API key as a bearer token. It has 26 tools covering uploads, validation, scheduling, publishing, editing, retries, comments and analytics.

Which plans include the MCP server?

API keys, webhooks and the MCP server come with the Pro and Studio plans. Every tool runs as the workspace the key or token belongs to, with that key's scopes.

Can an assistant publish without asking me?

Only what the token's scopes allow. posts:read sees; posts:write writes drafts; posts:publish is a separate scope for anything that goes live. Publishing at once needs confirmPublishNow, and deleting a post, taking it down or deleting a comment needs confirmDelete — the tool descriptions tell the assistant to ask first. create_post requires an idempotencyKey, so a retried call never publishes twice.

Does the assistant check the networks' rules before publishing?

validate_post is a dry run of create_post with the same arguments: every channel, file, time and network limit, the plan's monthly allowance and paused channels. It is the same validation the web composer and the REST API use, and the tools tell the assistant to run it before create_post.

Do files pass through the assistant?

No. create_media_upload returns signed URLs to PUT the bytes to directly, or takes a public sourceUrl the server fetches itself. The assistant then calls complete_media_upload and waits for get_media to report ready.

Write it once. Let the rules be our problem.

Preflight checks every post against each network's rules before it leaves, then publishes it to twelve networks. Free plan, no card.

Get started See pricing