How to schedule social media posts with MCP

You can schedule social media posts with MCP by connecting an AI client to PostSider’s hosted server, selecting a real connected channel, and calling its posting tools. Start with one draft. Check the saved content, explicitly confirm the publishing time, then read back that same post after scheduling. A confident chat reply is not evidence that your calendar changed.

AI & Agents | One post, checked from connection to calendar

In short

• Connect to https://mcp.postsider.com/mcp with a remote HTTP client that supports OAuth.
• Create an explicitly authorized draft, check it, and confirm the exact channel and time before scheduling.
• Read the changed post by its returned ID. Report saved facts, not an assumed publishing outcome.

The hosted connection uses HTTP and OAuth, not a local install

PostSider’s hosted MCP endpoint is https://mcp.postsider.com/mcp. It uses Streamable HTTP, with OAuth discovery pointing to https://api.postsider.com as the authorization server. You do not need to launch a local PostSider MCP process for this route.

You need a PostSider account with a connected social media channel and a client that supports remote HTTP MCP servers and OAuth. Claude Code is one documented option. Its official MCP instructions cover browser authentication.

Add the server from your terminal:

claude mcp add --transport http postsider https://mcp.postsider.com/mcp

Open Claude Code, enter /mcp, select PostSider, and follow the browser sign-in flow. Review the organization and requested permissions before consenting. This workflow needs posts:read for inspection and posts:write for creation and scheduling; a read-only grant cannot perform the writes.

Do not paste your API key into the chat or append it to this URL. The remote endpoint expects an OAuth access token, which the client handles after authorization. Its public resource metadata lists the authorization server and supported scopes.

Setup checked on October 10, 2026: discovery returned those scopes, an unauthenticated POST returned 401 with an OAuth discovery challenge, and GET on /mcp returned 405. Opening the endpoint in a browser is not a connection test. Some older PostSider setup documentation describes a different local workflow; use this hosted URL and the client’s current remote connection instructions.

A read-only check must identify the publishing destination

Call postsider_list_channels before preparing a write. Select the channel from its returned name, platform, and ID, rather than guessing an ID or assuming the first LinkedIn account is yours.

Start with this request:

List my connected PostSider channels. Do not create or modify anything.
Show the channel names, platforms, and IDs so I can select one.

If two accounts look similar, resolve the choice before continuing. This matters for agencies and anyone who maintains both a personal profile and a company page.

Next, call postsider_get_publishing_state with {}. Stop if the organization is paused. Inspect the intended date range with postsider_list_posts, which takes startDate and endDate, plus an optional customer filter.

Use postsider_find_slot with channelId only if you want the channel’s next free queue time. It returns a UTC date based on the configured queue. It does not choose a time based on your marketing goal, and a read does not reserve a slot.

For this walkthrough, choose your own time instead. The illustrative target is October 13, 2026, at 10:00 AM in America/New_York, or 2026-10-13T14:00:00Z. Replace it with a future time when you run the workflow. Avoid requests such as “tomorrow morning” without a timezone.

Explicit draft inputs prevent an accidental schedule

Set type: "draft" when saving work for inspection. The create tool defaults to schedule, and even drafts require a date in the current contract. Omitting the action is a publishing decision you did not make.

The sequence below is illustrative, not a transcript or a record of a post created for this article. It uses one text-only LinkedIn post to keep media handling out of the first test.

Show the proposed copy, destination, and timestamp in chat. Ask for permission to save that exact draft. Once granted, call postsider_create_post with this argument shape:

{
  "type": "draft",
  "date": "2026-10-13T14:00:00Z",
  "shortLink": false,
  "posts": [
    {
      "channelId": "CHANNEL_ID_FROM_LIST_CHANNELS",
      "content": "Before scheduling your next social media post, check the destination account and the timezone.",
      "images": [],
      "settings": {}
    }
  ],
  "tags": [],
  "idempotencyKey": "one-linkedin-draft-2026-10-13-v1"
}

Replace the channel placeholder with the selected live ID. Keep a unique, stable idempotencyKey for this creation request and reuse it only for an unchanged retry of that request. A different post needs a different key.

The posts array contains one entry per destination. This example contains one because you are proving one scheduling path, not starting a batch. Optional fields include firstComment and media objects in images; provider settings depend on the selected platform. Do not reuse empty settings for every network.

Validation means inspecting the draft, not trusting one tool name

Validate the input shape against the connected server’s schema, check platform requirements, and read back the stored draft. No single check establishes that a social network will accept the eventual publication.

After creation, retain the returned post ID. Call:

postsider_get_post({"postId":"POST_ID_FROM_CREATION"})
postsider_get_post_missing_fields({"postId":"POST_ID_FROM_CREATION"})

These show tool names and arguments, not executable JavaScript. Substitute the real returned ID in both calls.

The readback returns a group with a posts array. Find the entry whose id matches the returned post ID. Compare its content, integration, and publishDate with the proposal; confirm state: "DRAFT". Inspect its platform preview in PostSider.

There is an important limitation: despite its name and broad MCP description, postsider_get_post_missing_fields currently calls a backend diagnostic for provider-flagged missing content. An empty array on an ordinary draft is not a general validation pass. The tools reference documents that narrower behavior.

Check the text, links, and provider-specific fields separately. For a media post, import an approved public HTTPS asset with postsider_upload_media_from_url, then pass its returned media objects as images. A successful import does not prove that the asset fits every platform’s rules.

For more failure checks, see where AI agents fail at social media. Do not schedule around an unexplained mismatch.

Confirmation should name the saved post and the exact time

Ask for scheduling confirmation only after reading the draft. The confirmation must identify that stored post, its destination, exact copy, and timestamp. Permission to save a draft is not permission to publish it later.

A useful confirmation request is:

Schedule this saved draft to the selected LinkedIn account on October 13, 2026, at 10:00 AM America/New_York, equivalent to 14:00 UTC? The content is unchanged from the draft shown above. No other posts will be changed.

Include the real post ID and channel name in the actual request. Once the user confirms, check publishing state again, then call:

{
  "postId": "POST_ID_FROM_CREATION",
  "status": "schedule"
}

Those are the arguments for postsider_update_post_status. It accepts draft or schedule, not a replacement date. Check that the stored date is still correct and in the future before changing status. If it needs adjustment, stop for a reviewed correction in the dashboard.

This is a chat confirmation boundary, not a claim that MCP provides a team approval policy. Keep the client’s write permission prompts enabled. Do not substitute this path for an organization’s required review process.

Exact readback separates scheduled from published

Call postsider_get_post again with the same post ID after the status change. Report success only when the saved record matches what was confirmed and its state shows QUEUE.

Your completion message should contain the real ID, channel, exact saved content, publishDate, and state. Show the local equivalent of the UTC time. Include any returned error instead of hiding it behind “done.”

QUEUE means scheduled. It does not mean the post is already live. Recheck the record after the scheduled time; publication can fail because of channel credentials, platform rules, or service errors. Our guide to reliable social publishing with agents explains why post-write inspection belongs in the workflow.

If creation times out, do not invent an ID or repeat the write with a new key. Retry the unchanged request with its original key and inspect the returned record. If the outcome remains unclear, stop and review the calendar rather than creating another post.

A reusable prompt keeps the same boundaries on the next run

Reuse a prompt that separates preparation from scheduling and demands exact readback. Replace the bracketed values before sending it.

Prepare one text-only social media post in PostSider.
Channel: [platform and exact account name]
Copy: [exact text]
Target time: [future date, time, and IANA timezone]

First list channels and resolve the account ID. Read publishing state
and inspect the target date range. Discover the live tool schemas.
Show the exact copy and UTC timestamp before any write. Ask permission
to create one draft with type=draft and a stable idempotency key.
Read the created post by its returned ID. Check saved content, channel,
date, and draft state; check provider requirements. Do not treat an
empty missing-fields result as a general validation pass.
Ask explicit confirmation before scheduling that saved draft.
After confirmation, recheck publishing state and the future timestamp,
update that post's status to schedule, then read that exact ID again.
Report saved content, channel, publishDate, state, and any errors.
Do not publish now, change other posts, or create a duplicate on timeout.

Start with one channel in the dashboard so you can inspect the same post your agent reads. Create your PostSider account, connect the account you intend to use, and make the first MCP request read-only.

Lukasz Blania is the founder of PostSider.