Upload-Post
OfficialAn MCP server for publishing, scheduling, analyzing, engaging with, and managing social media through Upload-Post.
Publish videos, photos/carousels, text posts, and LinkedIn documents to TikTok, Instagram, YouTube, LinkedIn, Facebook, Pinterest, Threads, Bluesky, X, Google Business, Telegram, Discord, and more.
Schedule or queue posts; list, edit, cancel, retry, unpublish/delete, edit, repost, and act on published posts.
Check async upload/job status, upload history, and recent media from connected accounts.
Read analytics, impressions, per-post metrics, cached metrics, audience insights, hashtag/keyword suggestions, platform metrics, and best posting times.
Manage comments: read, create, reply, delete, hide, like, pin, edit, hold/approve/ignore, and enable/disable comments.
Send DMs and manage AutoDM monitors/rules for comment-to-DM and public auto-replies.
Manage profiles, social connections, Facebook/LinkedIn/Pinterest/Google Business resources, reviews, pages/boards/locations, queue settings, and webhooks.
Stage local media for upload, process media with FFmpeg jobs, use TikTok music/location/publishing helpers, and send feedback to Upload-Post.
Allows publishing, scheduling, analyzing, and managing posts on Bluesky.
Allows publishing, scheduling, analyzing, and managing posts on Discord, including sending DMs and managing conversations.
Allows publishing, scheduling, analyzing, and managing posts on Facebook, including managing Facebook pages.
Provides tools to submit FFmpeg video processing jobs, monitor their status, and download results.
Allows publishing, scheduling, analyzing, and managing posts on Instagram, including video and photo uploads.
Allows publishing, scheduling, analyzing, and managing posts on Pinterest, including managing boards.
Allows publishing, scheduling, analyzing, and managing posts on Reddit, including detailed post management.
Allows publishing, scheduling, analyzing, and managing posts on Telegram.
Allows publishing, scheduling, analyzing, and managing posts on Threads.
Allows publishing, scheduling, analyzing, and managing posts on TikTok, including video uploads.
Allows publishing, scheduling, analyzing, and managing videos on YouTube.
@upload-post/mcp
Official Model Context Protocol (MCP) server for Upload-Post.
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-postSDK 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-mcpTwo 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_SESSIONSand 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 |
|
Media staging |
|
Status |
|
Schedule |
|
Analytics |
|
Audience |
|
Users |
|
Pages/boards |
|
Pinterest and limits |
|
Posts |
|
Best times |
|
Telegram |
|
Bluesky |
|
YouTube |
|
Google Business |
|
Comments |
|
TikTok |
|
DMs |
|
AutoDM rules |
|
Webhooks |
|
Team approvals |
|
ChatGPT Ads |
|
FFmpeg |
|
Queue |
|
Feedback |
|
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 |
|
|
|
YouTube |
|
| |
|
| ||
|
|
| |
|
|
|
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. Alsobenchmark_categories, and the niche averages to compare against whenbenchmarkCategoryis set. The server clamps the window to at most 60 days ending before today, so a wider range is trimmed rather than rejected, andrangein the response says which window was used.get_suggestions— hashtags (withview_count) or related keyword searches, told apart bytype, not by a different tool.get_post_comments— top-level comments on a post, or, withcommentId, the replies under one of them (TikTok, Threads, YouTube, Instagram, Facebook and LinkedIn Page posts; LinkedIn prefers the fullcomment_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_commenton X — links are removed unless the account is allowed links on X (reported inwarnings); a message that was only links fails with 400x_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 429x_daily_write_limitwithretry_afterand aRetry-Afterheader.hide_comment,like_comment,pin_comment,edit_comment,hold_comment,approve_comment,ignore_comment,set_post_comments— one tool per moderation operation.comment_actiondoes the same through a singleactionargument and stays available everywhere except ChatGPT, which only gets the one-operation tools (the same goes formanage_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, byrequestId(posts published through Upload-Post, TikTok drafts once published publicly) or byplatformPostId+platform+user(any post of the connected account).post_metricsis whatever the platform reports, so its shape varies: on TikTok it addsretention,impression_sources,audience_types,new_followers,reachand 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 withpreserve_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"].mimeTypescontainingtext/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=offturns 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 8080Inspect the live tool surface with the official inspector:
npx @modelcontextprotocol/inspector node dist/index.jsConfiguration
Env var | Mode | Default | Description |
| stdio | — (required) | Single user's Upload-Post API key. Ignored in |
| both |
| Override for self-hosted / staging. |
| stdio | — | Team members: the account owner's email, sent as |
| http |
| Port for |
| http |
| Largest |
| http |
| Check a pasted API key once against |
| http |
| How long an accepted key is trusted before it is checked again. |
| 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. |
| http |
| 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. |
| http |
| Sessions of one credential kept in memory; past it that credential's own longest-idle one leaves memory (and is rebuilt when used again). |
| http |
| Idle time after which a session leaves memory. It still works afterwards: it is rebuilt on its next request. |
| http |
|
|
| http |
| Window for the count above; a held IP is released this long after its last failure. |
| http |
| While held, one request per this many seconds goes through the normal auth path. |
| http |
| Whether the client IP is the last |
| http |
| 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. |
| both | on |
|
| http | Current Upload-Post challenge token | Optional override for ChatGPT Apps domain verification at |
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. RequiresAuthorization: ApiKey <key>(orBearer <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…):
Point the PaaS at this repo and select Dockerfile as the build pack.
Port: 8080 (matches
EXPOSE 8080).Environment variables: none are required. Optionally set
UPLOAD_POST_BASE_URLif you point at staging.Health check path:
/healthz(HTTP, port 8080).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
Authorizationheader the server returns401. 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_studiofor 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 toupload_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 toupload_url→complete_media_upload, then pass the returnedmedia_urltoupload_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
videoBase64toupload_videoinstead ofvideoPathOrUrl. The server writes it to a temp file, uploads, then deletes it. Inline bytes are capped atUPLOAD_POST_MAX_INLINE_MB(default 100 MB), and in--httpmode the whole request atUPLOAD_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
Authorizationheader, 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).
/mcprequires a validAuthorizationheader 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
Originheader 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 withOAUTH_EXTRA_ALLOWED_ORIGINS(comma-separated) when self-hosting behind a custom dashboard.OAuth metadata is served both at
/.well-known/oauth-protected-resourceand at the path-inserted form/.well-known/oauth-protected-resource/mcp(RFC 9728 §3.1), and likewise foroauth-authorization-server.In
--httpmode 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). SetUPLOAD_POST_MCP_ACCESS_LOG=allto log every request oroffto disable it.If ChatGPT shows
redirect_uri not on allow-listduring OAuth, add the exactredirect_urifrom the failing authorize request to the Upload-Post backend OAuth redirect allow-list. For ChatGPT clients this is typically onhttps://chatgpt.com/.../oauth/callbackorhttps://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 othermcp-remote-style clients. Platforms without a documented fixed callback (e.g. Grok, Le Chat production) are added on request.All tools declare MCP
readOnlyHint/destructiveHintannotations so clients can surface confirmation prompts for destructive operations, and the tools that publish or message people also require an explicitconfirmed: 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 toolsapprove_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 BlueskyARead-onlyInspect
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 postBDestructiveInspect
Cancel a scheduled post by its job_id.
Inputs: jobId (required). Returns: result
chatgpt_ads_readRead ChatGPT AdsARead-onlyInspect
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 commentADestructiveInspect
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 replyADestructiveInspect
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 subscriptionAIdempotentInspect
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 AutoDMADestructiveInspect
Permanently delete an AutoDM monitor with its stats and logs. Cannot be undone.
Inputs: monitor_id (required). Returns: result
delete_autodm_ruleDelete an AutoDM ruleADestructiveInspect
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 commentADestructiveInspect
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 profileADestructiveInspect
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 subscriptionADestructiveIdempotentInspect
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 URLARead-onlyInspect
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 commentADestructiveInspect
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 postADestructiveIdempotentInspect
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 postADestructiveInspect
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 JWTADestructiveInspect
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 infoARead-onlyInspect
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 analyticsBRead-onlyInspect
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 insightsARead-onlyInspect
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 logsARead-onlyInspect
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 postARead-onlyInspect
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 analyticsARead-onlyInspect
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_connect_linkGet link to connect social accountsAInspect
Get the link the user opens to connect (or reconnect) social accounts such as TikTok, Instagram or YouTube. Use it when list_users shows no profile, or the platform the user wants is not connected or needs reconnecting. If the account has no profile yet, this creates one named "default" and returns a one-click link to connect accounts to it (valid 48 h); otherwise it returns the dashboard link. Give the user connect_url, ask them to tell you when they are done, then call list_users to confirm before publishing.
Inputs: profile, platforms. Returns: result
get_facebook_pagesList Facebook pagesCRead-onlyInspect
Facebook pages connected to a profile.
Inputs: profile. Returns: result
get_ffmpeg_consumptionGet FFmpeg quota usageARead-onlyInspect
Monthly FFmpeg processing minutes used vs. plan allowance.
Inputs: no named parameters. Returns: result
get_ffmpeg_jobPoll FFmpeg job statusARead-onlyInspect
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 locationsBRead-onlyInspect
Google Business Profile locations the profile can post to.
Inputs: profile. Returns: result
get_google_business_reviewsList Google Business reviewsARead-onlyInspect
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 historyBRead-onlyInspect
Paginated history of uploads across all profiles.
Inputs: page, limit. Returns: result
get_job_statusGet scheduled job statusARead-onlyInspect
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 pagesARead-onlyInspect
LinkedIn company pages connected to a profile.
Inputs: profile. Returns: result
get_mediaGet recent media from connected accountsARead-onlyInspect
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 uploadARead-onlyInspect
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 boardsCRead-onlyInspect
Pinterest boards available to a profile.
Inputs: profile. Returns: result
get_platform_metricsList platform metricsARead-onlyInspect
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 commentsARead-onlyInspect
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 limitsARead-onlyInspect
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 settingsARead-onlyInspect
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 postsARead-onlyInspect
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 postARead-onlyInspect
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 statusARead-onlyInspect
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 suggestionsARead-onlyInspect
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 infoARead-onlyInspect
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 impressionsBRead-onlyInspect
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 deliveryARead-onlyInspect
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 BusinessARead-onlyInspect
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 commentADestructiveInspect
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 reviewADestructiveInspect
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 replyADestructiveInspect
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 rulesARead-onlyInspect
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-repliesARead-onlyInspect
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 conversationsARead-onlyInspect
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 approvalARead-onlyInspect
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 postsARead-onlyInspect
List all currently scheduled (not-yet-published) posts.
Inputs: no named parameters. Returns: result
list_usersList profilesARead-onlyInspect
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 deliveriesARead-onlyInspect
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 subscriptionsARead-onlyInspect
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 monitoringADestructiveInspect
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 accountADestructiveInspect
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 AdsADestructiveInspect
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 BusinessADestructiveInspect
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 profileADestructiveInspect
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 botADestructiveInspect
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 accountADestructiveInspect
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 chatADestructiveInspect
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 paymentsADestructiveInspect
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 settingsADestructiveInspect
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 channelADestructiveInspect
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 commentsADestructiveInspect
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 liveADestructiveInspect
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 playlistsADestructiveInspect
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 videosADestructiveInspect
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 freeAIdempotentInspect
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 ruleAIdempotentInspect
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 commentADestructiveInspect
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 postAIdempotentInspect
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 queueARead-onlyInspect
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 commentADestructiveInspect
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 postADestructiveInspect
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 commenterADestructiveInspect
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 reviewADestructiveInspect
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 PageARead-onlyInspect
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 ruleAIdempotentInspect
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 postAIdempotentInspect
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 messageADestructiveInspect
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 postADestructiveInspect
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 AutoDMADestructiveInspect
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_location_searchSearch TikTok locationsARead-onlyInspect
Search TikTok places to tag on a post. TikTok needs both parts, so pass the returned location_id as tiktokLocationId and location_name as tiktokLocationName in upload_video's platformOptions. Available on TikTok connections that declare the location capability (see capabilities on the TikTok account in list_users).
Inputs: query (required), profile (required). Returns: result
tiktok_music_searchSearch TikTok musicARead-onlyInspect
Find a TikTok Commercial Music Library track by song title or artist, to soundtrack a TikTok video. Pass the returned track id as tiktokMusicId in upload_video's platformOptions (not commercial_music_id, which TikTok rejects on public posts). IMPORTANT: TikTok has no music search endpoint, so this searches the trending charts Upload-Post caches per genre/country/period, NOT TikTok's whole catalogue — a song that is not trending in the chart you query will not be found; widening the search means trying another genre, country or period. Matching is case- and accent-insensitive and every word must match. Available on TikTok connections that declare the music capability (see capabilities on the TikTok account in list_users).
Inputs: profile (required), q, genre, limit, +2 more. Returns: result
tiktok_music_trendingList trending TikTok musicARead-onlyInspect
Trending tracks from the TikTok Commercial Music Library, to soundtrack a TikTok video. Pass the returned track id as tiktokMusicId in upload_video's platformOptions (not commercial_music_id, which TikTok rejects on public posts). Available on TikTok connections that declare the music capability (see capabilities on the TikTok account in list_users).
Inputs: profile (required), genre, dateRange, countryCode. Returns: result
tiktok_publishing_settingsGet TikTok publishing settingsARead-onlyInspect
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 postADestructiveInspect
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 infoADestructiveIdempotentInspect
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 settingsBDestructiveInspect
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 JWTARead-onlyInspect
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 approvalADestructiveInspect
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 YouTubeARead-onlyInspect
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
Scored across 120 tools
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.
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`.
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.
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
Related MCP Connectors
Publish and schedule videos to TikTok, YouTube Shorts, Instagram, Facebook, LinkedIn, Pinterest, Bluesky, Threads and X from Claude, Cursor or any MCP client. Upload once, post everywhere, track views in unified analytics, and retry failed posts. Official platform APIs only, free plan available. Docs: https://docs.multi-upload-tool.com/mcp
MCP server for QPost — lets AI agents publish video and image posts to YouTube, TikTok, Instagram.
Agent-first social media publishing, scheduling, analytics, and unified inbox API + 16-tool MCP server across 18 social platforms (X, LinkedIn, Instagram, YouTube, TikTok, Threads, Bluesky, Reddit, Telegram, Discord, Mastodon, Facebook, Pinterest).
Schedule and publish posts to TikTok, Instagram, YouTube, LinkedIn and more from any AI agent. Connect your social accounts once, then let Claude, ChatGPT or any MCP client create, schedule, edit and review posts across every platform. Upload images and videos to your media library and attach them to posts. Signs in with OAuth; HubPost never sees your passwords. Also available in the [Claude directory](https://claude.ai/directory/hubpost) and as a [ChatGPT app](https://chatgpt.com/plugins/plugin_asdk_app_6ab141477a708191a7c5f68714ee7c39). Setup guide: [hubpost.co/mcp](https://hubpost.co/mcp?utm_source=glama&utm_medium=mcp-directory).
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceSocial media API and MCP server for AI agents that enables publishing to X, Instagram, LinkedIn, Reddit, Bluesky, and Threads from a single endpoint.MIT
- AlicenseAqualityDmaintenanceA local MCP server that lets Claude post to social media via upload-post.com — text, photos, and videos across 13 platforms.17MIT
- AlicenseAqualityCmaintenanceMCP server to manage social media accounts from AI assistants, enabling post creation, scheduling, publishing, and media uploads across multiple platforms.139 npm1MIT
- AlicenseAqualityCmaintenanceMCP server for QPost that lets AI agents schedule and publish video/image posts to YouTube, TikTok, and Instagram via QPost's REST API.745 npmMIT