Guide · By PostBoost team · · Markdown
A social media API is called by code you write; an MCP server is called by an AI assistant. With the API, your program decides every request: which endpoint, in what order, with which arguments. With MCP (Model Context Protocol), the assistant reads a list of tools and decides which ones to call to do what you asked. Use the API for jobs that must run the same way every time, MCP for work that needs judgement in a conversation, and both when you want an assistant to draft while your code publishes and watches.
The two are not rivals. In PostBoost they reach the same posts, accounts and safety checks, so the question is only who drives each step.
The difference in one table
| REST API | MCP server | |
|---|---|---|
| Who decides the calls | Your code | The AI assistant, from your request |
| How it is described | Endpoints in an OpenAPI spec, plus SDKs | Tools with a name, description and JSON input schema, listed with tools/list |
| How it is called | HTTP requests (POST /posts) |
JSON-RPC tools/call over stdio or Streamable HTTP |
| Same input, same result? | Yes, the request is fixed in your code | Not guaranteed: the model can pick other tools or arguments |
| Sign-in in PostBoost | Access token or scoped API key | OAuth sign-in in the client (connector), or an access token |
| Reacting to events | Webhooks call your URL | Only when the assistant asks |
| Setup | Write and host code | Add a URL to Claude, ChatGPT, Cursor or VS Code |
| Best for | Pipelines, products, bulk jobs, CI | Drafting, reviewing, one-off questions, analysis |
The MCP specification defines two standard transports, stdio (the client starts the server as a local process) and Streamable HTTP (one HTTP endpoint such as https://example.com/mcp). PostBoost's three MCP servers are remote Streamable HTTP endpoints, so there is nothing to install.
The same post, both ways
Say you want one LinkedIn post scheduled for Tuesday at 09:00 London time.
With the API
Your code sends one request. The Idempotency-Key header makes a retry after a timeout safe: the same key and body within 24 hours returns the first response with Idempotent-Replayed: true instead of creating a second post.
curl -X POST "https://postboost.co/app/api/$WORKSPACE_UUID/posts" \
-H "Authorization: Bearer $POSTBOOST_API_TOKEN" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: 6f1c2b8e-4d3a-4f5e-9b7c-2a1d0e9f8c7b" \
-d '{
"accounts": [12],
"versions": [{
"account_id": 0,
"is_original": true,
"content": [{ "body": "Our November product update is live." }]
}],
"schedule": true,
"date": "2026-11-03",
"time": "09:00",
"timezone": "Europe/London"
}'
You chose the account id, the text, the time and the order of operations. The social media API request builder writes this request for you in curl or any of the 9 SDK languages.
With MCP
You add the PostBoost connector (https://postboost.co/mcp) to your assistant and ask:
Draft a LinkedIn post about our November product update and schedule it for Tuesday 09:00 London time.
The assistant then plans the calls itself. A typical run on the connector looks like this:
list-workspaces() → workspace uuid
list-accounts({ workspace }) → LinkedIn account id 12
get-brand-voice({ workspace }) → tone and words to avoid
validate-post({ workspace, account_ids: [12], content: "…" }) → no errors
create-post({ workspace, account_ids: [12], content: "…",
schedule: "scheduled", scheduled_at: "2026-11-03 09:00",
timezone: "Europe/London", idempotency_key: "…" })
You never named a tool. The assistant read the tool descriptions, found the account, wrote the text in your brand voice and checked it before creating anything. That flexibility is the point of MCP, and also its cost: the model may take a different path next time, and every tool definition and intermediate result passes through its context. Anthropic's engineering team notes that tool descriptions "occupy more context window space, increasing response time and costs", and that "every intermediate result must pass through the model".
When the API is the better choice
- Repeatable jobs. A CMS that posts every new article, a weekly report export, a migration of 500 scheduled posts. You want the same request every time, not a fresh decision.
- Your own product. If your app lets users schedule posts, your backend calls the API. The SDKs cover Python, Node.js, PHP, Go, Ruby, Java, C#, Rust and a CLI.
- Reacting to events. Webhooks send
post.publishedorpost.publishing_failedfor each account to your URL. An MCP server does not start your assistant when something happens; it answers when the assistant calls it. - Least privilege. A scoped API key is bound to one workspace, carries only the abilities you pick (
read,write,publish,ai,webhooks) and can be limited to some accounts. A key withoutpublishgets403 insufficient_scopewhen it tries to schedule.
The API has no per-call fees on any plan, including Free, and accepts up to 60 requests per minute per user (rate limits).
When MCP is the better choice
- Work that needs judgement. "Turn this release note into posts for LinkedIn and X, and move anything that clashes with Friday's launch." The assistant reads, writes and decides.
- No code at all. A marketer adds one URL to Claude or ChatGPT and signs in. The MCP config generator gives the exact steps or config for Claude, ChatGPT, Claude Code, Cursor, VS Code and more.
- Questions across data. "Which of last month's posts did best on LinkedIn, and when should the next one go out?" The connector has analytics and
get-best-posting-timestools, so the assistant answers from your own numbers. - Drafts for review. The connector's
create-postsaves a draft unless you ask it to schedule, so the assistant can prepare a week of posts and a person checks them in the calendar.
PostBoost's three MCP servers
| Server | URL | Sign-in | Tools |
|---|---|---|---|
| Connector (recommended) | https://postboost.co/mcp |
OAuth in the client, or an unscoped access token | Curated workflow tools with titles and safety annotations |
| Advanced (API mirror) | https://postboost.co/mcp/postboost |
Access token or scoped API key | One tool per REST API operation, generated from the OpenAPI spec |
| Free tools | https://postboost.co/mcp/tools |
None | One tool per free tool, such as count-characters and split-thread |
The connector refuses scoped API keys, because its tools run outside the API's scope checks. If an agent needs a narrow key, point it at the advanced server, which honours scopes. The MCP docs list every tool on each server.
The guardrails are the same on both paths
A common worry is that MCP is the "loose" path. In PostBoost the connector's create-post, update-post, schedule-post and add-post-to-queue apply the same agent guardrails as the API:
| Check | REST API | Connector (MCP) |
|---|---|---|
| Dry run | POST /{workspaceUuid}/posts/validate |
validate-post (same arguments as create-post) |
| Safe retry | Idempotency-Key header |
idempotency_key argument |
| Duplicate within 24 hours | 409, code: duplicate_post |
Tool error naming duplicate_post |
| Daily cap per account | 429 |
Tool error naming the code |
| Override a deliberate repeat | allow_duplicate: true |
allow_duplicate: true |
Connector tools also carry MCP annotations such as readOnlyHint and destructiveHint, so your client can ask before a change. Treat those as hints for the client, not as protection: the MCP specification says clients must treat annotations as untrusted unless they come from a trusted server, and that there should always be a human able to deny a tool call. The limits that matter are the ones the server enforces. For the full setup (approval roles, scoped keys, logs), read how to let an AI agent post to social media safely.
Using both together
Most teams end up with a split like this:
- The assistant drafts. In Claude or ChatGPT, someone asks for a week of posts from a blog article. The connector saves them as drafts, written in the workspace brand voice.
- A person approves in the PostBoost calendar, or the assistant schedules what was agreed.
- Code watches. A small service subscribed to
post.publishing_failedwebhooks gets one delivery per failed account, with the error. It alerts the team, or an assistant runsretry-failed-postonce the cause (often an expired connection) is fixed. The failed post guide lists the usual causes. - Pipelines stay on the API. The RSS import, the CMS hook and the monthly report keep running on fixed requests with idempotency keys.
The posts, accounts and history are the same whichever path created them, so nobody has to choose one forever.
Which one to start with
- Building software, or a job that runs on a schedule: start with the API reference and the request builder.
- Working inside an AI assistant: add
https://postboost.co/mcpwith the MCP config generator and ask it to list your accounts. - Comparing providers: the best social media MCP servers page sets PostBoost next to the alternatives.
The REST API is included on every plan, Free too, with no per-call fees. Create a free account, connect your first network and try the same post both ways.
Do this in PostBoost
Free tools for this guide
Free tool
Social media API request builder
Build a create-post request for the PostBoost social media API and copy it as curl, Python, Node.js, PHP, Go, Ruby, Java, C#, Rust or the CLI.
Free tool
MCP server config generator for social media
Get the exact MCP setup to connect Claude, ChatGPT, Claude Code, Cursor, VS Code, Codex, Gemini CLI or n8n to PostBoost's social media MCP server.
FAQ
What is the difference between a social media API and an MCP server?
Who decides the calls. With a REST API your code chooses every request, its order and its arguments. With an MCP server an AI assistant reads a list of tools with descriptions and input schemas, then picks which tool to call and with what arguments to carry out what you asked.
Does MCP replace a REST API?
No. An MCP server is usually a layer over the same service the API exposes. PostBoost's advanced MCP server is generated from its OpenAPI spec with one tool per API operation, and the connector's post tools apply the same duplicate, daily-cap and idempotency rules as the API.
Which is better for scheduled, recurring posts?
The API. A cron job, a CMS hook or a script should send the same request every time, with an Idempotency-Key header so a retry never posts twice. An assistant adds a model decision to every run, which you want when the content needs judgement and not when it is the same job each day.
Do I need to write code to use a social media MCP server?
No. In clients such as Claude, ChatGPT, Cursor or VS Code you add the server URL, sign in, and ask in plain words. PostBoost's connector at https://postboost.co/mcp uses OAuth, so there is no token to copy.
Can an MCP server tell my assistant when a post fails?
Not on its own: an MCP server answers when the assistant calls it. To react to a failure as it happens, subscribe a webhook to post.publishing_failed through the API, then let your handler or an assistant run retry-failed-post once the cause is fixed.
Which PostBoost MCP server should I use?
The connector at https://postboost.co/mcp for assistants: curated workflow tools and OAuth sign-in. The advanced server at https://postboost.co/mcp/postboost when an agent needs every API operation or a scoped API key. The free tools server at https://postboost.co/mcp/tools needs no account.
Sources
- Model Context Protocol specification (2025-11-25): Tools
- Model Context Protocol specification (2025-11-25): Transports
- Anthropic Engineering: Code execution with MCP (2025-11-04)
- PostBoost docs: MCP server
- PostBoost docs: authentication and scoped keys
- PostBoost docs: rate limits
- PostBoost docs: webhooks