Skip to main content
Glama
Upload-Post

Upload-Post

Official

@upload-post/mcp

Official Model Context Protocol (MCP) server for Upload-Post.

Glama npm

Lets any MCP-compatible AI agent (ChatGPT, Claude Desktop, Claude Code, Cursor, …) publish, schedule, analyze and manage social media across TikTok, Instagram, YouTube, LinkedIn, Facebook, Pinterest, Threads, Reddit, Bluesky, X, Google Business, Discord, Telegram and more with a single API key.

Built on top of the official upload-post SDK and the public Upload-Post REST API.


Use it in ChatGPT (no setup)

Upload-Post is a plugin reviewed by OpenAI, listed in ChatGPT's Plugins (formerly Apps). Open Upload-Post in ChatGPT or search for Upload-Post in Plugins, click Install, then Connect, and sign in with OAuth. There is no MCP URL to paste, and you get the Upload Studio widget for publishing video files, photos and carousels straight from your computer. OpenAI dots use the same plugin: select it in your dot's Customize → Plugins and review its permissions.

Prefer to wire it up by hand? In ChatGPT on the web, open Plugins, click +, choose Add custom MCP server, point it at https://mcp.upload-post.com/mcp and set authentication to OAuth. Custom MCP servers get write actions on Business, Enterprise and Edu workspaces.

Related MCP server: upload-post-mcp

Use it in Claude (no setup)

Upload-Post is an official connector in Claude's connector directory. Add Upload-Post to Claude, or in claude.ai, Claude Desktop or Claude Cowork open Customize → Connectors, browse the directory and search for Upload-Post, then click Connect and sign in with OAuth. There is no MCP URL to paste. On Team and Enterprise an owner may need to allow it first in Organization settings.

Prefer to wire it up by hand? Open Customize → Connectors, click + Add, then Add custom connector, paste https://mcp.upload-post.com/mcp, click Continue and sign in with OAuth. Custom connectors work on every Claude plan (the Free plan allows one). In Claude Code: claude mcp add --transport http upload-post https://mcp.upload-post.com/mcp, or install the official Upload-Post plugin from the Claude directory.

Use it in Perplexity Computer

Open Plugins in the sidebar (or Customize → Connectors), then Add custom → Connector → Add MCP connector → Remote. Use https://mcp.upload-post.com/mcp with the Streamable HTTP transport and OAuth (or your Upload-Post API key), click Add, then click the Upload-Post card to sign in.

Use it in Gemini CLI

Install the extension and sign in with OAuth the first time Gemini calls a tool:

gemini extensions install https://github.com/Upload-Post/upload-post-mcp

Two ways to run it yourself

A) Local stdio (single-user) — simplest

The server runs on your machine, spawned by the MCP client. Add to ~/.claude/mcp.json (or Cursor settings, etc.):

{
  "mcpServers": {
    "upload-post": {
      "command": "npx",
      "args": ["-y", "@upload-post/mcp"],
      "env": { "UPLOAD_POST_API_KEY": "YOUR_API_KEY" }
    }
  }
}

Get your API key at https://app.upload-post.com → API Keys. Restart the client — you should see 58 upload-post tools.

B) Hosted HTTP (multi-tenant) — share one server with many users

Run the server on any Docker-capable host (Fly, Railway, Cloud Run, your own box…) and let each user connect with their own Upload-Post API key. The server stores nothing per user.

{
  "mcpServers": {
    "upload-post": {
      "url": "https://mcp.your-domain.com/mcp",
      "headers": {
        "Authorization": "ApiKey YOUR_OWN_UPLOAD_POST_API_KEY"
      }
    }
  }
}

Authorization: Bearer <key> is also accepted, for clients that only allow Bearer.


Sessions never expire

A hosted session does not live only in the memory of the process that opened it. The Mcp-Session-Id the client holds is a token signed by the server that carries the client's initialize (who it said it was, the protocol version, its capabilities). Any process with the same UPLOAD_POST_MCP_SESSION_SECRET rebuilds the session the first time it sees the id, so:

  • a restart, a deploy or a second replica is invisible to the client: its next call is served, without "Session not found" and without re-initializing;

  • there is no limit on how many sessions exist. UPLOAD_POST_MCP_MAX_SESSIONS and the idle TTL only bound how many are kept in memory at once;

  • nothing is stored anywhere: no database, no file.

The id is not a credential. It holds no key, every request still has to present its own Authorization, and an id only opens again for the key it was issued to. Ids issued by versions before this (plain UUIDs) are not rebuilt: they say nothing about the client, so they get the 404 they always got, the client re-initializes once and holds a signed id from then on. A session the client ends with DELETE answers 404 afterwards. Without UPLOAD_POST_MCP_SESSION_SECRET the server signs with a key made up at start: after a restart those ids are unknown, the client gets a 404 and re-initializes (as before this change). GET /health shows durableSessions.

What can the agent do?

The server exposes Upload-Post API tools plus one ChatGPT App UI launcher.

Group

Tools

Upload

upload_video, upload_photos, upload_text, upload_document, open_upload_studio

Media staging

create_media_upload, complete_media_upload, get_media_upload, delete_media_upload

Status

get_status, get_job_status, get_history, get_media

Schedule

list_scheduled, cancel_scheduled, edit_scheduled, get_scheduled_post (one post's options, preview and thumbnail; not exposed in ChatGPT yet)

Analytics

get_analytics, get_total_impressions, get_post_analytics, get_cached_post_analytics, get_platform_metrics

Audience

get_audience, get_suggestions

Users

get_account_info, list_users, get_connect_link, open_social_accounts, create_user, delete_user, generate_jwt, validate_jwt, manage_profile (rename, disconnect one network, default Facebook / LinkedIn Page and Google Business location; not exposed in ChatGPT yet)

Pages/boards

get_facebook_pages, get_linkedin_pages, resolve_linkedin_organization, get_pinterest_boards, get_google_business_locations, get_google_business_reviews, reply_to_google_business_review, get_reddit_detailed_posts

Pinterest and limits

manage_pinterest_boards (board sections, new boards and sections), save_post (save a Pin to a board, bookmark a Bluesky post), get_publishing_limits (Instagram and Threads posts left in 24 h) (not exposed in ChatGPT yet)

Posts

retry_post, unpublish_post, edit_post, repost_post, post_action (not exposed in ChatGPT yet)

Best times

get_best_times: the hours each connected account gets the most engagement; update_queue_settings with slots: "auto" fills the queue with them (not exposed in ChatGPT yet)

Telegram

manage_telegram_chat (chat info, members, invite links, join requests, forum topics), manage_telegram_bot (bot profile and commands, updates, query answers, sticker sets), manage_telegram_payments (Stars, invoices, refunds, gifts, automatic payment answers), manage_telegram_business (Business account profile, stories, gifts, Stars) (not exposed in ChatGPT yet)

Bluesky

bluesky_read (profiles, search, threads, feeds, notifications, account settings, drafts), manage_bluesky_account (profile, status, settings, preferences, drafts) (not exposed in ChatGPT yet)

YouTube

youtube_read (videos, quota, playlists, captions, comments, search and catalogs, channel, sections, subscriptions, activities, broadcasts, streams, live chat), manage_youtube_playlists, manage_youtube_comments, manage_youtube_channel, manage_youtube_videos (rating, thumbnail, captions, abuse reports), manage_youtube_live (broadcasts, streams, live chat, chat moderators and bans) (not exposed in ChatGPT yet)

Google Business

google_business_read (posts, reviews, performance and search keywords, gallery, location info, catalogs, attributes, menus, services), update_google_business_location (edit the location info), manage_google_business (attributes, Google's suggested changes, lodging, menus, services, gallery, booking links, review reply deletion, listing reports) (not exposed in ChatGPT yet)

Comments

get_post_comments, create_comment, delete_comment, reply_to_comment, public_reply_to_comment, hide_comment, like_comment, pin_comment, edit_comment, hold_comment, approve_comment, ignore_comment, set_post_comments, comment_action

TikTok

tiktok_music_trending, tiktok_music_search, tiktok_location_search, tiktok_publishing_settings

DMs

send_dm (Instagram, Bluesky; Telegram outside ChatGPT), list_dm_conversations, start_autodm (one post: Instagram DM or public auto-reply on TikTok, YouTube, Facebook, Threads, Bluesky), list_autodms, get_autodm_logs, pause_autodm, resume_autodm, stop_autodm, delete_autodm, manage_autodms

AutoDM rules

create_autodm_rule, list_autodm_rules, pause_autodm_rule, resume_autodm_rule, delete_autodm_rule: account-wide Instagram rules (every post, story replies, story mentions, DM keywords) that never expire (not exposed in ChatGPT yet)

Webhooks

list_webhook_deliveries, get_webhook_delivery, redeliver_webhook: 7-day log of the events sent to the user's webhook URLs, with attempts and manual redelivery; list_webhook_subscriptions, create_webhook_subscription, delete_webhook_subscription, test_webhook_subscription: extra destinations (n8n triggers, REST hooks) for chosen events; manage_webhook_settings: the account and per-profile webhook (the signing secret is never returned) (not exposed in ChatGPT yet)

Team approvals

list_pending_approvals, approve_post, reject_post, edit_pending_post, withdraw_pending_post: posts by Editors and Contributors waiting for the owner or an Admin; get_team_info: roles, members, shared accounts and the team activity log (not exposed in ChatGPT yet)

ChatGPT Ads

chatgpt_ads_read (accounts, campaigns, ad groups, ads, insights, previews), manage_chatgpt_ads (launch, create, edit, activate, pause, archive; spend runs on the user's own OpenAI billing) (not exposed in ChatGPT yet)

FFmpeg

submit_ffmpeg_job, get_ffmpeg_job, download_ffmpeg_result, get_ffmpeg_consumption

Queue

get_queue_settings, update_queue_settings, preview_queue, mark_queue_slot (skip or free one slot; not exposed in ChatGPT yet)

Feedback

send_feedback: the agent tells the Upload-Post team about an unclear error, a wrong tool description or a missing capability (not exposed in ChatGPT)

Async uploads return a request_id. The agent should poll get_status (about every 10 seconds, for up to about 15 minutes) until status is completed, failed or retryable; completed means every platform finished, and each entry of results says whether it published. pending_approval waits for a team approval.

Every upload carries an Idempotency-Key derived from the tool, its arguments and a 10-minute time window, so a call repeated after a timeout does not publish twice: an identical call repeated in the following minutes returns the earlier result, marked idempotent_replay: true, while the same call made deliberately later publishes again. A failed upload is retried with retry_post, which only resends the platforms that failed.

A team member's post can go to the approval queue instead (the API answers 202 with pending_approval: true and an approval_id): nothing is published until the owner or an Admin approves it. The upload tools and get_status return that as a success with a next_step explaining it, not as an error. To act as a team member on the owner's account from a local server, set UPLOAD_POST_ACT_AS_USER to the owner's email.

Some features are not generally available yet and answer 503 until they are switched on: webhook subscriptions (webhook_subscriptions_disabled), the approval queue (post_approvals_disabled), the new YouTube actions (every youtube_read / manage_youtube_* action except videos, quota and the thumbnail: youtube_feature_disabled). Each tool's description says which of its actions are affected. Connecting a ChatGPT Ads account (it takes an OpenAI Ads API key), the per-network credential connections and rotating the webhook secret stay in the dashboard on purpose: an agent never handles those secrets.

Per-platform: TikTok / YouTube / Instagram / LinkedIn / Facebook

One server covers every network; this is what each of the big five uses. Publishing always goes through the same upload tools with a platform list, so a single call can post one video to TikTok, Reels and Shorts at once.

Platform

Publish

Network-specific helpers

Engage and measure

TikTok

upload_video (videos, drafts), upload_photos (photo carousels)

tiktok_publishing_settings, tiktok_music_trending, tiktok_music_search, tiktok_location_search

get_post_comments, create_comment, comment_action, get_post_analytics, get_audience, start_autodm (public auto-reply)

YouTube

upload_video (videos and Shorts, with title, description and tags)

get_post_comments, comment_action (hide / hold), get_post_analytics, get_analytics, start_autodm (public auto-reply)

Instagram

upload_video (Reels, Stories), upload_photos (posts, carousels, Stories)

get_post_comments, reply_to_comment, comment_action, send_dm, list_dm_conversations, start_autodm (comment-to-DM on one post), create_autodm_rule (every post, stories, DM keywords), get_post_analytics

LinkedIn

upload_text, upload_photos, upload_video, upload_document (PDF, PPT, DOCX documents)

get_linkedin_pages (post as a company page), resolve_linkedin_organization (exact name and urn to @mention a company Page)

get_post_comments, get_post_analytics, get_analytics

Facebook

upload_video, upload_photos, upload_text

get_facebook_pages (pick the page)

get_post_comments, comment_action (hide / like / edit), start_autodm (public auto-reply), get_post_analytics

Search terms people use for these: TikTok MCP server, YouTube MCP server / YouTube uploader MCP, Instagram MCP server, LinkedIn MCP server, Facebook MCP server.

One tool per question, not per network

The Upload-Post API has no endpoint per social network: it has an endpoint per question, and a platform parameter saying who is being asked. get_post_comments, get_post_analytics, get_audience, get_suggestions and comment_action all work that way, so an agent learns one shape and reuses it for every network. Only the four tiktok_* tools are network-specific, because what they return (the Commercial Music Library, TikTok places, TikTok's per-account publishing settings) exists only on TikTok.

  • get_audience — who follows the profile, where they are, when they are online, what they tap. Also benchmark_categories, and the niche averages to compare against when benchmarkCategory is set. The server clamps the window to at most 60 days ending before today, so a wider range is trimmed rather than rejected, and range in the response says which window was used.

  • get_suggestions — hashtags (with view_count) or related keyword searches, told apart by type, not by a different tool.

  • get_post_comments — top-level comments on a post, or, with commentId, the replies under one of them (TikTok, Threads, YouTube, Instagram, Facebook and LinkedIn Page posts; LinkedIn prefers the full comment_urn). Reads are cached for up to 60 seconds (up to 2 minutes on X); a comment created or deleted through Upload-Post by the same account shows up on the next read.

  • create_comment on X — links are removed unless the account is allowed links on X (reported in warnings); a message that was only links fails with 400 x_links_not_allowed. Replies, post edits and reposts on X share a daily limit per X account (20 on the free plan, 200 on paid plans, reset at 00:00 UTC); past it the API answers 429 x_daily_write_limit with retry_after and a Retry-After header.

  • hide_comment, like_comment, pin_comment, edit_comment, hold_comment, approve_comment, ignore_comment, set_post_comments — one tool per moderation operation. comment_action does the same through a single action argument and stays available everywhere except ChatGPT, which only gets the one-operation tools (the same goes for manage_autodms).

  • comment_action — moderate a comment on TikTok (hide / like / pin), Facebook (hide / like / edit), Instagram (hide, or enable / disable comments on a post), YouTube (hide / hold) and Threads (hide / approve / ignore). Each value carries its own inverse, so nothing is permanent.

  • get_post_analytics — per-post metrics, by requestId (posts published through Upload-Post, TikTok drafts once published publicly) or by platformPostId + platform + user (any post of the connected account). post_metrics is whatever the platform reports, so its shape varies: on TikTok it adds retention, impression_sources, audience_types, new_followers, reach and the watch times (average_time_watched, total_time_watched, full_video_watched_rate).

Errors are shared too: platform_not_supported (400, with the list of the networks that can answer), invalid_parameter (400), tiktok_reconnect_required (400), reauth_required (409) and 502 when the upstream network fails.

TikTok capabilities

get_post_comments, create_comment, delete_comment and comment_action accept platform: "tiktok", and firstComment works on TikTok like on every other network.

What a TikTok account can do depends on how it is connected. list_users returns a capabilities array on each TikTok account — music, location, cover_image, cover_timestamp, draft, video_privacy, photo_privacy, profile_analytics, comments, trend_search — and each tool's description names the one it needs. They are granted when the user connects TikTok, so an account connected before a capability existed has to reconnect before the matching tools answer; that is what a tiktok_reconnect_required error means.

list_dm_conversations (Instagram, WhatsApp, Messenger, Bluesky, and outside ChatGPT Telegram: the private chats of the profile's own bot, which need its updates on) is cursor-paginated the same way, through pagination.next_cursor / has_more. It also takes since (Unix timestamp or ISO 8601, activity after that moment), participant_id (one thread) and messages_limit (latest messages per conversation, 1-25, default 10). Pages hold at most 50 conversations (25 on Bluesky). Message media comes back in attachments with type and url. Bluesky also takes conversation_id + messages_cursor (one conversation's older messages), status (request / accepted) and read_state: "unread"; send_dm on Bluesky takes a handle or DID, a shared post, reply_to and sender actions (read, react, accept, mute, leave). Bluesky DMs need an app password created with access to direct messages.

get_media and get_cached_post_analytics are cursor-paginated: feed the response's next_cursor back as cursor until has_more is false. LinkedIn, Discord and Telegram do not support media cursors and accept limit only. Prefer get_cached_post_analytics over get_post_analytics when scanning many posts — it replays previously fetched results and so avoids the live analytics rate limit of 100 requests / 5 minutes. Only contains posts previously fetched through a live per-post endpoint; there is no background refresh, so captured_at is the last time that post was read live.

FFmpeg jobs accept one public URL through input_url or multiple URLs through files. They run on Upload-Post's encoding servers, each in its own working directory. full_command is a single ffmpeg invocation with {input} (or {input0}, {input1}…) and {output} placeholders, run without a shell: it must start with ffmpeg, every -i must be an {input}/{inputN} placeholder or a -f lavfi source, and {output} is the only output. Protocols or URLs inside the command (file:, concat:, subfile,…), the movie=/amovie=/sendcmd filters, absolute paths other than fonts under /usr/share/fonts, .., -safe 0 and shell metacharacters are rejected with a 400. Endless commands (-stream_loop -1, -loop 1, a lavfi source without a duration) need -t, -shortest or -frames, and -stream_loop goes from -1 to 100. Usage is charged at the longer of the input and output durations. Poll get_ffmpeg_job until completion, then call download_ffmpeg_result; it returns the result URL without streaming the processed binary through MCP. Nothing is posted until you pass that URL to an upload tool.

Telegram, Bluesky and Google Business

The resource tools (manage_telegram_chat, manage_telegram_bot, bluesky_read, manage_bluesky_account, google_business_read) take an action and a params object with the REST API's own field names, so one tool covers a whole resource without a tool per endpoint. Deletions and other changes that cannot be undone carry the API's own confirm: true, which the agent sets only after the user approves.

Publishing takes the new per-network options in platformOptions: sponsored content (paidPartnership, facebookSponsorId), Telegram (telegramPoll, telegramLocation, telegramVenue, telegramContact, telegramDice, telegramReplyMarkup buttons, telegramPin, telegramDisableNotification, telegramProtectContent, telegramMessageThreadId, telegramHasSpoiler, telegramCaptionOverflow…), Bluesky (blueskyTags, blueskyThreadgate, blueskyPostgate, blueskyQuoteUri, blueskyThreadOverflow, blueskyCaptions, blueskyVideoPresentation, blueskyGifAsVideo) and Google Business (gbpScheduledTime, gbpRecurrence*, gbpMultiMedia, gbpUploadToGallery). Telegram paid broadcasts (telegramAllowPaidBroadcast) and the end-client approval flag of generate_jwt (clientApproval) show up once the installed upload-post SDK sends them (2.22.0 or later): uploads go through the SDK, which drops fields it does not know. unpublish_post deletes Telegram posts (delete_all_messages for the messages a long post was split into), get_analytics takes telegram, and list_dm_conversations takes Bluesky's view: "summary" and include: "unread_counts".

YouTube works the same way (youtube_read and five manage_youtube_* tools). Each account has a daily YouTube allowance for these calls (200 units on the free plan, 2,000 on paid plans, reset at midnight Pacific time; youtube_read with action: "quota" shows what is left): reads cost about 1 unit, most writes 50 and caption uploads 400 or more. Images and caption files are taken by public URL (image_url, file_url, thumbnail_url), never as a path. Uploads take youtubeLocalizations and youtubeBrandPartner, and edit_post edits YouTube videos (title, description, tags, privacy, translations, brand partner…).

These tools and parameters are not in ChatGPT's surface yet: they join it with the next app review. npm run check compares what ChatGPT sees with the reviewed snapshot in scripts/fixtures/chatgpt-tools.json.

Confirmation before acting

Tools that publish or reach other people as the user run in two steps. Called without confirmed: true, they return status: "confirmation_required" with a preview of exactly what would go out (text, media, platforms or recipients, buttons, keywords, timing) and do nothing; the model shows it to the user and repeats the call with confirmed: true once they approve. This covers upload_video, upload_photos, upload_text, upload_document, send_dm, reply_to_comment, public_reply_to_comment, create_comment, reply_to_google_business_review, edit_comment, unpublish_post, start_autodm and manage_autodms with action: "start", create_autodm_rule, redeliver_webhook, edit_post, repost_post, post_action (except private bookmarks), the YouTube comment and live chat writes, live chat bans, abuse reports and the YouTube deletions, manage_chatgpt_ads when it spends money or cannot be undone (activating, archiving, updating, or creating something active; pausing and paused drafts run straight away), create_webhook_subscription, delete_webhook_subscription, test_webhook_subscription, manage_webhook_settings when it changes or removes where events go or sends a test notification, approve_post, reject_post, withdraw_pending_post, manage_profile disconnecting a network, save_post on Pinterest, Telegram invoices and Business stories, deleting a Google review reply, plus comment_action / hide_comment when they edit a comment or ban its author. delete_user deletes only when confirm_username repeats the profile name. Uploads with a scheduledDate or addToQueue run straight away, because a scheduled or queued post can still be reviewed and cancelled before it publishes; this also lets scheduled, unattended runs post. ChatGPT, which asks the user before every write tool, keeps the single-step tools.

Reddit publishing is switched off while the Reddit app is unavailable: reddit is not offered as a platform and asking for it fails with reddit_unavailable. Self-hosters can set UPLOAD_POST_REDDIT_ENABLED=true once it is back.

ChatGPT video upload UI

open_upload_studio renders a ChatGPT Apps component for file-based publishing: one video, or one or more images (up to 10, for a carousel; pass mediaType: "photos"). For each file the widget creates a short-lived Upload-Post/R2 staging upload, PUTs the file directly to R2 and completes the upload, one file at a time, then calls upload_video or upload_photos with the returned temporary media URLs in order. For photos it can instead hand the staged URLs back to ChatGPT ("Send to ChatGPT"), which then calls upload_photos itself, e.g. with a different caption per platform. upload_video and upload_photos refuse /mnt/data and sandbox attachment paths and point the model at the Studio.

The widget speaks the ChatGPT Apps SDK bridge, so it is only advertised to ChatGPT (detected from clientInfo at initialize; override the match with UPLOAD_POST_STUDIO_CLIENTS=<regex>). Every other host (claude.ai, Claude Desktop, Claude Code, Cursor, …) does not see the tool or its ui:// resource; instead create_media_upload / complete_media_upload are exposed to the model with step-by-step guidance, and upload_video tells the assistant to ask for a public URL or send the user to the dashboard when the client cannot PUT the file itself.

The staging object is deleted after 24 hours whether it is used or not. Scheduled/queued posts remain safe because upload_video copies the temporary URL into the existing durable scheduler storage before execution.

Claude and other MCP clients can use the same flow without the ChatGPT UI: call create_media_upload, PUT the file to upload_url, call complete_media_upload, then pass media_url to upload_video.

Set UPLOAD_POST_R2_CONNECT_DOMAINS on the MCP host to the comma-separated origins used by the backend's R2 signed URLs when they differ from the defaults (for example https://<account>.r2.cloudflarestorage.com,https://<bucket>.<account>.r2.cloudflarestorage.com) so the ChatGPT component CSP allows the browser PUT.

The R2 bucket CORS policy must allow browser uploads. A restrictive policy can include your actual widget origin; for fastest validation, use:

[
  {
    "AllowedOrigins": ["*"],
    "AllowedMethods": ["PUT", "GET", "HEAD"],
    "AllowedHeaders": ["*"],
    "ExposeHeaders": ["ETag"],
    "MaxAgeSeconds": 3600
  }
]

Connect social accounts from the chat (MCP Apps)

open_social_accounts shows one card per network (TikTok, Instagram, YouTube, LinkedIn, Facebook, X, Threads, Pinterest, Bluesky, Google Business, Telegram and the rest under "More networks"), each marked connected, needs reconnecting or not connected. It is an MCP Apps view (ui://upload-post/social-accounts.html, text/html;profile=mcp-app), built on the open standard rather than the ChatGPT-only bridge.

  • One button per network. The click asks the server for a link at that moment (the view calls create_social_connect_link, visible to the view only) and opens it in a new tab through the host (ui/open-link): network sign-ins such as TikTok, Meta or Google do not run inside an iframe. The link is a signed one-click page of the selected profile that shows only that network, with no Upload-Post login, and it names the network (&connect=tiktok) so the page starts that connection by itself: the user goes through Upload-Post straight to the network's sign-in; networks connected with a form (Bluesky, Telegram, Discord, Mastodon, WordPress, …) open the profile's full connection page. For a profile the MCP did not create, the link is minted with preserve_settings, so its white-label connection settings (logo, texts, redirect, platform list) are never touched. The dashboard is only the fallback: several profiles and none selected, or the API not answering.

  • No "done" needed. After a click the view checks again every 5 s, for at most 3 minutes per click and 120 checks per view, and stops as soon as the network is connected. A new connection turns the card green and updates the model's context (ui/update-model-context); a "Continue in the chat" button sends a message only when the user clicks it.

  • Who sees it. Only hosts that declare MCP Apps support in initialize (capabilities.extensions["io.modelcontextprotocol/ui"].mimeTypes containing text/html;profile=mcp-app). Hosts that do not declare it keep the text flow (list_users → get_connect_link). ChatGPT does not get it yet: its tool surface stays the one OpenAI reviewed until the next app submission. UPLOAD_POST_MCP_APPS=off turns the view off for everyone.

  • Expired connections (reauth_required) get the same signed link as new ones, in the view and in upload errors.


Local / development

git clone https://github.com/Upload-Post/upload-post-mcp.git
cd upload-post-mcp
npm install
npm run build

# stdio (default — used by Claude Desktop, Cursor)
UPLOAD_POST_API_KEY=... node dist/index.js

# HTTP streamable (for hosted deployments)
UPLOAD_POST_API_KEY=... node dist/index.js --http --port 8080

Inspect the live tool surface with the official inspector:

npx @modelcontextprotocol/inspector node dist/index.js

Configuration

Env var

Mode

Default

Description

UPLOAD_POST_API_KEY

stdio

— (required)

Single user's Upload-Post API key. Ignored in --http mode — keys come per request.

UPLOAD_POST_BASE_URL

both

https://api.upload-post.com/api

Override for self-hosted / staging.

UPLOAD_POST_ACT_AS_USER

stdio

—

Team members: the account owner's email, sent as X-Act-As-User so the server acts on the owner's account with the member's role. Never applied in --http mode.

UPLOAD_POST_MCP_PORT

http

8080

Port for --http mode.

UPLOAD_POST_MCP_MAX_BODY_MB

http

10

Largest /mcp request body accepted; bigger ones get 413.

UPLOAD_POST_MCP_VALIDATE_API_KEYS

http

true

Check a pasted API key once against GET /uploadposts/me (cached) before opening a session for it; a rejected key gets 401.

UPLOAD_POST_MCP_KEY_CHECK_TTL_MS

http

600000

How long an accepted key is trusted before it is checked again.

UPLOAD_POST_MCP_SESSION_SECRET

http

random at start

Key that signs session ids. Set it (any long random string) so sessions survive a restart or a deploy, and give every replica the same one.

UPLOAD_POST_MCP_MAX_SESSIONS

http

2000

Sessions kept in memory (about 2 MB each); past it the longest-idle one leaves memory and is rebuilt on its next request. Not a limit on how many sessions exist.

UPLOAD_POST_MCP_MAX_SESSIONS_PER_KEY

http

200

Sessions of one credential kept in memory; past it that credential's own longest-idle one leaves memory (and is rebuilt when used again).

UPLOAD_POST_MCP_SESSION_TTL_MS

http

1800000

Idle time after which a session leaves memory. It still works afterwards: it is rebuilt on its next request.

UPLOAD_POST_MCP_AUTH_FAIL_MAX

http

20

401s on /mcp one client IP may collect per window; past it that IP gets 429 + Retry-After (sessions and keys already verified still pass; one request per probe interval is checked normally). 0 turns it off.

UPLOAD_POST_MCP_AUTH_FAIL_WINDOW_S

http

300

Window for the count above; a held IP is released this long after its last failure.

UPLOAD_POST_MCP_AUTH_FAIL_PROBE_S

http

30

While held, one request per this many seconds goes through the normal auth path.

UPLOAD_POST_MCP_TRUST_PROXY

http

auto

Whether the client IP is the last X-Forwarded-For hop: auto (only when the peer is a private address, i.e. a local reverse proxy), true or false.

UPLOAD_POST_MCP_ALLOW_LOCAL_FILES

http

false

Let tools read media from file paths on the server's disk. Off for a shared host (only http(s) URLs are accepted); turn it on only when the HTTP server runs next to your own files. stdio always allows paths.

UPLOAD_POST_MCP_APPS

both

on

off stops advertising MCP Apps views (the social accounts cards) to every host.

OPENAI_APPS_CHALLENGE_TOKEN

http

Current Upload-Post challenge token

Optional override for ChatGPT Apps domain verification at /.well-known/openai-apps-challenge.

CLI flags:

  • --http — start the streamable HTTP transport instead of stdio

  • --port <n> — port for HTTP mode

HTTP endpoints:

  • POST /mcp — JSON-RPC over MCP streamable HTTP. Requires Authorization: ApiKey <key> (or Bearer <key>) on every request. The key is the user's own Upload-Post API key; the server uses it only for that session and stores nothing.

  • GET /healthz — liveness probe, always open. Returns {"ok":true}.

Auth model in --http mode is the same pattern Resend, Tavily, Brave Search and other API-key-native services use for their hosted MCPs: the upstream key is the auth.


Deploy with Docker

The repo ships with a multi-stage Dockerfile and a .dockerignore. On any Docker-capable PaaS (Fly.io, Railway, Render, Cloud Run, fly machines, your own box…):

  1. Point the PaaS at this repo and select Dockerfile as the build pack.

  2. Port: 8080 (matches EXPOSE 8080).

  3. Environment variables: none are required. Optionally set UPLOAD_POST_BASE_URL if you point at staging.

  4. Health check path: /healthz (HTTP, port 8080).

  5. Domain: attach a domain, e.g. mcp.your-domain.com, and provision TLS (most PaaS do this automatically via Let's Encrypt).

Deploy. The server is now ready for any number of users. Each user adds the endpoint to their MCP client config with their own Upload-Post API key:

{
  "mcpServers": {
    "upload-post": {
      "url": "https://mcp.your-domain.com/mcp",
      "headers": {
        "Authorization": "ApiKey USER_OWN_UPLOAD_POST_API_KEY"
      }
    }
  }
}

Without an Authorization header the server returns 401. The header is the only credential — invalid Upload-Post keys will surface as upstream errors on the first tool call.

Local test of the production image:

docker build -t upload-post-mcp .
docker run --rm -p 8080:8080 upload-post-mcp
curl http://localhost:8080/healthz   # → {"ok":true}
curl -i -X POST http://localhost:8080/mcp \
  -H "content-type: application/json" \
  -d '{}'                               # → 401 (no Authorization)

Tips for prompting the agent

  • Prefer public URLs over local paths when uploading — local paths only work if the MCP server runs on the user's machine.

  • In ChatGPT Apps, prefer open_upload_studio for user-selected video and image files. It avoids local-path handoff issues by uploading to short-lived Upload-Post/R2 staging, then passing temporary media URLs to upload_video / upload_photos.

  • In any other client with a local file: if the client can run HTTP requests (Claude Code, Cursor, a script), stage it with create_media_upload → PUT the bytes to upload_url → complete_media_upload, then pass the returned media_url to upload_video. Hosted chats without that ability (claude.ai) need a public HTTPS URL or the dashboard at https://app.upload-post.com.

  • To send video bytes directly (a client that holds the file rather than a URL), pass videoBase64 to upload_video instead of videoPathOrUrl. The server writes it to a temp file, uploads, then deletes it. Inline bytes are capped at UPLOAD_POST_MAX_INLINE_MB (default 100 MB), and in --http mode the whole request at UPLOAD_POST_MCP_MAX_BODY_MB (default 10 MB, roughly 7 MB of video once base64-encoded) — for larger videos use a public URL.

  • Always create the profile first (create_user) and connect socials in the Upload-Post dashboard before publishing.

  • For scheduled posts, pass ISO 8601 dates with timezone, e.g. "2026-12-25T10:00:00Z" + "timezone": "Europe/Madrid".


Privacy & data handling

This server is a stateless proxy to the Upload-Post API. Per request, the only data it processes is the user's API key (or OAuth access token resolved to one) and the arguments of the tool call being executed. No user data is persisted by the MCP container itself.

  • What we receive per request: the Authorization header, the MCP tool name + arguments, and any media URLs/paths the agent passes.

  • What we forward: the tool arguments to the Upload-Post API on behalf of the authenticated user.

  • What we store: nothing per-user. OAuth tokens are stored upstream in the Upload-Post backend, hashed (SHA-256), so a breach of token storage cannot impersonate users.

  • What we log: HTTP method, path, status code, and an opaque request ID. No tool arguments, no API keys, no tokens.

Full Upload-Post privacy policy (data collection, retention, third-party sharing, contact, GDPR/CCPA): https://upload-post.com/privacy

To revoke a connector's access at any time, open Connected Apps in app.upload-post.com.


Security

  • All traffic is TLS-terminated at the edge (HTTPS only).

  • /mcp requires a valid Authorization header on every request; OAuth access tokens are short-lived (1 h access + 90 d refresh with rotation per RFC 6749 §10.4).

  • The server validates the Origin header against an allow-list (claude.ai, claude.com, chatgpt.com, chat.openai.com, app.upload-post.com, localhost) to mitigate DNS-rebinding attacks from browser-based clients. Extend with OAUTH_EXTRA_ALLOWED_ORIGINS (comma-separated) when self-hosting behind a custom dashboard.

  • OAuth metadata is served both at /.well-known/oauth-protected-resource and at the path-inserted form /.well-known/oauth-protected-resource/mcp (RFC 9728 §3.1), and likewise for oauth-authorization-server.

  • In --http mode the server writes one stderr line per failed request and per OAuth/well-known request (method, path, status, auth scheme, user agent — never query strings or credentials). Set UPLOAD_POST_MCP_ACCESS_LOG=all to log every request or off to disable it.

  • If ChatGPT shows redirect_uri not on allow-list during OAuth, add the exact redirect_uri from the failing authorize request to the Upload-Post backend OAuth redirect allow-list. For ChatGPT clients this is typically on https://chatgpt.com/.../oauth/callback or https://chat.openai.com/.../oauth/callback.

  • OAuth redirect callbacks are pre-allowed for: Claude (claude.ai/claude.com), ChatGPT, Cursor, VS Code (stable + Insiders), Smithery, Glama, Toolhouse, Perplexity (standard + Enterprise), Mistral Studio debugger and Postman — plus any http://localhost/loopback redirect (RFC 8252), which covers Claude Code, Windsurf, Cline, Continue, Goose, Gemini CLI and other mcp-remote-style clients. Platforms without a documented fixed callback (e.g. Grok, Le Chat production) are added on request.

  • All tools declare MCP readOnlyHint/destructiveHint annotations so clients can surface confirmation prompts for destructive operations, and the tools that publish or message people also require an explicit confirmed: true (see Confirmation before acting).

Report a security issue: info@upload-post.com (encrypted PGP available on request).


License

MIT © Upload-Post

Available Tools

120 tools
approve_commentApprove a pending Threads replyAInspect

Approve a reply waiting for approval on one of the profile's Threads posts, so it shows publicly. Threads only; to leave it unpublished use ignore_comment.

Inputs: user (required), commentId (required). Returns: result

approve_postApprove a postAInspect

Approve a team member's post waiting for approval: Upload-Post creates its scheduled job and publishes it to the post's platforms. Owner and Admin only. version is the item's version as reviewed; if the post was edited since, the call answers 409 approval_version_changed with the current item, which should be reviewed again. When it publishes: scheduled_date (+ timezone) if sent; now for immediate posts or with publish_now; the next free queue slot for queued posts; otherwise the post's own date. 409 approval_expired (an Editor's post whose date has passed), scheduled_date_in_past (a draft whose proposed date passed: send a date or publish_now), approval_closed; 429 when the monthly upload allowance is used up. Not generally available yet: until post approvals are switched on for the account, these calls answer 503 post_approvals_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: version (required), approval_id (required), comment, timezone, +3 more. Returns: result

bluesky_readRead BlueskyA
Read-only
Inspect

Read-only Bluesky lookups. Fields go in params with the API's names; lists page with limit (1-100) and cursor. profiles (actor: handles or DIDs, comma-separated, up to 25; without it the connected account); search_posts (q, sort latest|top, since, until, author, mentions, lang, domain, url, tag; needs user); search_accounts (q, typeahead); followers / follows (actor, or the connected account with user); post_thread (uri, depth, parentHeight), author_feed (actor, filter), feed (feed: at:// URI of a feed generator): Bluesky's own answer, with Bluesky's camelCase parameter names; post_engagement (post_id, type likes|reposts|quotes): who liked, reposted or quoted a post; xrpc (nsid plus its parameters): other public read methods such as app.bsky.feed.getPosts, app.bsky.feed.getQuotes, app.bsky.graph.getLists, app.bsky.actor.searchActorsTypeahead. Of the connected account (need user): notifications (reasons: reply, mention, quote, like, repost, follow…), unread_count, notification_preferences, activity_subscriptions, labels (post_ids: up to 25 at:// URIs), own_profile, status, settings, preferences, drafts, chat_status, chat_preferences.

Inputs: action (required), user, params. Returns: result

cancel_scheduledCancel scheduled postB
Destructive
Inspect

Cancel a scheduled post by its job_id.

Inputs: jobId (required). Returns: result

chatgpt_ads_readRead ChatGPT AdsA
Read-only
Inspect

Read-only ChatGPT Ads (OpenAI's ad platform) data of the ad account the user connected to Upload-Post in the dashboard; spending on it runs on the user's own OpenAI billing. Nothing here changes or spends anything. accounts (connected ad accounts, default first, with their linked profiles; never the key); account (live metadata of the chosen account); campaigns; campaign (campaign_id); ad_groups (campaign_id required); ad_group (ad_group_id); ads (ad_group_id required; each ad has review_status in_review|approved|rejected); ad (ad_id); lists take params limit (1-500, default 20), after (last_id of the previous page), before, order asc|desc. insights (whole account), campaign_insights (campaign_id), ad_group_insights (ad_group_id), ad_insights (ad_id): params since / until (YYYY-MM-DD, ad account timezone), time_granularity hourly|daily|monthly|none (default daily), aggregation_level ad_account|campaign|ad_group|ad, fields (list: impressions, clicks, spend, ctr, cpc, cpm and more), segments (list: product, country, device), filters / sort / time_ranges (lists of objects, passed to OpenAI), limit (1-2000), after, before. preview_ad (ad_id): a temporary preview link of the ad, valid 24 hours. 404 means no ChatGPT Ads account is connected, the profile has none linked, or the object does not exist; 401 can also mean OpenAI revoked the stored key and the account has to be reconnected in the dashboard.

Inputs: action (required), ad_id, params, ad_group_id, +3 more. Returns: result

comment_actionHide, like or pin a commentA
Destructive
Inspect

Moderate or react to a comment on one of the profile's own posts. One endpoint for every network, chosen with platform; each network supports its own verbs and answers 400 platform_not_supported / invalid action otherwise. TikTok: hide/unhide (postId), like/unlike (no postId), pin/unpin (postId). Facebook: hide/unhide, like/unlike, edit (needs message). Instagram: hide/unhide a comment, or enable_comments/disable_comments on a post (postId, no commentId). YouTube: hide/unhide/hold (postId; banAuthor only with hide). Threads: hide/unhide, approve/ignore. Most actions have an inverse; edit does not keep the previous text and banAuthor bans the commenter from the YouTube channel, so both need the user's approval of the exact change. Deleting a comment is a different tool: delete_comment. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), platform (required), postId, +4 more. Returns: result

complete_media_uploadComplete media uploadAInspect

Step 2 of staging a local file. Call it only after the file bytes were actually PUT to the upload_url from create_media_upload; without that PUT it fails or yields no publishable media. Returns a temporary media_url to pass straight to upload_video / upload_photos / upload_document.

Inputs: uploadId (required). Returns: result

create_autodm_ruleCreate an account-wide Instagram AutoDM ruleAInspect

Create a rule that AUTOMATICALLY sends private Instagram DMs as the user, with nobody reviewing each message, to everyone who triggers it on the whole Instagram account: comments on ANY post or reel (present and future), and optionally replies to the account's stories, mentions of the account in other people's stories, and DMs containing a keyword. Unlike start_autodm (one post, stops after 15 days), a rule never expires: it runs until paused or deleted. Use it when the user wants 'every post', stories or DM keywords; use start_autodm for a single post. triggers: 'comment' (default), 'story_reply', 'story_mention', 'dm_keyword' (needs trigger_keywords, otherwise every DM would be answered). trigger_keywords limit comment, story-reply and DM triggers to messages containing them (case and accents ignored); a story mention has no text, so keywords do not apply to it. Limits: up to 10 rules per Instagram account; at most 25 DMs per account every 15 minutes and the plan's daily DM allowance (what does not fit is queued and sent later, within Instagram's reply windows); one DM per comment; each person gets at most one DM per rule every per_user_cooldown_hours (default 24; story and DM triggers never less than 24). Replies inside a thread, the account's own comments and live-video comments are not answered. A post with its own active start_autodm monitor is handled by that monitor, not by the rule. Works only through Instagram webhooks (no polling): creating a rule subscribes the account to them, and if Instagram refuses, no rule is created and the call returns 502 webhook_subscription_failed (the user must reconnect Instagram). Other errors: 409 duplicate_rule, rule_limit_reached or rule_creation_in_progress; 503 account_rules_disabled. Instagram only. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: reply_message (required), profile_username (required), buttons, triggers, +3 more. Returns: result

create_commentCreate a comment or replyA
Destructive
Inspect

Post a top-level comment or a reply on a post. Provide exactly ONE of commentId (reply to a comment), postId, or postUrl (top-level). LinkedIn: postId=the post urn; the comment is made as whoever published the post (the member on a personal post, the Page on a Page post) unless linkedinPageId says otherwise. Instagram requires commentId (replies only). TikTok always needs postId (the video id); add commentId on top of it to reply inside that thread. X: links are removed from the message unless the account is allowed links on X (the response then lists it in warnings), and a message that was only links is refused with 400 x_links_not_allowed. Replies on X share a daily limit per X account with post edits and reposts made through Upload-Post (20 a day on the free plan, 200 on paid plans, reset at 00:00 UTC); past it the call returns 429 x_daily_write_limit with retry_after in seconds. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), message (required), postId, postUrl, +4 more. Returns: result

create_media_uploadCreate media uploadAInspect

Step 1 of staging a local file for publishing. Returns upload_id and a short-lived upload_url; the caller must then PUT the raw file bytes to upload_url (same Content-Type and size as declared here) and call complete_media_upload. Only useful when this client can perform the HTTP PUT itself (for example a coding agent with a shell); the model cannot read chat attachments or /mnt/data paths, so for those ask the user for a public HTTPS URL or send them to https://app.upload-post.com. Staging media is deleted after 24 hours; scheduled posts are safe because upload_video copies the media into durable scheduler storage.

Inputs: filename (required), contentType (required), contentLength (required), source, +1 more. Returns: result

create_userCreate profileAInspect

Create a new Upload-Post profile (logical container for connected socials). A name already used in the account (capitals ignored) answers 409 "Username already in use": pick another or use the existing profile (list_users). 403 PROFILE_LIMIT_REACHED when the plan has no profile left (current_profiles, profile_limit).

Inputs: username (required). Returns: result

create_webhook_subscriptionCreate a webhook subscriptionA
Idempotent
Inspect

Add a destination that receives the listed events (besides the account webhook), signed like the account webhook (X-Upload-Post-Signature with the account's webhook secret, plus X-Upload-Post-Subscription: ). Idempotent: the same url + events + profile_username returns the existing subscription (created: false) and reactivates it if it was disabled (reactivated: true); name and source are updated when sent. The first delivery can take about a minute; failed deliveries are retried and show up in list_webhook_deliveries. At most 10 active subscriptions per account (409 subscription_limit_reached). Team members cannot create them (403 team_member_forbidden). Events: upload_completed, social_account_connected, social_account_disconnected, social_account_reauth_required, dm_received, comment_received, telegram_update, review_received, review_updated, customer_media_received, listing_google_update, listing_duplicate, listing_control_changed, post_analytics_updated; also youtube_video_published / youtube_video_updated and the post approval events (post_approval_requested, post_approved, post_rejected, post_approval_expired) while those features are on. Not generally available yet: until webhook subscriptions are switched on for the account, every call answers 503 with reason webhook_subscriptions_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: url (required), events (required), name, source, +2 more. Returns: result

delete_autodmDelete an AutoDMA
Destructive
Inspect

Permanently delete an AutoDM monitor with its stats and logs. Cannot be undone.

Inputs: monitor_id (required). Returns: result

delete_autodm_ruleDelete an AutoDM ruleA
Destructive
Inspect

Permanently delete an account-wide AutoDM rule with its stats and queued DMs. Cannot be undone; use pause_autodm_rule for a break.

Inputs: rule_id (required). Returns: result

delete_commentDelete a commentA
Destructive
Inspect

Delete a comment by commentId. LinkedIn also requires postId (the post urn); TikTok needs only the commentId. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works.

Inputs: user (required), commentId (required), postId, platform. Returns: result

delete_userDelete profileA
Destructive
Inspect

Permanently delete a profile and disconnect its socials. Needs the user's approval: the call only deletes when confirm_username repeats the profile name, typed or approved by the user. Without it the response says what would be deleted.

Inputs: username (required), confirm_username. Returns: result

delete_webhook_subscriptionDelete a webhook subscriptionA
DestructiveIdempotent
Inspect

Delete a webhook subscription: Upload-Post stops sending to it right away. The account webhook and other subscriptions are not touched. A second delete answers 404 not_found. Not generally available yet: until webhook subscriptions are switched on for the account, every call answers 503 with reason webhook_subscriptions_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: subscription_id (required), confirmed. Returns: result

download_ffmpeg_resultGet FFmpeg result download URLA
Read-only
Inspect

Returns how to get a finished FFmpeg job's output without streaming it through MCP. For video and image outputs it returns a temporary public media_url (signed, no API key, deleted 24 h after the job finished) that you can pass straight to upload_video / upload_photos as the video URL / photo URL. It also returns download_url, which needs the user's Upload-Post API key.

Inputs: jobId (required). Returns: result

edit_commentEdit a Facebook commentA
Destructive
Inspect

Replace the text of a comment the Page itself wrote on Facebook. Facebook only. The previous text is not kept. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), message (required), commentId (required), confirmed. Returns: result

edit_pending_postEdit a post awaiting approvalAInspect

Change a post while it waits for approval (its author or a reviewer). Same fields as editing a scheduled post: title and caption apply to every platform, platform_content {platform: {title, caption}} to some, fields holds other upload options by their form names, scheduled_date + timezone, cover_image_base64 / remove_cover (Instagram/Facebook Reels cover). Only what is sent changes. Every edit raises version by one. 409 approval_closed or approval_state_changed. Not generally available yet: until post approvals are switched on for the account, these calls answer 503 post_approvals_disabled (the feature is off, not a temporary failure).

Inputs: approval_id (required), title, fields, caption, +5 more. Returns: result

edit_postEdit a published postA
DestructiveIdempotent
Inspect

Change a post that is already live, in place. Facebook (Page posts), LinkedIn, X, Google Business, Telegram and YouTube. text is the new text (sent as each network's own field; YouTube: the description). Telegram also takes telegram_action: pin, unpin, stop_poll, edit_live_location, stop_live_location, and in params: telegram_reply_markup (buttons), telegram_parse_mode, telegram_link_preview, telegram_show_caption_above_media, telegram_pin_notify, telegram_media + telegram_media_type (replace the photo/video by URL or file_id), telegram_location. Google Business: the text plus call to action, event and offer fields in params (cta_type, cta_url, event_title, event_start_date, event_start_time, event_end_date, event_end_time, offer_coupon, offer_redeem_url, offer_terms); its media and schedule cannot be changed. Facebook: is_pinned, facebook_page_id. LinkedIn: linkedin_visibility, linkedin_disable_reshare. YouTube (post_id = video id), in params: title, tags, privacyStatus, categoryId, publishAt, defaultLanguage, localizations {lang: {title, description}}, localizations_remove, brand_partner (a UC… channel id), embeddable, publicStatsViewable, selfDeclaredMadeForKids, containsSyntheticMedia, license, recordingDate, paid_partnership; editing these spends about 51 units of the account's daily YouTube allowance. Instagram, TikTok and Threads posts cannot be edited. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), post_id (required), platform (required), text, +3 more. Returns: result

edit_scheduledEdit scheduled postA
Destructive
Inspect

Edit a pending scheduled post in place, keeping its job ID and media: reschedule it (scheduledDate/timezone) and/or fix its text. title and caption rewrite the text for EVERY platform of the post; to change only some platforms, send platformContent instead, e.g. {"instagram":{"caption":"..."},"tiktok":{"caption":"..."}} — platforms not listed keep their text. youtubePublishAt sets or clears the date YouTube itself makes the video public (native YouTube scheduling). First comments cannot be edited on a pending post.

Inputs: jobId (required), title, caption, timezone, +3 more. Returns: result

generate_jwtGenerate platform-integration JWTA
Destructive
Inspect

Generate a JWT + connection URL so an end-user can connect socials inside an embedded Upload-Post flow (white-label integration). The profile must already exist. Each call resets the profile's connection-page settings to the values passed. To simply help the account owner connect their own socials, prefer get_connect_link.

Inputs: username (required), language, uiLabels, logoImage, +8 more. Returns: result

get_account_infoGet account infoA
Read-only
Inspect

Return the connected Upload-Post account: email, plan and usage limits. Useful as a first call to confirm the connection works before doing real work. analyze_shorts {limit, used, remaining, resets_at} is the AI Shorts analysis allowance of the current 30-day window (reading it uses none).

Inputs: no named parameters. Returns: result

get_analyticsGet profile analyticsB
Read-only
Inspect

Aggregated analytics for a profile across selected platforms (followers, views, engagement). Instagram also returns two audience breakdowns with the same shape (age / gender / country / city): follower_demographics for the account's followers and engaged_audience_demographics for the accounts that engaged with its content. Telegram returns followers (subscribers or members), boosts_active and the chat's title and link; Telegram reports no views.

Inputs: platforms (required), profileUsername (required), pageId, pageUrn. Returns: result

get_audienceGet audience insightsA
Read-only
Inspect

Who follows the profile, when they are online and what they tap on it. One endpoint for every network, chosen with platform. Returns audience.countries / .cities / .ages / .genders, activity_by_hour (followers online per hour of the day — use it to pick posting times), followers_daily (total / new / lost), profile_actions and bio_description. It always returns benchmark_categories (the 25 values benchmark_category accepts), and when benchmark_category is set it adds a benchmark object with that niche's averages (engagement rate, likes, views, follower growth…) to compare the account against. The window is clamped by the server — at most 60 days, always ending before today — so a wider range is trimmed, not rejected; range in the response says which window was actually used. Requires the 'profile_analytics' capability on the profile's TikTok account (see the capabilities array in list_users).

Inputs: user (required), platform (required), endDate, startDate, +1 more. Returns: result

get_autodm_logsGet AutoDM logsA
Read-only
Inspect

Read the activity log of one AutoDM monitor: comments seen and DMs sent or failed.

Inputs: monitor_id (required). Returns: result

get_best_timesBest times to postA
Read-only
Inspect

Best hours to publish for one connected account, from its own audience and post history. Answers best_times (hour, score), by_hour, by_day (0 = Monday), source (audience_activity, account_posts, upload_post_history or none) and confidence; with too little history source is none and best_times is empty. Results are cached for 24 hours (YouTube 7 days). To fill the posting queue with these hours automatically, use update_queue_settings with slots "auto".

Inputs: platform (required), profile_username (required), top, refresh, +3 more. Returns: result

get_cached_post_analyticsGet cached post analyticsA
Read-only
Inspect

Replays per-post metrics Upload-Post already fetched, instead of calling the platforms again. ONLY contains posts previously fetched through get_post_analytics; there is no background refresh, so captured_at is the last time that post was read live and a post never queried live will be absent. Unlike get_post_analytics it never hits the platforms, so it is not subject to the live analytics rate limit (100 requests / 5 minutes) — prefer it when scanning many posts or paging through a profile's history. Paginated: pass next_cursor from the response back as cursor until has_more is false.

Inputs: user (required), limit, since, until, +2 more. Returns: result

get_facebook_pagesList Facebook pagesC
Read-only
Inspect

Facebook pages connected to a profile.

Inputs: profile. Returns: result

get_ffmpeg_consumptionGet FFmpeg quota usageA
Read-only
Inspect

Monthly FFmpeg processing minutes used vs. plan allowance.

Inputs: no named parameters. Returns: result

get_ffmpeg_jobPoll FFmpeg job statusA
Read-only
Inspect

Poll the status of an FFmpeg job. When status is 'finished', call download_ffmpeg_result to obtain a publishable media_url (or the authenticated download URL).

Inputs: jobId (required). Returns: result

get_google_business_locationsList Google Business locationsB
Read-only
Inspect

Google Business Profile locations the profile can post to.

Inputs: profile. Returns: result

get_google_business_reviewsList Google Business reviewsA
Read-only
Inspect

List reviews for a Google Business Profile location. Pass the profile that owns the connected Google Business account; location_id defaults to the account's selected location.

Inputs: user (required), orderBy, pageSize, pageToken, +1 more. Returns: result

get_historyGet upload historyB
Read-only
Inspect

Paginated history of uploads across all profiles.

Inputs: page, limit. Returns: result

get_job_statusGet scheduled job statusA
Read-only
Inspect

Check the status of a scheduled or queued upload by job_id. Use this for posts created with addToQueue or scheduledDate.

Inputs: jobId (required). Returns: result

get_linkedin_pagesList LinkedIn pagesA
Read-only
Inspect

LinkedIn company pages connected to a profile.

Inputs: profile. Returns: result

get_mediaGet recent media from connected accountsA
Read-only
Inspect

Retrieve recent media (videos, photos, text posts) pulled directly from a profile's connected social accounts. Supports instagram, tiktok, youtube, linkedin, facebook, x, threads, pinterest, bluesky, reddit. Useful for browsing what already exists on a platform before posting more. Paginated: the response carries pagination = { limit, next_cursor, has_more }; pass next_cursor back as cursor for the next page (the last page returns next_cursor null and has_more false).

Inputs: user, limit, cursor, page_urn, +1 more. Returns: result

get_media_uploadGet media uploadA
Read-only
Inspect

Internal/app staging helper. Get status for a short-lived MCP media upload. Optionally returns a fresh temporary media_url for an already-uploaded staging object.

Inputs: uploadId (required), includeUrl. Returns: result

get_pinterest_boardsList Pinterest boardsC
Read-only
Inspect

Pinterest boards available to a profile.

Inputs: profile. Returns: result

get_platform_metricsList platform metricsA
Read-only
Inspect

Reference: which metrics are available per platform (impressions, likes, …) and their human labels.

Inputs: no named parameters. Returns: result

get_post_analyticsGet post analyticsAInspect

Per-platform metrics for one post. Identify it EITHER by requestId (a post published through Upload-Post, including TikTok drafts once they are published publicly from the TikTok app; add platform to read only that platform) OR by platformPostId + platform + user together (any post on the connected account, e.g. one returned by get_media, even if it was not published through Upload-Post). post_metrics carries whatever each platform reports, so its shape is not the same everywhere: on TikTok it adds retention (the curve, second by second), impression_sources (For You, following, search, profile…), audience_types (followers vs non-followers), new_followers won by the post, reach and the watch times (average_time_watched, total_time_watched, full_video_watched_rate) on top of the usual counters. TikTok drafts: until the draft is published from the TikTok app, post_metrics_error says it is still in the inbox; a draft published as private has no per-post analytics; once published publicly the entry carries the real platform_post_id, post_url, draft_published_at and original_publish_id (the TikTok publish id the upload started with). A TikTok upload more than 30 days old that never got a post id is no longer looked up: read it by platformPostId. It fetches the metrics live from the platform and changes nothing on the post or the account; Upload-Post keeps a copy of the result, which later reads of the same post can get from get_cached_post_analytics. Repeated calls for the same post within 5 minutes return the same result; live reads are limited to 100 per 5 minutes. When one platform cannot answer (for example, X's daily limit on live post reads), its entry carries post_metrics_error instead of post_metrics and the other platforms still answer.

Inputs: user, platform, requestId, platformPostId. Returns: result

get_post_commentsGet post commentsA
Read-only
Inspect

List comments on a post. One endpoint for every network, chosen with platform. Identify the post by either postId or postUrl (YouTube: postId=videoId; LinkedIn: postId=the post urn; TikTok: postId=the video id, postUrl is not accepted). Add commentId to get the REPLIES hanging off that one comment instead of the post's top-level comments — replies are the same question with one more parameter, not another tool. Replies can be listed on TikTok, Threads, YouTube, Instagram, Facebook and LinkedIn (company Page posts only: a personal-profile post returns 403 linkedin_personal_not_supported), so you can check whether a comment already has an answer before replying; on X and Bluesky commentId returns 400 platform_not_supported. postId or postUrl is still required with commentId (on Facebook it picks the Page). A comment with no replies returns an empty list; a malformed id returns 400 invalid_comment_id, an unknown one 404 comment_not_found (LinkedIn: 404 linkedin_comment_not_found, pass the full comment_urn instead). Reads are cached for up to 60 seconds (up to 2 minutes on X); a comment created or deleted through Upload-Post by the same account shows up on the next read. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works.

Inputs: user (required), after, limit, postId, +3 more. Returns: result

get_publishing_limitsGet publishing limitsA
Read-only
Inspect

How many posts Instagram or Threads still lets the connected account publish: both networks cap posts per rolling 24 hours, and a post over the cap fails. Cached; refresh: true reads it again from the network.

Inputs: profile (required), platform (required), refresh. Returns: result

get_queue_settingsGet queue settingsA
Read-only
Inspect

Posting queue configuration (slots per day, time windows, timezone). configured: false means the profile never saved queue settings and the answer shows the defaults.

Inputs: profile_username. Returns: result

get_reddit_detailed_postsGet detailed Reddit postsA
Read-only
Inspect

Recent Reddit posts published from a profile, with the platform-side metadata (subreddit, flair, score, …). Reddit posting is currently unavailable (error_code=reddit_unavailable) until the Reddit app is restored. Do not use reddit as a publish target.

Inputs: profile (required), limit. Returns: result

get_scheduled_postGet a scheduled postA
Read-only
Inspect

One scheduled or queued post by job_id (from list_scheduled). details: the options it was scheduled with (what edit_scheduled can change), signed media URLs and whether it can still be edited. preview: short-lived URLs of its media, cover and thumbnail (null when there is none). thumbnail: a signed URL of a small JPEG of its video or first image, built once if missing; a 202 answer means another request is building it, retry after retry_after seconds.

Inputs: job_id (required), view. Returns: result

get_statusGet async upload statusA
Read-only
Inspect

Check the status of an async upload by request_id. While it runs, status is pending, queued, processing or in_progress. It ends as completed (every platform finished; check each entry of results, one of them can still have failed), failed, or retryable (retry_post resends only the platforms that failed). pending_approval and draft wait for a team member's approval, so stop polling; rejected, withdrawn and expired will not publish. not_found (404) means no upload has that request_id. Poll about every 10 seconds and stop after about 15 minutes; a long video can take longer, so tell the user it is still processing and check again later instead of polling on.

Inputs: requestId (required). Returns: result

get_suggestionsGet hashtag or keyword suggestionsA
Read-only
Inspect

What to write about: the hashtags or the searches a network suggests around a word. One endpoint for both questions, told apart by type, and one endpoint for every network, chosen with platform. type: 'hashtags' returns { hashtags: [{ name, view_count }] } — pick tags that actually have reach for a caption; type: 'keywords' returns { keywords: [...] }, what people really search around q, useful for the next video topic. Requires the 'profile_analytics' capability on the profile's TikTok account (see the capabilities array in list_users). Keyword suggestions need 'trend_search' instead, granted the same way.

Inputs: type (required), user (required), platform (required), q, +2 more. Returns: result

get_team_infoGet team infoA
Read-only
Inspect

Read-only team data. roles: the role matrix (owner, admin, editor, contributor, viewer and what each can do), whether roles and approvals are enabled, and the caller's own role and profiles. members: the owner's team members with status and, with roles on, role and profiles (null = every profile); not available to members. shared_with_me: accounts whose team the caller belongs to, with the caller's role there. audit: what members did (post_created, published, scheduled_edited, scheduled_cancelled, approval_requested, draft_created, approval_edited, approved, rejected, approval_withdrawn, approval_expired, member_access_changed), newest first, owner and Admin only; filters actor, action, profile_username, target_id, since, until (ISO 8601), limit (1-200), cursor (= next_cursor). Roles and member access are changed by the account owner in the dashboard.

Inputs: action (required), actor, limit, since, +5 more. Returns: result

get_total_impressionsGet total impressionsB
Read-only
Inspect

Sum of impressions for a profile from daily snapshots. Use period for presets, or startDate/endDate for custom ranges.

Inputs: profileUsername (required), date, period, endDate, +4 more. Returns: result

get_webhook_deliveryGet a webhook deliveryA
Read-only
Inspect

One outgoing webhook delivery with all its attempts and the exact JSON body (payload) that was signed and sent. 404 when the id is unknown, older than 7 days or belongs to another account.

Inputs: delivery_id (required). Returns: result

google_business_readRead Google BusinessA
Read-only
Inspect

Read-only Google Business Profile data for the location connected to user. Fields go in params with the API's names; lists page with page_size and page_token (answer: next_page_token). list_posts, get_post (post_id: accounts/…/localPosts/…); get_review (review_name, or review_id + location_id), batch_reviews (location_ids, order_by newest|lowest|highest) — list reviews with get_google_business_reviews; performance (metrics, comma-separated, e.g. BUSINESS_IMPRESSIONS_DESKTOP_MAPS, CALL_CLICKS, WEBSITE_CLICKS, BUSINESS_DIRECTION_REQUESTS; start_date / end_date YYYY-MM-DD, up to 18 months back): daily series; search_keywords (start_month / end_month YYYY-MM): the searches that showed the location; location_info (read_mask): name, address, hours, phones, categories, open status; google_updates: changes Google suggests; list_locations (account, filter, order_by, read_mask); list_accounts; gallery: list_media, get_media (media_name, or media_key + location_id), list_customer_media, get_customer_media; catalogs: categories (region_code, language_code, query), batch_categories (names, language_code), chains (name), get_chain (chain); available_attributes, attributes; place_action_types, place_actions (booking and ordering links), get_place_action (link); food_menus, services, lodging (hotels); as customers see them after Google's own changes: attributes_google_updated, lodging_google_updated (read_mask; diff_mask lists what Google changed); edit status per field (experimental Google API): attributes_extended, location_info_extended (pending_fields, rejected_fields); accounts and access: get_account (account), admins (scope, account or location_id), invitations (account, target_type: invitations the connected Google account received); verification: verification_state (summary.status ok, unverified, verification_pending, suspended, disabled, duplicate, under_review), verifications (past and pending), verification_options (language_code, context: the methods Google offers); search_google_locations (query or location, page_size: whether a business is already on Google; items with requestAdminRightsUri are managed by someone else; Google allows it only for businesses the user works with), recommended_locations (account).

Inputs: action (required), user, params, location_id. Returns: result

hide_commentHide or unhide a commentA
Destructive
Inspect

Hide a comment on one of the profile's own posts so the public no longer sees it, or show it again with hidden: false. Works on TikTok, Facebook, Instagram, YouTube and Threads. TikTok and YouTube need the postId the comment belongs to. To delete a comment use delete_comment. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), platform (required), commentId (required), hidden, +3 more. Returns: result

hold_commentHold a YouTube comment for reviewA
Destructive
Inspect

Move a comment on one of the channel's YouTube videos to "Held for review", taking it off the public video until it is approved. YouTube only. To publish it again use hide_comment with hidden: false.

Inputs: user (required), postId (required), commentId (required). Returns: result

ignore_commentIgnore a pending Threads replyA
Destructive
Inspect

Ignore a reply waiting for approval on one of the profile's Threads posts, so it stays unpublished. Threads only; to publish it use approve_comment.

Inputs: user (required), commentId (required). Returns: result

like_commentLike or unlike a commentAInspect

Like a comment as the profile's account, or remove that like with liked: false. Works on TikTok and Facebook. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works.

Inputs: user (required), platform (required), commentId (required), liked. Returns: result

list_autodm_rulesList account-wide AutoDM rulesA
Read-only
Inspect

List the account's Instagram AutoDM rules (the account-wide ones from create_autodm_rule; per-post monitors are in list_autodms). Each rule carries status (active, paused, reconnect_required, disabled, or stopped with a stop_reason such as account_disconnected), its triggers and keywords, stats per trigger (replies sent, skipped by cooldown, failed), DMs still pending in the queue, and a webhook block: subscribed, receiving_events, last_event_at, error and a hint. If receiving_events is false or error is set, Instagram is not delivering events and the rule cannot answer: tell the user, usually to reconnect Instagram.

Inputs: profile_username. Returns: result

list_autodmsList AutoDMs and comment auto-repliesA
Read-only
Inspect

List the account's AutoDM and comment auto-reply monitors (one post each) with their platform, state and counters. Active ones only, unless include_inactive is true. Account-wide Instagram rules (every post, stories, DM keywords; no expiry) are listed by list_autodm_rules.

Inputs: include_inactive. Returns: result

list_dm_conversationsList DM conversationsA
Read-only
Inspect

DM conversations for a profile on a given platform, newest first, each with its latest messages. The response carries pagination { next_cursor, has_more }: to read older conversations, call again with cursor set to next_cursor (and the same since / participant_id) until has_more is false. Media a message carries comes back in attachments (type, url, plus size and preview fields when the platform gives them); content the platform flags is_unsupported cannot be retrieved. Bluesky (read live, up to 25 conversations per page) adds per conversation status (request / accepted), unread_count, muted, kind (direct / group) and per message direction, reactions, reply_to and shared posts in attachments; use conversation_id (+ messages_cursor) to page back through one conversation's history, and status / read_state to filter. Bluesky needs the account connected with an app password that allows direct messages, otherwise 403 bluesky_dm_scope_missing. Telegram (platform: "telegram"): the private chats of the profile's own bot, with participant_id = the person's numeric chat id (what send_dm takes as recipient_id). It needs the bot's updates on (manage_telegram_bot set_updates); otherwise 409 telegram_updates_not_enabled. Files people send come with a media_id (a Telegram file_id), which send_dm attachments can send again.

Inputs: user (required), kind, view, limit, +12 more. Returns: result

list_pending_approvalsList posts awaiting approvalA
Read-only
Inspect

Posts created by team members (Editors and Contributors) that wait for the account owner or an Admin: status pending_approval (an Editor's post, published once approved) or draft (a Contributor's, the reviewer sets the date). By default only open ones, newest first. Each item has approval_id, status, version (needed to approve), profile_username, platforms, post_type, title, caption, platform_content, scheduled_date, expires_at, author_email, author_role, and after a decision decided_by, decision_comment and job_id; closed ones are approved, rejected, withdrawn or expired. With approval_id it returns that one item with its upload fields, preview_url and thumbnail_url (temporary links) and destinations_effective. Editors and Contributors see only their own posts. Page with before = the previous next_before. With count_only: true it lists nothing and answers only counts {status: n} and total for the same filters (status, profile_username, author), e.g. how many posts wait for review. Not generally available yet: until post approvals are switched on for the account, these calls answer 503 post_approvals_disabled (the feature is off, not a temporary failure).

Inputs: limit, author, before, status, +3 more. Returns: result

list_scheduledList scheduled postsA
Read-only
Inspect

List all currently scheduled (not-yet-published) posts.

Inputs: no named parameters. Returns: result

list_usersList profilesA
Read-only
Inspect

List all Upload-Post profiles in the account, with their connected social accounts. Call this FIRST, before publishing, to get the exact profile name (user) and check that the target platforms are connected; never invent a profile name. When the account has no profile, or the requested platform is not connected or needs reconnecting, the response carries next_step and connect_url: give the user that link, ask them to tell you when they have connected, and wait — do not try to publish meanwhile. The TikTok account object carries a capabilities array (music, location, cover_image, cover_timestamp, draft, photo_privacy, video_privacy, inbox_fallback, profile_analytics) telling which optional TikTok fields that connection accepts.

Inputs: platforms. Returns: result

list_webhook_deliveriesList webhook deliveriesA
Read-only
Inspect

History of the webhook events Upload-Post sent to the user's own webhook URLs over the last 7 days, newest first: account and profile webhooks and webhook subscriptions (filter one with subscription_id), every event (upload_completed, social_account_connected / _disconnected / _reauth_required, dm_received, comment_received). Use it to find out whether an event reached the user's server: each delivery has status (pending = waiting for a retry, delivered, failed, cancelled), attempt_count / max_attempts, last_status_code or last_error (timeout, connection_error, HTTP nnn), every attempt in attempts, and next_attempt_at. Failed deliveries (timeout, connection error, 5xx, 408, 429) are retried automatically up to 6 attempts in about 8.5 hours; other 4xx answers are final. Test sends are marked test: true and never retried. The event body is left out unless include_payload is true; get_webhook_delivery returns one delivery with its body. Paginated with page (up to 50) and limit; the response carries total and has_more.

Inputs: page, event, limit, job_id, +5 more. Returns: result

list_webhook_subscriptionsList webhook subscriptionsA
Read-only
Inspect

The account's webhook subscriptions: extra destinations (an n8n trigger, a REST hook…) that receive the listed events besides the account webhook, newest first, active and disabled, with limit (at most 10 active) and active_count. Each one has id, url, events, profile_username (null = every profile), source, name, status active|disabled, disabled_reason (endpoint_gone, failing_too_long, blocked_url, profile_removed), last_delivery_at and health (consecutive_failures, last_failure). With subscription_id it returns just that one. To see what was sent to a subscription use list_webhook_deliveries. Not generally available yet: until webhook subscriptions are switched on for the account, every call answers 503 with reason webhook_subscriptions_disabled (the feature is off, not a temporary failure).

Inputs: url, source, status, subscription_id. Returns: result

manage_autodmsManage automatic DM monitoringA
Destructive
Inspect

Control AutoDM monitors, which answer every comment on a post (or only those containing trigger_keywords). Instagram answers with a private DM; TikTok, YouTube, Facebook, Threads and Bluesky answer with a public reply under the comment. For action='start', provide profile_username, reply_message and the post (post_url on Instagram; post_id or post_url elsewhere, plus platform). For stop/pause/resume/delete/logs, provide monitor_id. For status, optionally set include_inactive=true. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: action (required), buttons, post_id, platform, +9 more. Returns: result

manage_bluesky_accountManage the Bluesky accountA
Destructive
Inspect

Change the connected Bluesky account. Fields go in params with the API's names; a field left out stays as it is, and null or clear_fields clears it. update_profile (display_name, description, pronouns, website, avatar_url, banner_url, remove_avatar, remove_banner, pinned_post, links [{url, title}], labels); set_status (status live, url, title, description, duration_minutes) and clear_status; update_settings (chat_allow_incoming all|following|none, chat_allow_group_invites, allow_subscriptions followers|mutuals|none, hide_from_algorithmic_recommendations); update_preferences (preferences: Bluesky preference objects to add or replace; remove / remove_types; replacing a whole list such as muted words or saved feeds, or removing, needs confirm); mark_notifications_seen (seen_at; needs confirm); update_notification_preferences (preferences); set_activity_subscription (subject, post, reply); update_chat_preferences (chat / chat_request: {include all|follows, push}); drafts (text only, no media): create_draft (text, or posts [{text, link_url, quote_uri, labels}] for a thread; langs, reply_settings, quote_settings), update_draft (draft_id), delete_draft (draft_id, needs confirm).

Inputs: user (required), action (required), params, confirm, +1 more. Returns: result

manage_chatgpt_adsManage ChatGPT AdsA
Destructive
Inspect

Create and change ChatGPT Ads campaigns, ad groups and ads in the ad account the user connected to Upload-Post. This spends the user's money: spend runs on their own OpenAI billing, and an ad serves only when its campaign, ad group and ad are all active and OpenAI approved the ad. Objects are created paused unless params.status is active. Fields go in params with the API's names. promote: campaign + ad group + ad in one call (title 3-50 characters, body up to 100, target_url, image_url or file_id; budget = lifetime spend limit in the account currency, minimum 1, or budget_micros; max_bid per billing event or max_bid_micros; bidding_type impressions|clicks|conversions, billing_event_type impression|click, start_time, end_time, locations, targeting, context_hints, name, ad_group_name, ad_name, status); if a later step fails the error lists in details.created what was already created. create_campaign (name, budget or budget_micros, status, description, start_time, end_time, bidding_type, conversion_event_setting_ids, locations, custom_audience_ids, excluded_custom_audience_ids, targeting); create_ad_group (campaign_id, name, max_bid or max_bid_micros unless bidding_config, billing_event_type, status, description, context_hints, product_set); create_ad (ad_group_id, name, and title, body, target_url, file_id, price at the top level or a full creative object; type chat_card|product_ad_template; it serves after OpenAI's review); upload_creative (image_url, OpenAI fetches it; returns the file_id an ad uses); update_campaign / update_ad_group / update_ad (the id plus only the fields to change; an edited ad goes back into review); activate_* starts spending, pause_* stops it, archive_* is irreversible (campaign_id, ad_group_id or ad_id). Connecting or disconnecting the ad account is done in the Upload-Post dashboard. Read results with chatgpt_ads_read. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: action (required), ad_id, params, confirmed, +4 more. Returns: result

manage_google_businessManage Google BusinessA
Destructive
Inspect

Change the Google Business location connected to user beyond its basic info (edit that with update_google_business_location). Fields go in params with the API's names; changes go live on Google Search and Maps, and Google allows about 10 edits per minute per location (429 location_edit_rate_limited). dry_run validates without applying where supported. update_attributes (attributes, whatsapp_url, text_messaging_url, remove: only the attributes named change; see google_business_read available_attributes); answer_google_updates (decision accept|reject, fields: keep or undo Google's own changes; title and storefront fields need confirm); update_lodging (lodging, update_mask; null clears a field, lists are replaced whole; needs confirm); replace_food_menus (menus: the WHOLE list, anything left out is removed, null removes all; needs confirm) and replace_services (service_items, the whole list; needs confirm): read them first with google_business_read; gallery: upload_media (source_url public link, category COVER|PROFILE|EXTERIOR|INTERIOR|PRODUCT|AT_WORK|FOOD_AND_DRINK|MENU|COMMON_AREA|ROOMS|TEAMS|ADDITIONAL, description; photos at least 250 px and 10 KB), update_media_category (media_name or media_key, category: the only editable field), delete_media (media_name or media_key; cannot be restored; needs confirm); booking and ordering links: create_place_action (type, uri, is_preferred), update_place_action (link, uri, is_preferred, is_disabled), delete_place_action (link, needs confirm); delete_review_reply (review_name, or review_id + location_id: removes the owner's public reply); report_google_location (google_location from search_google_locations, reason_bad_location or reason_bad_recommendation, elaboration; needs confirm, cannot be withdrawn); create_account_group (type LOCATION_GROUP|USER_GROUP, account_name, primary_owner; needs confirm). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +2 more. Returns: result

manage_pinterest_boardsManage Pinterest boardsAInspect

Pinterest boards of a profile's connected account (list them with get_pinterest_boards). list_sections (board_id): the board's sections, whose id goes in the upload's pinterest board section option. create_board (name, description, privacy PUBLIC|PROTECTED; default PUBLIC) and create_section (board_id, name) create them on the user's Pinterest account.

Inputs: action (required), profile (required), name, privacy, +2 more. Returns: result

manage_profileManage a profileA
Destructive
Inspect

One Upload-Post profile (username, as list_users returns it). get: the profile and its connected social accounts. rename (display_name): the label shown in the dashboard; the username never changes, so history, schedules and integrations keep working; an empty display_name removes the label. disconnect_social (social_platform: the key in the profile's social_accounts, e.g. instagram): unlinks that one network from the profile; the others stay; reconnecting needs the user to log in to the network again through get_connect_link. Default Page used when publishing, per network (page_type facebook, linkedin or google_business): list_page_choices (every Page or location of the connected account and the one selected), select_page (page_id), clear_page (back to the account's first one). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: action (required), username (required), page_id, confirmed, +3 more. Returns: result

manage_telegram_botManage the Telegram botA
Destructive
Inspect

Profile and commands of the profile's own Telegram bot. Fields go in params: get_profile (language_code); update_profile (name, description, short_description, language_code, photo_url or animation_url, remove_photo with confirm, menu_button, default_administrator_rights, for_channels; clear_name / clear_description / clear_short_description); get_commands and delete_commands (scope, language_code; delete needs confirm); set_commands (commands: [{command, description}], 1-100, plus scope and language_code); updates_status (whether the bot sends its updates to Upload-Post, and the webhook health Telegram reports); set_updates (enabled;replace_existing_webhook to replace another service's webhook, otherwise 409 telegram_webhook_in_use; forward_url, business_chats, auto_answer_callbacks, extra_updates: the updates then arrive as telegram_update webhook events); answer_query (type callback|inline|join_request|join_request_web_app|guest|widget|shipping|pre_checkout, query_id and the answer fields: text, show_alert, url, results, ok, error_message…, for a query received as a telegram_update event; 410 telegram_query_expired when Telegram's time is up); sticker sets: get_sticker_set (name, or custom_emoji_ids), create_sticker_set (owner_user_id, name ending in by, title, stickers, sticker_type), edit_sticker_set (action add_sticker|replace_sticker|delete_sticker|set_position|set_emoji_list|set_keywords|set_mask_position|set_title|set_thumbnail|set_custom_emoji_thumbnail, name, sticker…), delete_sticker_set (name, needs confirm), upload_sticker_file (owner_user_id, sticker_format static|animated|video, sticker_url: returns a file_id); share_theme_backdrops.

Inputs: user (required), action (required), params, confirm. Returns: result

manage_telegram_businessManage the Telegram Business accountA
Destructive
Inspect

A Telegram Business account (the user's own Telegram account) connected to the profile's bot. Fields go in params with the API's names; business_connection_id picks the connection when the bot has several. connections (rights and whether each is enabled); get_profile; update_profile (first_name, last_name, username, bio, media_url for the photo with is_public, remove_photo, gift_settings); stories posted as the account: post_story (media_url: photo 1080x1920 up to 10 MB or video 720x1280 up to 30 MB and 60 s; active_period, caption, areas, post_to_chat_page, protect_content), edit_story (story_id and the fields), delete_story (story_id), repost_story (from_chat_id, from_story_id, active_period); gifts (the account's gifts), manage_gift (action convert|upgrade|transfer|delete, owned_gift_id, idempotency_key; irreversible, needs confirm); stars_balance, transfer_stars (star_count 1-10000 to the bot, idempotency_key; needs confirm). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +1 more. Returns: result

manage_telegram_chatManage the Telegram chatA
Destructive
Inspect

Read and administer the Telegram channel or group the profile publishes to, through the profile's own bot (it needs the matching admin rights). Fields go in params, with the API's names: get_info (include_administrators, return_bots: title, members count, admins); get_boosts (user_id); get_member (user_id; without it, the administrators); update_info (title, description, clear_description, photo_url, delete_photo, permissions, sticker_set_name; deleting the photo or changing permissions needs confirm); moderate_member (action: ban, unban, restrict, promote, demote, set_title, ban_sender_chat, unban_sender_chat, delete_all_reactions; user_id or sender_chat_id, until_date, revoke_messages, permissions, rights, custom_title; ban, restrict, promote, demote and delete_all_reactions need confirm); create_invite_link / edit_invite_link (invite_link, name, expire_date as Unix time, member_limit, creates_join_request); revoke_invite_link (invite_link) and new_primary_invite_link (the old primary link stops working) need confirm; answer_join_request (user_id, action approve or decline); forum topics: list_topic_icons, create_topic (name, icon_color, icon_custom_emoji_id), edit_topic (message_thread_id or general: true, action edit, close, reopen, hide, unhide, unpin_all), delete_topic (message_thread_id, needs confirm); unpin_all (every pinned message, needs confirm); leave_chat (the bot leaves: publishing there stops working, needs confirm); answer_suggested_post (message_id, action approve|decline, send_date, comment: a post suggested in the channel's direct messages chat); personal_chat_messages (user_id, limit: last messages of a user's personal channel); profile_audios (user_id, offset, limit).

Inputs: user (required), action (required), params, confirm. Returns: result

manage_telegram_paymentsTelegram Stars and paymentsA
Destructive
Inspect

Telegram Stars, invoices and gifts of the profile's own bot. Fields go in params with the API's names. Reads: stars_balance, star_transactions (offset, limit), get_payment_settings, unanswered_payments (limit: automatic payment answers that failed in the last 30 days), available_gifts, owned_gifts (user_id or chat_id, filters), unique_gift (name). send_invoice (title, description, payload, currency XTR for Stars or a provider currency with provider_token, prices [{label, amount}], photo_url, need_* fields, chat_id; it is posted in the chat) and create_invoice_link (same fields; subscription_period 2592000 makes a 30-day Stars subscription) ask other people to pay the bot. refund_star_payment (user_id, telegram_payment_charge_id; needs confirm, never retried) and edit_star_subscription (user_id, telegram_payment_charge_id, is_canceled; needs confirm). set_payment_settings: automatic pre-checkout answers (pre_checkout off|approve|reject, max_total_amount, allowed_payload_prefixes, error_message, shipping off|static, shipping_options, shipping_countries); they need the bot's updates on (manage_telegram_bot set_updates). send_gift (user_id or chat_id, gift_id, max_star_count, text, idempotency_key; needs confirm) and gift_premium (user_id, month_count 3|6|12, star_count 1000|1500|2500, idempotency_key; needs confirm) SPEND the bot's Stars. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +1 more. Returns: result

manage_webhook_settingsManage webhook settingsA
Destructive
Inspect

The account webhook (one URL that gets the account's events) and per-profile webhooks (a profile sending its events to its own URL instead). The signing secret is never returned: responses only say webhook_secret_set, and the user sees or rotates it in the dashboard. get_account: current notification settings (channels {webhook, telegram}, webhook_url, webhook_events, telegram_chat_id). set_account: change only the fields sent (webhook_url, webhook_events, channels, telegram_chat_id); the first URL saved creates the signing secret. remove_account: clears webhook_url, webhook_events and the secret and turns the webhook channel off (webhook subscriptions keep working). test_account: sends a sample upload_completed through the configured channels (params: platform, media_type, title, caption, profile_username), logged as a test delivery. get_profile / set_profile (webhook_url; webhook_events {event: true|false}, omitted = every event, null = back to every event) / remove_profile (its events go back to the account webhook): need profile_username. webhook_events names: upload_completed, social_account_connected, social_account_disconnected, social_account_reauth_required, dm_received, comment_received and the others listed in create_webhook_subscription. Team members cannot change where the owner's events go (403). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: action (required), params, confirmed, webhook_url, +2 more. Returns: result

manage_youtube_channelManage the YouTube channelA
Destructive
Inspect

Settings of the connected channel. update (description, keywords, country, default_language, unsubscribed_trailer, localizations {lang: {title, description}}, localizations_remove; only what you send changes; the channel name cannot be changed here); channel page sections: create_section (type, title, playlists, channels, position 0-9), update_section / delete_section (section_id; delete needs confirm); set_banner (image_url); set_watermark (image_url, timing_type, offset_ms, duration_ms; needs confirm), remove_watermark (needs confirm); subscribe (channel_id) and unsubscribe (subscription_id from youtube_read subscriptions). Not generally available yet: every action here belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +3 more. Returns: result

manage_youtube_commentsManage YouTube commentsA
Destructive
Inspect

Comments on the connected channel's videos, as the channel. create (text, and parent_id to reply or video_id for a new comment; idempotency_key); edit (comment_id, text: only the channel's own comments); delete (comment_id, own comments only, needs confirm); moderate (comment_ids up to 50, status published|heldForReview|rejected, ban_author; rejected or banning needs confirm). Read them with youtube_read comments. Not generally available yet: every action here belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +2 more. Returns: result

manage_youtube_liveManage YouTube liveA
Destructive
Inspect

Live broadcasts of the connected channel. Upload-Post does not send video: it returns the ingestion URL and stream key for the user's encoder (the key is a secret; share it only with the user). create_broadcast (title, scheduled_start_time, privacy_status, description, made_for_kids, enable_auto_start, enable_auto_stop, latency_preference…; create_stream true also creates and binds a stream), update_broadcast, delete_broadcast (needs confirm); bind (stream_id, or unbind true); transition (status testing|live|complete; live and complete need confirm); insert_cuepoint (duration_secs: an ad break); create_stream (title, ingestion_type, resolution, frame_rate), update_stream, delete_stream (needs confirm; encoders using its key stop); live chat of the channel's own broadcasts: send_chat_message (broadcast_id or live_chat_id, message up to 200 characters or poll {question, options}; daily limit per channel), close_poll (message_id), delete_chat_message (message_id, needs confirm); chat moderators and bans (broadcast_id or live_chat_id; 200 units each): add_moderator (channel_id), remove_moderator (moderator_id from youtube_read live_moderators, needs confirm), ban_user (channel_id, type permanent|temporary, duration_seconds for temporary; needs confirm), unban_user (ban_id). Not generally available yet: every action here belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), ban_id, params, +6 more. Returns: result

manage_youtube_playlistsManage YouTube playlistsA
Destructive
Inspect

Playlists of the connected channel. create (title, description, privacy_status public|unlisted|private, default_language, localizations); update (playlist_id; only what you send changes, localizations_remove); delete (playlist_id; the videos stay, needs confirm); add_video (playlist_id, video_id, position, note), update_video (playlist_id, item_id: move with position or change note), remove_video (playlist_id, item_id, needs confirm); set_image / replace_image (playlist_id, image_url: square JPEG or PNG; replace needs confirm), delete_image (needs confirm). Not generally available yet: every action here belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +3 more. Returns: result

manage_youtube_videosManage YouTube videosA
Destructive
Inspect

Per-video actions on the connected channel (edit title, description, tags, privacy and translations with edit_post). rate (video_id, rating like|dislike|none); set_thumbnail (video_id, thumbnail_url); captions: upload_caption (video_id, file_url, language, name, is_draft; 400+ units, more than a free plan's whole day), update_caption (caption_id, file_url and/or is_draft false to publish a draft; replacing the file needs confirm), delete_caption (caption_id, needs confirm); report_abuse (video_id, reason_id and secondary_reason_id from youtube_read abuse_reasons, comments, language; reports someone's video to YouTube as the channel, cannot be withdrawn, needs confirm, 50 units and a daily limit per channel). Not generally available yet: every action here except set_thumbnail belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), params, confirm, +3 more. Returns: result

mark_queue_slotMark a queue slot full or freeA
Idempotent
Inspect

Mark one slot of a profile's posting queue as full, so the queue skips it (for example because the user filled it outside Upload-Post), or free it again with full: false. Slot times come from preview_queue.

Inputs: full (required), slot_datetime (required), profile_username (required). Returns: result

pause_autodmPause an AutoDMAInspect

Pause an AutoDM monitor: no DMs are sent until resume_autodm.

Inputs: monitor_id (required). Returns: result

pause_autodm_rulePause an AutoDM ruleA
Idempotent
Inspect

Pause an account-wide AutoDM rule: it sends no DMs until resume_autodm_rule. Its settings and stats are kept.

Inputs: rule_id (required). Returns: result

pin_commentPin or unpin a TikTok commentA
Destructive
Inspect

Pin a comment to the top of one of the profile's own TikTok videos, or unpin it with pinned: false. TikTok only. TikTok: Requires the 'comments' capability on the profile's TikTok account (see the capabilities array in list_users). It is granted at connection time, so an account connected earlier has to reconnect TikTok before this works.

Inputs: user (required), postId (required), commentId (required), pinned. Returns: result

post_actionAct on a published postA
Idempotent
Inspect

Actions on a published post. Bluesky: bookmark / unbookmark (private), pin / unpin on the profile (unpin takes no post_id), reply_settings (who can reply: reply_settings everyone, nobody, mention, following, followers or list:, one or several), quote_settings (quote_settings disable_quotes or everyone), detach_quote / reattach_quote (quote_uri = the post that quotes this one). Telegram: react (emoji, or params.telegram_reaction, params.telegram_is_big), delete_reaction (removes another person's reaction in a group: params.user_id or params.actor_chat_id, needs confirm). Bluesky likes and reposts are not available. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), action (required), platform (required), emoji, +7 more. Returns: result

preview_queuePreview queueA
Read-only
Inspect

Preview the upcoming queue slots and what would land in them. Optionally nextSlot=true returns just the next available slot timestamp.

Inputs: nextSlot, profile_username. Returns: result

public_reply_to_commentPublic reply to commentA
Destructive
Inspect

Post a public reply visible under the original Instagram comment. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), message (required), commentId (required), platform, +1 more. Returns: result

redeliver_webhookRedeliver a webhookAInspect

Send a past webhook delivery again, now, with the same body, to the webhook URL configured TODAY for that account or profile. It goes out as a new delivery with its own delivery_id (its redelivery_of and the X-Upload-Post-Redelivery-Of header name the original), and is retried like any other if it fails. The receiver gets the event a second time, so only redeliver events it missed. 409 when there is nowhere to send it (reason: webhook_removed, event_unsubscribed, blocked_url, or for a webhook subscription's delivery subscription_removed / subscription_disabled); 404 when the delivery is unknown or older than 7 days. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: delivery_id (required), confirmed. Returns: result

reject_postReject a postA
Destructive
Inspect

Reject a team member's post waiting for approval: it will not be published and the author is notified with the comment. Owner and Admin only. A rejected post cannot be reopened. 409 approval_closed when it was already decided. Not generally available yet: until post approvals are switched on for the account, these calls answer 503 post_approvals_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: comment (required), approval_id (required), confirmed. Returns: result

reply_to_commentPrivate reply (DM) to commenterA
Destructive
Inspect

Send a private DM to the author of an Instagram comment (within Instagram's 7-day reply window). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), message (required), commentId (required), buttons, +2 more. Returns: result

reply_to_google_business_reviewReply to a Google Business reviewA
Destructive
Inspect

Create or update the owner reply to a Google Business review. Provide review_name (the full resource path from get_google_business_reviews) or review_id + location_id. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), comment (required), confirmed, review_id, +2 more. Returns: result

repost_postRepost / forward a postAInspect

Reshare a published post. LinkedIn (reshare, optional commentary, target_linkedin_page_id to reshare as a Page), X (retweet), Threads (repost), Telegram (forward or copy a channel post into another chat). Telegram: mode forward (shows the source) or copy (no link back), target_chat_id (@username or id) or target_user (another Upload-Post profile with Telegram), post_ids for several messages, all_messages true to include the messages a long post was split into (rest of the caption, first comment). More Telegram fields in params: telegram_message_thread_id, telegram_disable_notification, telegram_protect_content, caption, telegram_remove_caption, telegram_reply_markup. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), platform (required), mode, params, +8 more. Returns: result

resolve_linkedin_organizationResolve a LinkedIn company PageA
Read-only
Inspect

Turn any LinkedIn company, showcase or school Page (its URL, vanity name, numeric id or urn:li:organization:ID) into { urn, id, name, vanity_name, mention }, so it can be @mentioned in a LinkedIn post. LinkedIn only links a company mention when the name matches the Page's name exactly, capitals included; otherwise it is published as plain text. Put the returned mention (@[Exact Name](urn:li:organization:ID)) in the LinkedIn text of upload_text, upload_photos, upload_video or upload_document. Works for any public Page, not only the ones the user administers. People cannot be resolved (400 linkedin_person_not_resolvable): a person can only be mentioned with an urn:li:person id Upload-Post already returned, such as a comment author. Uses the profile's LinkedIn connection; results are cached (cached). Errors: 404 organization_not_found, 403 linkedin_permission_missing (reconnect LinkedIn), 401 linkedin_reauth_required, 429 rate_limited / linkedin_rate_limited.

Inputs: url (required), user (required). Returns: result

resume_autodmResume an AutoDMAInspect

Resume a paused AutoDM monitor, so it sends DMs to new matching comments again.

Inputs: monitor_id (required). Returns: result

resume_autodm_ruleResume an AutoDM ruleA
Idempotent
Inspect

Resume a paused account-wide AutoDM rule, so it AUTOMATICALLY sends Instagram DMs as the user again to everyone who triggers it. Re-checks the Instagram webhook subscription: 502 webhook_subscription_failed means the user must reconnect Instagram; 409 rule_stopped (with stop_reason) means the Instagram account is no longer on that profile, so create a new rule instead.

Inputs: rule_id (required). Returns: result

retry_postRetry a failed uploadAInspect

Retry a failed upload. Identify it by either requestId (async upload) or jobId (scheduled/queued upload). Only the platforms that failed are sent again; the ones that already published are left alone and come back in skipped_platforms. A job that published everywhere answers 409 nothing_to_retry, and one that has not run yet 409 job_not_finished (use edit_scheduled or cancel_scheduled for those). The retry is a new upload with its own request_id / job_id: poll that one.

Inputs: jobId, requestId. Returns: result

save_postSave a Pin or bookmark a postA
Idempotent
Inspect

Pinterest: save an existing Pin (post_id) to one of the profile's boards (pinterest_board_id, optionally a section); it shows on that board. Bluesky: bookmark a post (private). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), post_id (required), platform (required), confirmed, +2 more. Returns: result

send_dmSend a direct messageA
Destructive
Inspect

Send a DM as a connected Upload-Post profile, on Instagram or Bluesky. Instagram: recipient_id (from Instagram comments or the DM conversation tools) and message, optionally up to 3 link buttons. Bluesky: recipient_id is the person's handle (e.g. 'alice.bsky.social'), DID or profile link, or pass conversation_id (also for group chats) instead. The text may carry links, @mentions (up to 10) and #hashtags, which become clickable; at most 1000 characters. Optional reply_to (a message id) and one shared Bluesky post in attachments; Bluesky chat takes no images, files or buttons. With sender_action (Bluesky only) nothing is written: mark_seen/mark_read, react/unreact (message_id + one emoji in reaction), delete (message_id; removes it only for this account), accept (a message request), mute, unmute, leave. Sender actions do not count toward the daily DM allowance. Bluesky DMs need the account connected with an app password created with 'Allow access to your direct messages'; otherwise the call returns 403 bluesky_dm_scope_missing and the user has to create such an app password and reconnect Bluesky. Other Bluesky errors: 403 bluesky_recipient_unavailable (the person does not accept DMs from this account, with reason), 404 bluesky_recipient_not_found, 400 bluesky_message_too_long, 504 bluesky_send_unconfirmed (the DM may have gone out: list the conversation before retrying). Telegram (the profile's own bot): recipient_id is the person's numeric chat id (sender.id of a dm_received event); only private chats (groups and channels: 403 telegram_private_chats_only, publish there with the upload tools); text up to 4096 characters. 403 telegram_recipient_not_started (the person never started the bot) or telegram_recipient_blocked; 504 telegram_send_unconfirmed means it may have been sent: list the conversation before retrying. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), platform (required), buttons, contact, +14 more. Returns: result

send_feedbackSend feedback to the Upload-Post teamAInspect

Tell the Upload-Post team about a problem with this API or these tools: an error you could not understand, a tool description that did not match what happened, something that looks like a bug, or a capability you needed and could not find. Use it once per problem, after you have tried to solve it; do not use it for errors the response already explains (expired connection, plan limit, payment). Describe the API, not the user's content: never include credentials, personal data or the text of the user's posts. It does not open a support ticket and gets no reply; for help with their account, the user can write to info@upload-post.com.

Inputs: message (required), tool, agent, category, +1 more. Returns: result

set_post_commentsTurn comments on or off for an Instagram postA
Destructive
Inspect

Turn commenting off on one of the profile's own Instagram posts, or back on with enabled: true. Existing comments are kept either way. Instagram only.

Inputs: user (required), postId (required), enabled (required). Returns: result

start_autodmStart an AutoDM or comment auto-replyAInspect

Watch one of the profile's posts and automatically answer everyone who comments on it (optionally only comments containing trigger_keywords, e.g. 'comment POST'). On Instagram (default) the answer is a private DM with reply_message and up to 3 link buttons. On tiktok, youtube, facebook, threads and bluesky it is a PUBLIC reply under each matching comment; links in TikTok replies are not clickable, so point people to the bio. Instagram and TikTok answer new comments within seconds; youtube, facebook, threads and bluesky check for them every monitoring_interval minutes (15 minimum). At most 25 replies per interval (10 on YouTube), and the monitor stops after 15 days. Returns the monitor ID used by the other AutoDM tools. For Instagram DMs on EVERY post of the account, story replies, story mentions or DM keywords, use create_autodm_rule instead: rules cover the whole account, never expire and work only through Instagram webhooks. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: reply_message (required), profile_username (required), buttons, post_id, +6 more. Returns: result

stop_autodmStop an AutoDMA
Destructive
Inspect

Stop an AutoDM monitor: it stops sending DMs and shows as stopped in list_autodms (with include_inactive). For a temporary break use pause_autodm; to remove it entirely use delete_autodm.

Inputs: monitor_id (required). Returns: result

submit_ffmpeg_jobSubmit FFmpeg processing jobAInspect

Process media with FFmpeg on Upload-Post's encoding servers (trim, transcode, resize, watermark, concatenate, extract a thumbnail…). Inputs are public HTTP(S) URLs: input_url for one file, or files for several. They are downloaded into a working directory of their own for this job. full_command is one ffmpeg invocation using the placeholders {input} (or {input0}, {input1}… with several files) and {output}, e.g. ffmpeg -i {input} -ss 5 -t 10 -c copy {output}. It runs without a shell and must start with ffmpeg. Every -i must be an {input}/{inputN} placeholder or a generated -f lavfi source, and {output} is the only output. Rejected with a 400 that names the problem: shell metacharacters (; | & $ ), protocols or URLs anywhere in the command (file:, concat:, subfile,…), the movie=, amovie=andsendcmdfilters, absolute paths other than fonts under /usr/share/fonts,.., and -safe 0. A command that would never end (-stream_loop -1, -loop 1, or a lavfi source without a duration) needs -t, -shortestor-frames; -stream_loopaccepts -1 to 100. Usage is charged at the longer of the input and output durations, so looped or generated outputs count at their full length. The output is not posted anywhere; fetch it with download_ffmpeg_result. Returns ajob_idyou can poll withget_ffmpeg_job`.

Inputs: files, input_url, full_command, output_filename. Returns: result

test_webhook_subscriptionTest a webhook subscriptionAInspect

Send one signed sample event to a subscription now, with the keys of the real event and test: true. ok is true when the destination answered with a status below 400 (a redirect counts as delivered). Logged as a test delivery: never retried and never counted towards disabling the subscription. 409 subscription_disabled or blocked_url; 400 invalid_event when event is not one of the subscription's events. Not generally available yet: until webhook subscriptions are switched on for the account, every call answers 503 with reason webhook_subscriptions_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: subscription_id (required), event, confirmed. Returns: result

tiktok_publishing_settingsGet TikTok publishing settingsA
Read-only
Inspect

What the connected TikTok account is allowed to publish. Call this before setting tiktokPrivacyLevel: TikTok narrows the four privacy values per account (a private account has no PUBLIC_TO_EVERYONE), and sending one the account does not have fails the upload with error_code tiktok_privacy_unavailable. Returns privacy_level_options plus the account's max video duration and its comment/duet/stitch switches.

Inputs: profile (required). Returns: result

unpublish_postDelete a published postA
Destructive
Inspect

Delete a post already published to a platform. Supported: facebook, youtube, x, linkedin, pinterest, bluesky, google_business. Instagram, TikTok, Threads and Reddit posts cannot be deleted through Upload-Post; they have to be removed in the platform's own app. Telegram posts can be deleted too: pass the post id returned by the upload. Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: user (required), postId (required), platform (required), confirmed, +1 more. Returns: result

update_google_business_locationEdit Google Business location infoA
DestructiveIdempotent
Inspect

Edit the public info of the Google Business location (what shows on Google Search and Maps). edit_mode legacy (default): only description, website, phone, additional_phones, regular_hours, special_hours, primary_category, additional_categories; an empty value clears the field. edit_mode strict: also title, address, service_area, more_hours, open_status (OPEN, CLOSED_TEMPORARILY, CLOSED_PERMANENTLY), opening_date, store_code, labels; an empty value leaves the field as it is and null clears it; title, address, primary_category, phone and closing the business need confirm, and dry_run checks the change with Google without applying it. validate_only checks with Google in both modes. Read the current values first with google_business_read location_info. Changes go live on Google.

Inputs: user (required), fields (required), confirm, dry_run, +4 more. Returns: result

update_queue_settingsUpdate queue settingsB
Destructive
Inspect

Update posting queue configuration for a profile. Fields are flat, not nested: timezone, slots, days_of_week, and max_posts_per_slot. With slots "auto", get_queue_settings returns slots_mode, auto_slots and effective_slots (what the queue uses).

Inputs: profile_username (required), slots, refresh, timezone, +5 more. Returns: result

upload_documentUpload document (LinkedIn)AInspect

Publish a document (PDF / PPT / PPTX / DOC / DOCX) to LinkedIn. Title is required. firstComment posts a comment under the document right after it is published. LinkedIn mentions: write @Exact Page Name, @Name or @company-vanity in the LinkedIn text. A company name must match the Page's name on LinkedIn exactly, capitals included, or it is published as plain text. Publishing now needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve. Calls with scheduledDate or addToQueue run straight away, since the post can still be reviewed and cancelled before it goes out.

Inputs: user (required), title (required), documentPathOrUrl (required), timezone, +9 more. Returns: result

upload_photosUpload photos / carouselAInspect

Publish one or more photos (single image or carousel; items are published in array order). Each item in photosPathsOrUrls must be a public/signed HTTPS URL (a staged media_url from complete_media_upload works), or an absolute local path only when the MCP server runs on the same machine as the file. One call can carry a different caption per platform: title is the default and platformOptions.facebookTitle, platformOptions.instagramTitle, platformOptions.linkedinTitle, platformOptions.xTitle, … override it for that platform. Bluesky shows at most 4 images per post: with more, the first 4 are published and the result carries a warning, unless platformOptions.blueskyGallery is true, which publishes up to 10 as a gallery (the first 10 when more are sent). LinkedIn mentions: write @Exact Page Name, @Name or @company-vanity in the LinkedIn text. A company name must match the Page's name on LinkedIn exactly, capitals included, or it is published as plain text. A hosted MCP server cannot read files on the user's machine or chat attachments (/mnt/data, sandbox paths). To publish a local file: (1) if this client can run HTTP requests itself (for example a coding agent with a shell), stage it with create_media_upload (returns upload_id + upload_url), PUT the raw file bytes to upload_url with the same Content-Type, call complete_media_upload and pass the returned media_url as the media URL; (2) otherwise ask the user for a public HTTPS URL of the file, or tell them to publish it from the dashboard at https://app.upload-post.com. Staged media is deleted after 24 hours. An identical call repeated in the following minutes (same arguments, e.g. after a timeout) returns the earlier result, marked idempotent_replay: true, instead of publishing again. To retry the platforms of an upload that failed, use retry_post. Publishing now needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve. Calls with scheduledDate or addToQueue run straight away, since the post can still be reviewed and cancelled before it goes out.

Inputs: user (required), platforms (required), photosPathsOrUrls (required), title, +10 more. Returns: result

upload_textUpload text postAInspect

Publish a text-only post. linkUrl (or platform-specific *LinkUrl) attaches a link preview where supported. LinkedIn mentions: write @Exact Page Name, @Name or @company-vanity in the LinkedIn text. A company name must match the Page's name on LinkedIn exactly, capitals included, or it is published as plain text. An identical call repeated in the following minutes (same arguments, e.g. after a timeout) returns the earlier result, marked idempotent_replay: true, instead of publishing again. To retry the platforms of an upload that failed, use retry_post. Publishing now needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve. Calls with scheduledDate or addToQueue run straight away, since the post can still be reviewed and cancelled before it goes out.

Inputs: user (required), title (required), platforms (required), linkUrl, +7 more. Returns: result

upload_videoUpload videoAInspect

Publish a video to one or more platforms. Use videoPathOrUrl only for public/signed HTTPS URLs, or for absolute local paths when the MCP server runs on the same machine as the file. videoBase64 is only for clients that can provide raw bytes directly and is capped by UPLOAD_POST_MAX_INLINE_MB (default 100). Returns a request_id you can poll with get_status. Supports per-platform overrides (tiktokPrivacyLevel, youtubePrivacyStatus, youtubePlaylistId, youtubeThumbnailUrl, youtubeTags, facebookPageId, instagramMediaType, etc.). LinkedIn mentions: write @Exact Page Name, @Name or @company-vanity in the LinkedIn text. A company name must match the Page's name on LinkedIn exactly, capitals included, or it is published as plain text. A hosted MCP server cannot read files on the user's machine or chat attachments (/mnt/data, sandbox paths). To publish a local file: (1) if this client can run HTTP requests itself (for example a coding agent with a shell), stage it with create_media_upload (returns upload_id + upload_url), PUT the raw file bytes to upload_url with the same Content-Type, call complete_media_upload and pass the returned media_url as the media URL; (2) otherwise ask the user for a public HTTPS URL of the file, or tell them to publish it from the dashboard at https://app.upload-post.com. Staged media is deleted after 24 hours. An identical call repeated in the following minutes (same arguments, e.g. after a timeout) returns the earlier result, marked idempotent_replay: true, instead of publishing again. To retry the platforms of an upload that failed, use retry_post. Publishing now needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve. Calls with scheduledDate or addToQueue run straight away, since the post can still be reviewed and cancelled before it goes out.

Inputs: user (required), platforms (required), title, timezone, +11 more. Returns: result

validate_jwtValidate platform-integration JWTA
Read-only
Inspect

Verify a JWT previously issued by generate_jwt. The returned profile object echoes the connection page settings, including language and any ui_labels.

Inputs: jwt (required). Returns: result

withdraw_pending_postWithdraw a post awaiting approvalA
Destructive
Inspect

Withdraw (its author) or discard (a reviewer) a post waiting for approval: it becomes withdrawn, will not be published and its media is deleted. It cannot be undone. 409 approval_closed when it was already decided. Not generally available yet: until post approvals are switched on for the account, these calls answer 503 post_approvals_disabled (the feature is off, not a temporary failure). Needs the user's approval: call it first without confirmed to get a preview (nothing is sent), show the user exactly what will go out, and repeat the call with confirmed: true only after they approve.

Inputs: approval_id (required), confirmed. Returns: result

youtube_readRead YouTubeA
Read-only
Inspect

Read-only YouTube data of the connected channel. Fields go in params with the API's names; lists page with max_results and page_token. videos (ids up to 50, parts, include_owner_details: status, processing, statistics, translations); quota (the account's allowance left today); rating (ids: the channel's like/dislike); playlists (ids or channel_id), playlist_items (playlist_id), playlist_image (playlist_id); captions (video_id: caption tracks); comments (video_id, or scope: channel for the whole channel; moderation_status published|heldForReview|likelySpam, order, search, include_replies), comment_replies (parent_id); search (q, for_mine, channel_id, type video|channel|playlist, order, published_after…; few searches per day: free plan 1, paid 5), categories (region), languages, regions; channel (settings, branding, translations, statistics), channel_lookup (for_handle, ids), channel_sections, subscriptions (filter mine|my_subscribers), activities; broadcasts (status active|upcoming|completed), broadcast (broadcast_id), streams, stream (stream_id; include_stream_key returns the secret key to the owner), live_chat (broadcast_id or live_chat_id, page_token; wait polling_interval_ms between reads), super_chats, live_moderators (broadcast_id or live_chat_id; 50 units a page); caption_download (caption_id, tfmt srt|vtt|sbv|scc|ttml, tlang to machine-translate, video_id; own videos only, 200 units, the same download within 10 minutes is free); abuse_reasons (hl: the reason ids report_abuse takes). Not generally available yet: every action here except videos and quota belongs to the new YouTube features, and until they are switched on for the account those actions answer 503 youtube_feature_disabled (a 503 with that code means the feature is off, not a temporary failure). Every call spends the account's daily YouTube allowance (free plan 200 units, paid plans 2,000; resets at midnight Pacific time; youtube_read quota shows what is left): reads cost about 1 unit, most writes 50, captions 400-450, so batch reads and avoid needless writes.

Inputs: action (required), user, params. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 120 tools

    Disambiguation2/5

    There is heavy functional overlap: `manage_autodms` re-implements `start_autodm`/`stop_autodm`/`pause_autodm`/`resume_autodm`/`delete_autodm`/`get_autodm_logs`/`list_autodms`, and `comment_action` re-implements `hide_comment`/`like_comment`/`pin_comment`/`approve_comment`/`ignore_comment`/`edit_comment`/`hold_comment`/`set_post_comments`. `manage_google_business` vs `update_google_business_location`, `manage_youtube_videos` vs `edit_post` (YouTube branch), and `manage_pinterest_boards` vs `get_pinterest_boards` also overlap. An agent will frequently pick the wrong sibling of a redundant pair.

    Naming Consistency3/5

    Everything is snake_case, which is good, and there are readable prefixes (tiktok_, youtube_, google_business_, bluesky_, manage_youtube_). But verb conventions are mixed: some read tools are `get_x` (get_analytics, get_media) while others are noun-first (`youtube_read`, `chatgpt_ads_read`, `bluesky_read`), and there is a large family of unconstrained `manage_*` god-tools sitting next to single-action verbs like `hide_comment` and `pin_comment`.

    Tool Count2/5

    120 tools is very heavy for any single server, even one spanning publishing, scheduling, DMs, comments and several ad/business platforms. A large share of the count is redundant (10+ comment tools collapsible into 2, 7 AutoDM tools plus the `manage_autodms` wrapper), so many tools do not earn their place.

    Completeness4/5

    Coverage is unusually broad and lifecycle-complete: publish (video/photo/text/document), schedule, queue, retry, edit, unpublish, analytics, comments, DMs, moderation, webhooks, media staging and FFmpeg. Real gaps exist — Reddit is disabled, Instagram/TikTok/Threads posts cannot be deleted, and large swaths of YouTube/Google Business/webhook-subscription actions return 503 until features are enabled.

    Maintenance

    ActivityActive
    ResponsivenessMixed handling

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      F
      maintenance
      Social media API and MCP server for AI agents that enables publishing to X, Instagram, LinkedIn, Reddit, Bluesky, and Threads from a single endpoint.
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      MCP server to manage social media accounts from AI assistants, enabling post creation, scheduling, publishing, and media uploads across multiple platforms.
      13
      9 npm
      1
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      MCP server for QPost that lets AI agents schedule and publish video/image posts to YouTube, TikTok, and Instagram via QPost's REST API.
      7
      45 npm
      MIT