API Documentation

The Status 200 Uploads API lets you upload media and publish to TikTok, Instagram, Facebook, YouTube, X (Twitter), LinkedIn, Pinterest, Threads, and Skool programmatically.

It imports a media file from a URL (/media) or takes one uploaded from a computer through a one-time link (/media/uploads, paid plans), creates a post that is published at once or scheduled for later (/posts, with post.scheduledFor), and cancels a scheduled post (DELETE /posts/{id}). It also reads back your profiles and their connected networks (GET /accounts), what each network allows (GET /accounts/{id}/options), and your posts with their status, link and figures (GET /posts, GET /posts/{id}). Connecting accounts, analytics across posts and the calendar are in the dashboard.

The API is described in OpenAPI 3.1 at https://status200uploads.com/openapi.yaml, both URLs, every answer and every error code: import it into Postman or Insomnia, or generate a client from it.

The older URLs https://app.status200uploads.com/functions/v1/api-posts and https://app.status200uploads.com/functions/v1/api-media-upload accept the same requests and keep working.

Supported Platforms

Authentication

All API requests require a valid API key passed in the Authorization header using Bearer token format.

Generating API Keys

1. Sign in to your dashboard
2. Navigate to API Management
3. Click "Generate Key" and give it a descriptive name
4. Copy the key immediately - it will only be shown once

Using Your API Key

Authorization: Bearer rl_your_api_key_here

A post or a media import may also carry an optional Idempotency-Key header, so that a request sent again after a timeout is never done twice (see Safe Retries).

Key Rotation Best Practices

• 1. Generate a new key before revoking the old one
• 2. Update all services to use the new key
• 3. Verify traffic is flowing with the new key
• 4. Revoke the old key from your dashboard

Connect an AI app (Claude, Cursor, VS Code …)

Status 200 Uploads runs an MCP server at https://mcp.status200uploads.com/mcp. Add that address in your AI app, sign in to Status 200 Uploads on the page it opens, and choose whether the app may only read or may also post. No key is copied anywhere. Connected apps are listed under Dashboard → API, and Disconnect cuts one off at once. The AI connector (this MCP server) is included in every paid plan, from Beginner, whether an app signs in or sends an API key. On Free, use the REST API with your rl_ API keys.

An app you connected this way gets the seventeen tools below. Everything a connected app does goes through the same rules as the REST API — your plan's post allowance, the X add-on, the 20-second spacing between posts — and it can only ever see the account that signed in.

An app that can run commands on your computer (tested with Claude Code; other AI apps that can run commands may work) can also post a video or an image that is on that computer: it asks for a one-time private upload link, runs our small uploader, and the file is checked (exact size, type and SHA-256) before it can be posted. Nothing is put on a public site on the way. This is part of the paid plans, within one daily budget per account for every upload link and the URL imports of connected AI apps (see Upload from a computer); an app that cannot run commands sends you to the dashboard (Media) instead.

A file you already uploaded in the dashboard (Media) needs no link at all: tell the app its name, and it finds it in your media library and posts it by its file id. The app sees each file's name, type, size and upload time, never its address.

Or connect with an API key

An MCP client that cannot sign in can send an rl_ key instead. That path needs a paid plan too (the key of a Free account works with the REST API only) and offers the older, smaller set of tools (server info, create a post, import media). The Integrations hub has a snippet per client, and https://mcp.status200uploads.com/health says whether the server is up.

{
  "mcpServers": {
    "status200-uploads": {
      "url": "https://mcp.status200uploads.com/mcp",
      "headers": {
        "Authorization": "Bearer rl_put_your_dashboard_key_here"
      }
    }
  }
}

Running your own copy of the server? Keep SUPABASE_SERVICE_ROLE_KEY on that machine only — never in an agent, a repository or a browser bundle. The operational detail is in mcp-server/README.md.

Rate Limits

Your plan sets a post allowance: successful posts, all platforms combined. Free: 30 per account per calendar month (UTC), for every Free account from 18 October 2026. Posts published from 1 October 2026 count toward October's 30; if 30 or more are already used on 18 October 2026, posting pauses until 1 November 2026. Until 18 October 2026, Free accounts created since 18 September 2026 have 60 per calendar month and older ones 5 per profile per UTC day. Beginner and Apprentice: per profile per UTC day (00:00 to 24:00 UTC). Skilled and up: no allowance. Failed posts do not count. The same allowance applies to the dashboard, the scheduler and the API. Posts to X use the X add-on's own allowance (200 per billing month, up to 20 with links), not the plan's.

Over a daily allowance a request is answered HTTP 202 queued_for_next_day and the post is queued for the same time on the next day; over the Free monthly allowance it is answered 429 monthly_limit_reached (see the Create a post reference for the responses). A post scheduled with post.scheduledFor is checked against the allowance when it goes out, not when it is scheduled.

Safe Retries (Idempotency-Key)

A request can time out after the post already went out. Send an Idempotency-Key header with a value that names this one request (a UUID, or something like order-42-tiktok), and send it again with the same key and the same body: if the first request got an answer within the last 24 hours, you get that answer back, byte for byte, with the header Idempotent-Replayed: true, and nothing is posted or imported a second time.

• - Optional, on POST only, at four addresses: /api/v2/posts, /api/v2/media, and the older https://app.status200uploads.com/functions/v1/api-posts and https://app.status200uploads.com/functions/v1/api-media-upload. A request without the header works exactly as before. GET, DELETE and dry runs ignore it.
• - 1 to 255 printable ASCII characters (letters, digits, spaces and punctuation). Spaces around it and one pair of double quotes are removed. An empty value or anything else is refused with 400 idempotency_key_invalid and nothing is sent.
• - A key belongs to the API key that sent it, and posts and media are kept apart: the same value can name a media import and the post that uses it. The two posts addresses share one entry (a key sent to one and then the other is answered again at the second), and so do the two media addresses. A key is remembered for 24 hours from the first request; after that it is new again.
• - The same request means the same JSON body (the order of its fields does not matter). The same key with a different body is refused with 422 idempotency_key_reused (first_used_at says when the key was first used), and nothing is sent: use a new key for each new request.
• - While the first request is still being worked on, the same key gets 409 idempotency_in_progress with Retry-After: 5 (and retry_after_seconds in the body): send it again then to get its answer. This is a different code from media_processing.
• - A first request that never finished (more than 10 minutes without an answer) gets 409 idempotency_outcome_unknown and no Retry-After: for a post, check GET /api/v2/posts or History, and if it is not there send it with a new key; for a media import, send it again with a new key (a second import does no harm).
• - When the key cannot be checked just now, the answer is 503 idempotency_unavailable with Retry-After: 5, and nothing is sent: send the same request with the same key again. Rarely, that key is then answered 409 idempotency_in_progress for up to 10 minutes and idempotency_outcome_unknown after. If every earlier try with that key got an answer (none timed out) and each was a 503 idempotency_unavailable, nothing was sent: send it with a new key.

What is remembered

• - Remembered: every 2xx answer (published, processing, still_publishing, scheduled, queued for the next day; for media a 200 or 202 with its file_id), and an answer whose outcome we could not confirm (the post may have gone out), such as a 5xx that names no cause (platform_error on /api/v2/posts) after the post was handed to the network. Those are answered again for 24 hours: check History, and send the post again with a new key only if it is not there.
• - Not remembered: refusals (400 to 429, media_processing, the 503s before sending) and failures the network reported with their own code (History shows them as failed). Fix what the message names and send it again with the same key: it is sent afresh, so a retry loop sends such a failure to the network again on every try.
• - An answer sent again is the first answer, not the current state: a replayed 202 still_publishing, processing or scheduled says what happened then. Read status200.status_url (or GET /api/v2/media?file_id= for an import) for the outcome. To send a post again after it failed in the background, use a new key.
• - An answer sent again takes no 20-second wait and counts as a request in your API key's request count (it is in your request log); it never uses the post allowance.

curl -i -X POST 'https://status200uploads.com/api/v2/posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -H 'Idempotency-Key: 8e03978e-40d5-43e8-bc93-6894a57f9324' \
  -d '{"post": {"accountId": "@yourprofile", "platform": "x", "content": {"text": "Hello"}}}'
# The same command again: the same answer, with "Idempotent-Replayed: true", and one post.

Retry automatically only after a timeout, a lost connection, a 5xx without our error.code (a gateway's page), and the codes in RETRY_CODES above, each after its Retry-After: nothing was sent then, or the first answer comes back. After any other 5xx, read the message and check History first. In n8n, Make and Zapier, build the key from the item and the network (for example {{ $json.id }}-tiktok, with an id that is never empty), never from the time or a random value, so that a retry sends the same key, and keep the body the same on every try (see the Guides).

Quick Start

Get up and running in two steps: upload media, then publish a post.

curl -X POST 'https://status200uploads.com/api/v2/media' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{"url": "https://example.com/video.mp4"}'

{
  "success": true,
  "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "size": 5242880,
  "type": "video/mp4",
  "status": "ready"
}

curl -X POST 'https://status200uploads.com/api/v2/posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{
    "post": {
      "accountId": "@yourprofile",
      "platform": "tiktok",
      "content": {
        "text": "My first API post! #automation",
        "mediaID": ["YOUR_FILE_ID"]
      },
      "tiktok": {
        "privacyLevel": "PUBLIC_TO_EVERYONE"
      }
    }
  }'

{
  "data": {
    "status": "processing",
    "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "publish_id": "v_pub_url~v2-1.7123456789012345678",
    "message": "Post is being processed. Check post history for updates."
  },
  "status200": {
    "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "scheduled_post_id": null,
    "status_url": "https://status200uploads.com/api/v2/posts/b2c3d4e5-f6a7-8901-bcde-f12345678901"
  }
}

Full URL: POST https://status200uploads.com/api/v2/posts. The older URL POST https://app.status200uploads.com/functions/v1/api-posts accepts the same request and keeps working (its few differences are listed at the end of this section). A post that has not gone out yet can be cancelled with DELETE https://status200uploads.com/api/v2/posts/{id}. Every answer that made a post or a scheduled post names it in a status200 field, and GET https://status200uploads.com/api/v2/posts/{id} reads it back: its status, its link on the network and its figures. GET https://status200uploads.com/api/v2/posts lists your posts and your waiting posts, and GET https://status200uploads.com/api/v2/accounts your profiles (see List profiles, Posting options, List posts and Read a post, below).

The whole API, at both URLs, with every answer and every error code, is described in OpenAPI 3.1 at https://status200uploads.com/openapi.yaml: import it into Postman or Insomnia, or generate a client from it.

To publish later, send post.scheduledFor with a time zone: the post is scheduled for that time and the answer is 202 scheduled (see Schedule and cancel, below). A time in the past or within the next 60 seconds publishes at once.

Besides scheduledFor, a post is deferred in one case: when a Beginner or Apprentice profile has used its daily allowance (successful posts per profile per UTC day, all networks combined, see Rate Limits), the request is not refused. The server answers 202 Accepted and queues the post for the next day. On the Free plan (30 successful posts per calendar month per account) a post over the allowance is refused with 429 monthly_limit_reached. Skilled, Expert and Agency have no allowance (publish attempts are capped at 500 per profile per UTC day).

Media is required, except for text-only posts: these are accepted for Threads, X, LinkedIn, Skool and Facebook. A Facebook post with no media field is a text post on both URLs: facebook.postType can be left out (or set to "text"), and content.text is required. Without a postType, a media field sent empty ([] or null) is refused with 400 on both URLs, so a failed media step never publishes the text alone; with postType "text" it is a text post. Skool needs a paid plan (Beginner or higher) and X needs the X add-on ($9/month, any plan); every other network is available on every plan.

Platform-Specific Options

Put a platform object inside post, next to content (for example post.tiktok). Each platform supports different options. A field we do not use does not stop the post: it is sent, and the answer names the field in warnings (see Fields we did not use, below).

File Size Limits per Network

The media import accepts videos up to 5 GB, but each network has its own publishing limit. Video sizes on every network, and image sizes on TikTok, Instagram, X, Pinterest and Threads, are checked on the server before anything is sent to the network: a file that is too large for the chosen network is refused with 413 and the error code MEDIA_TOO_LARGE (example below). Image sizes for Facebook, LinkedIn and Skool are not checked on our side: those networks decide.

curl -X POST 'https://status200uploads.com/api/v2/posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{
    "post": {
      "accountId": "@myprofile",
      "platform": "instagram",
      "content": {
        "text": "Check out this reel! #trending",
        "mediaID": ["a1b2c3d4-e5f6-7890-abcd-ef1234567890"]
      },
      "instagram": {
        "postType": "reel",
        "shareToFeed": true
      }
    }
  }'

Waits and Timeouts

• - Every answer arrives within about 25 seconds. Set the timeout of your HTTP client to 30 seconds or more.
• - A scheduled post (post.scheduledFor) is answered at once with 202 scheduled: nothing is sent until its time, and it takes no 20-second wait.
• - A mediaID whose import is still running is waited for up to about 12 seconds. If it is not ready by then, the answer is 409 media_processing and nothing is published.
• - A network that has not answered after about 24 seconds gets 202 still_publishing: publishing continues in the background and the outcome appears in History within a few minutes, or poll GET /api/v2/posts/{status200.post_id} every 30 seconds, for up to 10 minutes, until done is true.
• - YouTube uploads always continue in the background (202, data.status "processing"). So do large videos on X and Skool (over 100 MB), LinkedIn (over 200 MB) and Facebook (over 1 GB): 202 with a job_id and a post_id, sent in the background, result in History. TikTok and Instagram answer 200 with "processing" and finish the post after the response.

{
  "data": {
    "status": "processing",
    "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "container_id": "17912345678901234",
    "message": "Post is being processed. Check post history for updates."
  },
  "status200": {
    "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "scheduled_post_id": null,
    "status_url": "https://status200uploads.com/api/v2/posts/b2c3d4e5-f6a7-8901-bcde-f12345678901"
  }
}

{
  "scheduled": true,
  "code": "scheduled",
  "message": "Scheduled for 2026-10-01T09:00:00.000Z. It will be published then, usually within a few minutes of that time. Your plan's allowance is checked when it goes out, not now. To cancel it, send DELETE https://status200uploads.com/api/v2/posts/c3d4e5f6-a7b8-9012-cdef-123456789012.",
  "scheduled_post_id": "c3d4e5f6-a7b8-9012-cdef-123456789012",
  "scheduled_at": "2026-10-01T09:00:00.000Z",
  "platform": "tiktok",
  "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
  "data": {
    "status": "scheduled",
    "scheduled_post_id": "c3d4e5f6-a7b8-9012-cdef-123456789012",
    "scheduled_at": "2026-10-01T09:00:00.000Z"
  },
  "status200": {
    "post_id": null,
    "scheduled_post_id": "c3d4e5f6-a7b8-9012-cdef-123456789012",
    "status_url": "https://status200uploads.com/api/v2/posts/c3d4e5f6-a7b8-9012-cdef-123456789012"
  }
}

{
  "queued": true,
  "code": "queued_for_next_day",
  "message": "Daily post limit reached for this profile (20/20 today, all platforms combined). Post queued for 2026-09-19T14:30:00.000Z.",
  "upgrade_url": "https://status200uploads.com/pricing",
  "scheduled_post_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "scheduled_at": "2026-09-19T14:30:00.000Z",
  "limit": 20,
  "used": 20,
  "plan": "beginner",
  "status200": {
    "post_id": null,
    "scheduled_post_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "status_url": "https://status200uploads.com/api/v2/posts/a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}

{
  "success": false,
  "status": "unknown",
  "code": "still_publishing",
  "retry": false,
  "message": "The network is taking longer than this request can wait, so the outcome is not known yet. Publishing continues in the background and the result appears in the post history within a few minutes. Do not send this request again: it may already have been published.",
  "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
  "status200": {
    "post_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "scheduled_post_id": null,
    "status_url": "https://status200uploads.com/api/v2/posts/b2c3d4e5-f6a7-8901-bcde-f12345678901"
  }
}

{
  "error": {
    "code": "media_not_found",
    "message": "Media a1b2c3d4-e5f6-7890-abcd-ef1234567890 was not found on the account that owns this API key. It was never uploaded, it was deleted (uploaded files are kept for 7 days, and until a scheduled post that uses them goes out), or it is an upload that has not finished: finish it with POST /api/v2/media/uploads/a1b2c3d4-e5f6-7890-abcd-ef1234567890/complete and send this request again once it answers \"ready\". Otherwise upload it again (from a public URL: POST /api/v2/media; from a computer, on a paid plan: POST /api/v2/media/uploads), then send this request with the new file_id.",
    "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}

{
  "error": {
    "code": "media_processing",
    "message": "Media a1b2c3d4-e5f6-7890-abcd-ef1234567890 is still being imported (42%). Poll GET /api/v2/media?file_id=a1b2c3d4-e5f6-7890-abcd-ef1234567890 until status is \"ready\", then send this request again.",
    "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "progress": 42,
    "retry_after_seconds": 30
  }
}

{
  "error": {
    "code": "MEDIA_TOO_LARGE",
    "message": "This video is 412.5 MB; Instagram accepts videos up to 300 MB. This is Instagram's own limit for Reels posted through its API (15 minutes; Stories 100 MB and 60 seconds).",
    "platform": "instagram",
    "size_bytes": 432537600,
    "limits_url": "https://status200uploads.com/docs/file-limits",
    "max_video_bytes": 314572800,
    "max_image_bytes": 8388608
  }
}

When to Send a Request Again

• - With an Idempotency-Key, a timeout or a lost connection is safe to retry: send the same request with the same key, and a post that did go out is answered again (Idempotent-Replayed: true) instead of being posted twice. 409 idempotency_in_progress: wait for the Retry-After seconds (5) and send it again. See Safe Retries. Without a key, the rules below apply.
• - Never after a 200, or a 202 with still_publishing or "processing", unless you send the same Idempotency-Key: the post is published or on its way. Check History instead, or poll GET /api/v2/posts/{status200.post_id} every 30 seconds, for up to 10 minutes, until done is true. A 202 with "queued": true publishes by itself on the next day.
• - Never after a 202 scheduled without the same Idempotency-Key: sending it again schedules the post a second time (branch on code). After a 202 schedule_unconfirmed, check the Scheduled page first. A DELETE can always be sent again: cancelling twice is safe (the second answer is 200 with already_cancelled: true), and 504 cancel_unconfirmed asks you to.
• - 409 media_processing: wait for the Retry-After seconds (30), then send the same request.
• - 429 throttle: wait for the Retry-After seconds (the same number is in error.retry_after_seconds, for tools that read only the body, such as n8n), then send the same request. daily_attempts_exceeded: stop until 00:00 UTC. monthly_limit_reached, x_limit_reached, x_link_limit_reached: do not resend before resets_at (for a link post you can remove the link).
• - 502 upstream_unavailable and 503 skool_unavailable / x_unavailable: send it again later.
• - 503 caller_check_unavailable and idempotency_unavailable: nothing was posted. Wait for the Retry-After seconds (5, also in error.retry_after_seconds), then send the same request.
• - Other 4xx answers will not succeed unchanged: fix what the message names first (a refusal is not remembered, so the fixed request can use the same Idempotency-Key; 422 idempotency_key_reused asks for a new key). After a 500, read the message and check History before sending again (with the same Idempotency-Key, a 500 platform_error after the post was handed to the network is answered again as it was: if the post is not in History, send it with a new key).

Checking a Post Without Sending It

Send "dryRun": true next to post (or inside it) to check a post without sending it. You can also send the post as validate instead of post. Every check a publish makes is run and nothing is sent. The answer is 200 with dry_run: true, an outcome (publish, queue, schedule for a post with a time, or refuse), would_publish, a reason when it would not be sent now, and warnings. The reason carries the code and status this URL would answer, for example 403 account_not_found. A check is not counted in your API key's request count. "dryRun": false publishes as usual. Any other value is refused with 400 bad_request and nothing is published. A check that gets no report in time is answered 503 dry_run_unavailable with Retry-After: send it again (nothing was sent).

Send the same request as for publishing, with post.scheduledFor set to the time the post should go out. Everything a post is checked for now is checked at once (the profile, the connection, the media, the network's options, and the plan: Skool needs Beginner or higher and X the X add-on, 403 plan_required). The post is then saved, and the answer is 202 with "code": "scheduled" and a scheduled_post_id. It works on every plan, Free included, and a scheduled post takes no 20-second wait, so a calendar of posts can be sent in a row.

The time

• - An ISO 8601 date and time with a time zone: 2026-09-30T10:00:00Z, 2026-09-30T12:00:00+02:00, 2026-09-30T10:00:00.000Z. A Unix time in seconds or milliseconds (a number) works too, and so does a date with the month as a word and a zone, as e-mail, HTTP and JavaScript's Date.toString() write it (Wed, 30 Sep 2026 10:00:00 GMT, ... +0200, ... EDT).
• - A date written with numbers only (01/10/2026 10:00 GMT) is unreadable, even with a zone: it is 10 January in one country and 1 October in another.
• - A time without a zone (2026-09-30T10:00:00, or a date alone) is refused with 400 scheduled_for_invalid, error.reason no_time_zone, even when it is in the past: we cannot tell which moment you mean. The message shows your time with a zone added.
• - More than 60 seconds ahead is scheduled; the past, "now" or within 60 seconds publishes at once, as without the field.
• - Up to 365 days ahead (too_far_ahead after that), and at most 500 posts waiting per account (409 scheduled_queue_full). A value that is not a date and time is unreadable.

curl -X POST 'https://status200uploads.com/api/v2/posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{
    "post": {
      "accountId": "@myprofile",
      "platform": "tiktok",
      "scheduledFor": "2026-10-01T09:00:00Z",
      "content": { "text": "Coming Thursday", "mediaID": ["a1b2c3d4-e5f6-7890-abcd-ef1234567890"] },
      "tiktok": { "privacyLevel": "PUBLIC_TO_EVERYONE" }
    }
  }'

# Cancel it before it goes out
curl -X DELETE 'https://status200uploads.com/api/v2/posts/c3d4e5f6-a7b8-9012-cdef-123456789012' \
  -H 'Authorization: Bearer rl_your_api_key'

Cancelling

DELETE https://status200uploads.com/api/v2/posts/{scheduled_post_id} cancels a post that has not gone out, whether the API, the dashboard or a connected AI app scheduled it, or the daily allowance queued it (the 202 of a queued post has a scheduled_post_id too). The same key, no body. The older URL takes DELETE https://app.status200uploads.com/functions/v1/api-posts/{id}. A DELETE is counted in the key's request count like any request.

• - 200: {"data": {"scheduled_post_id", "status": "cancelled", "platforms", "was_due_at", "message"}}. Sent again, the answer is 200 with "already_cancelled": true: cancelling twice is safe.
• - 404 post_not_found: no scheduled post with that id on your account. 400 bad_request: the id is not a UUID.
• - 409 not_cancellable, with error.status: it is being published right now (processing), it was published, or it failed when it was due. A post that is on its way cannot be stopped, and Status 200 Uploads cannot remove a post from a network. If a post that was being published is moved to a later time instead (a used-up daily allowance moves it to the next day), send the same DELETE again.
• - 504 cancel_unconfirmed (with Retry-After): send the same DELETE again.

What is checked when it goes out

• - Your plan's allowance, when the post goes out, not when it is scheduled. Over a daily allowance (Beginner, Apprentice) the post moves to the same time on the next day. On Free, a post over the 30 posts of the month fails: this shows on the Scheduled page and in the failure email, not in History.
• - X: the X add-on's allowance at that time. Skool: one post per hour per account, across all its profiles (a warning skool_one_post_per_hour says when two scheduled Skool posts of your account are closer), and its daily cap.
• - The network itself, with the options you sent: they are kept with the post and sent as a post published at once would send them.

Media

A file imported with POST /api/v2/media (or uploaded through an upload link) and sent as mediaID is kept until the post goes out, however far ahead it is. mediaUrls are fetched when the post goes out, not now, and no copy is kept: the file must still be at that address then (the answer warns with media_url_not_kept, and an address that already answers "not found" is refused with 400 media_not_available). For anything more than a few hours ahead, import the file and send its mediaID. A Reel's instagram.coverUrl is fetched when the Reel goes out too: the same warning, the same 400 for a cover that is already gone, and a cover that is gone by then leaves the Reel without its cover.

Timing and where to see it

• - A scheduled post is published at its time, usually within a few minutes of it. Posts due at the same moment go out one after another with no gap between them, so a large batch takes longer, and a network can refuse posts that arrive that close together: leave at least a minute between posts on one network (the warning posts_close_together says when two are within 20 seconds).
• - It is listed on the Scheduled page and the calendar of the dashboard, which can also cancel it, and in History once it has gone out. Through the API, GET /api/v2/posts/{scheduled_post_id} (the 202's status200.status_url) reads it before it goes out and, afterwards, each network's result; GET /api/v2/posts?status=scheduled lists the posts still waiting.
• - Revoking an API key does not cancel the posts it scheduled.
• - There is no endpoint to change a scheduled post yet: cancel it and schedule it again.
• - A request with a time sent twice schedules the post twice: never send it again after a 202 scheduled unless it carries the same Idempotency-Key (then the first answer comes back and nothing is scheduled again), and check the Scheduled page after a 202 schedule_unconfirmed.
• - A dry run with a time answers the outcome schedule and schedules nothing.

Full URL: GET https://status200uploads.com/api/v2/accounts. Use a profile_id (or the handle) as post.accountId when you post, instead of guessing a name. No parameters.

• - The same API key as for posting, in Authorization: Bearer rl_your_api_key. You only ever see your own account: another account's id reads exactly like an id that does not exist.
• - On https://status200uploads.com/api/v2 only. The older URL answers a GET with 405.
• - 60 reads a minute per account, all your API keys together (posting options also 10 a minute, see Rate Limits). Over the limit: 429 rate_limited with a Retry-After header and error.retry_after_seconds. Reads are not counted in your API key's request count, so a key used only for reads shows 0 requests on the API page: it is still in use.
• - Answers carry Cache-Control: private, no-store: do not cache them between API keys.

curl 'https://status200uploads.com/api/v2/accounts' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "data": [
    {
      "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
      "profile_name": "myshop",
      "handle": "@myshop",
      "created_at": "2026-03-01T10:00:00+00:00",
      "networks": [
        {
          "platform": "pinterest",
          "username": "myshop",
          "status": "connected",
          "health": "ready",
          "access_expires_at": "2026-11-20T08:12:00+00:00",
          "connected_at": "2026-03-02T09:30:00+00:00",
          "updated_at": "2026-09-20T08:12:00+00:00"
        }
      ]
    }
  ]
}

Full URL: GET https://status200uploads.com/api/v2/accounts/{profile_id}/options. Ask before you post, so the post is built from what the account allows: the only TikTok privacy levels it will accept in post.tiktok.privacyLevel, the board ids for post.pinterest.boardId, the group ids for post.skool.group. Each network that is asked is a real call with your own sign-in, so answers are reused for about a minute and a half, and the answer changes slowly: reuse it.

• - The same API key as for posting, in Authorization: Bearer rl_your_api_key. You only ever see your own account: another account's id reads exactly like an id that does not exist.
• - On https://status200uploads.com/api/v2 only. The older URL answers a GET with 405.
• - 60 reads a minute per account, all your API keys together (posting options also 10 a minute, see Rate Limits). Over the limit: 429 rate_limited with a Retry-After header and error.retry_after_seconds. Reads are not counted in your API key's request count, so a key used only for reads shows 0 requests on the API page: it is still in use.
• - Answers carry Cache-Control: private, no-store: do not cache them between API keys.

curl 'https://status200uploads.com/api/v2/accounts/d4e5f6a7-b8c9-0123-def0-234567890123/options?platforms=tiktok,pinterest' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "data": {
    "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
    "profile_name": "myshop",
    "networks": [
      {
        "platform": "tiktok",
        "status": "ok",
        "options": {
          "privacy_level_options": ["PUBLIC_TO_EVERYONE", "SELF_ONLY"],
          "comment_disabled": false, "duet_disabled": true, "stitch_disabled": false,
          "max_video_post_duration_sec": 600,
          "creator_username": "myshop", "creator_nickname": "My Shop"
        },
        "note": "privacy_level_options are the only values TikTok will accept in post.tiktok.privacyLevel for this account. ...",
        "checked_at": "2026-09-27T12:00:00.000Z", "cached": false, "error_code": null
      },
      {
        "platform": "pinterest",
        "status": "ok",
        "options": { "boards": [{ "id": "900123", "name": "Recipes", "privacy": "PUBLIC", "pin_count": 12 }] },
        "note": "Send one of these ids as post.pinterest.boardId when you post to Pinterest.",
        "checked_at": "2026-09-27T12:00:00.000Z", "cached": false, "error_code": null
      }
    ],
    "note": null,
    "asked_at": "2026-09-27T12:00:00.000Z"
  }
}

Full URL: GET https://status200uploads.com/api/v2/posts. Every item is either a post (kind "post": one network, its status, its link) or a scheduled post that has not produced a post yet (kind "scheduled_post": waiting, cancelled, or failed before anything was sent). Once a scheduled post has gone out, each network's post is listed instead, with its scheduled_post_id, so nothing is listed twice. Items are ordered by at: when a post was sent, when a scheduled post is due (so posts due in the future come first).

• - The same API key as for posting, in Authorization: Bearer rl_your_api_key. You only ever see your own account: another account's id reads exactly like an id that does not exist.
• - On https://status200uploads.com/api/v2 only. The older URL answers a GET with 405.
• - 60 reads a minute per account, all your API keys together (posting options also 10 a minute, see Rate Limits). Over the limit: 429 rate_limited with a Retry-After header and error.retry_after_seconds. Reads are not counted in your API key's request count, so a key used only for reads shows 0 requests on the API page: it is still in use.
• - Answers carry Cache-Control: private, no-store: do not cache them between API keys.

curl 'https://status200uploads.com/api/v2/posts?limit=50&status=failed' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "data": [
    {
      "id": "c3d4e5f6-a7b8-9012-cdef-123456789012",
      "kind": "scheduled_post",
      "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
      "platforms": ["tiktok", "x"],
      "status": "scheduled",
      "outcome": "waiting",
      "done": false,
      "media_type": "video",
      "at": "2026-10-01T09:00:00+00:00",
      "scheduled_for": "2026-10-01T09:00:00+00:00",
      "created_at": "2026-09-27T12:00:00+00:00",
      "updated_at": "2026-09-27T12:00:00+00:00",
      "note": null,
      "error_message": null
    },
    {
      "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
      "kind": "post",
      "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
      "platform": "pinterest",
      "status": "success",
      "done": true,
      "media_type": "image",
      "publish_id": "1146236468384210033",
      "permalink": "https://www.pinterest.com/pin/1146236468384210033/",
      "error_message": null,
      "at": "2026-09-27T11:58:02.183412+00:00",
      "updated_at": "2026-09-27T11:58:04.912+00:00",
      "scheduled_post_id": null,
      "notices": []
    }
  ],
  "next_cursor": "eyJ0IjoiMjAyNi0wOS0yN1QxMTo1ODowMi4xODM0MTJaIiwiaWQiOiJiMmMzZDRlNS1mNmE3LTg5MDEtYmNkZS1mMTIzNDU2Nzg5MDEifQ",
  "next_url": "https://status200uploads.com/api/v2/posts?limit=2&cursor=eyJ0IjoiMjAyNi0wOS0yN1QxMTo1ODowMi4xODM0MTJaIiwiaWQiOiJiMmMzZDRlNS1mNmE3LTg5MDEtYmNkZS1mMTIzNDU2Nzg5MDEifQ"
}

Full URL: GET https://status200uploads.com/api/v2/posts/{id}. The id is a post id or a scheduled post id: the status200.post_id or status200.scheduled_post_id of a POST answer (its status200.status_url is this URL, ready to call), or an id from GET /api/v2/posts. To wait until a post is published, call it every 30 seconds until done is true, for up to 10 minutes: most posts are done within a minute or two. Stop after that either way. A post still processing (a large video) finishes by itself and shows in History; a timeout was sent and never confirmed, and can stay so for up to 2 days while we check: look on the network, and never send it again.

• - The same API key as for posting, in Authorization: Bearer rl_your_api_key. You only ever see your own account: another account's id reads exactly like an id that does not exist.
• - On https://status200uploads.com/api/v2 only. The older URL answers a GET with 405.
• - 60 reads a minute per account, all your API keys together (posting options also 10 a minute, see Rate Limits). Over the limit: 429 rate_limited with a Retry-After header and error.retry_after_seconds. Reads are not counted in your API key's request count, so a key used only for reads shows 0 requests on the API page: it is still in use.
• - Answers carry Cache-Control: private, no-store: do not cache them between API keys.

curl 'https://status200uploads.com/api/v2/posts/b2c3d4e5-f6a7-8901-bcde-f12345678901' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "data": {
    "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "kind": "post",
    "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
    "platform": "tiktok",
    "status": "success",
    "done": true,
    "media_type": "video",
    "publish_id": "v_pub_7123456789",
    "permalink": "https://www.tiktok.com/@myshop/video/7123456789",
    "error_message": null,
    "at": "2026-09-27T11:58:02+00:00",
    "updated_at": "2026-09-27T11:59:40+00:00",
    "scheduled_post_id": null,
    "notices": [],
    "figures": {
      "metrics": { "views": 1200, "likes": 34, "comments": 5, "shares": 2, "impressions": null, "reach": null, "saves": null, "clicks": null, "watch_time_seconds": null },
      "not_reported": ["impressions", "reach", "saves", "clicks", "watch_time_seconds"],
      "engagement": 41,
      "polled_at": "2026-09-27T18:00:03+00:00",
      "note": null
    }
  }
}

{
  "data": {
    "id": "c3d4e5f6-a7b8-9012-cdef-123456789012",
    "kind": "scheduled_post",
    "profile_id": "d4e5f6a7-b8c9-0123-def0-234567890123",
    "platforms": ["pinterest", "tiktok"],
    "status": "published",
    "outcome": "success",
    "done": true,
    "media_type": "image",
    "at": "2026-10-01T09:00:00+00:00",
    "scheduled_for": "2026-10-01T09:00:00+00:00",
    "created_at": "2026-09-27T12:00:00+00:00",
    "updated_at": "2026-10-01T09:01:12+00:00",
    "note": null,
    "error_message": null,
    "results": [
      {
        "platform": "pinterest",
        "post_id": "e5f6a7b8-c9d0-1234-ef01-345678901234",
        "status": "success",
        "done": true,
        "publish_id": "1146236468384210034",
        "permalink": "https://www.pinterest.com/pin/1146236468384210034/",
        "error_message": null,
        "notices": []
      },
      {
        "platform": "tiktok",
        "post_id": "f6a7b8c9-d0e1-2345-f012-456789012345",
        "status": "success",
        "done": true,
        "publish_id": "7123456790",
        "permalink": "https://www.tiktok.com/@/video/7123456790",
        "error_message": null,
        "notices": [
          {
            "code": "resized_for_tiktok",
            "message": "Photo too large for TikTok: it is 2160 × 2700 pixels and TikTok takes up to 1080 × 1920, so we sent a smaller copy (1080 × 1350). Your original file is unchanged.",
            "photo": 1,
            "photos": 1,
            "size": { "width": 2160, "height": 2700 },
            "copy_size": { "width": 1080, "height": 1350 }
          }
        ]
      }
    ]
  }
}

Import: POST https://status200uploads.com/api/v2/media. Status of an import: GET https://status200uploads.com/api/v2/media?file_id=<file_id>. The older URL https://app.status200uploads.com/functions/v1/api-media-upload accepts the same two requests and keeps working. A file on a computer rather than at a URL (paid plans): see Upload from a computer, below. Never put a file on a public site only to import it from there.

A larger file is refused with 413. These are the import limits: the networks accept less, see platform file limits. Imported files are kept for 7 days, and a file used by a scheduled post is kept until that post goes out, however far ahead it is. A post scheduled with mediaUrls instead fetches them when it goes out, so for anything more than a few hours ahead import the file and send its file_id. One file_id can be used in any number of posts during that time.

curl -X POST 'https://status200uploads.com/api/v2/media' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{"url": "https://example.com/video.mp4"}'

{
  "success": true,
  "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "size": 2048576,
  "type": "image/jpeg",
  "status": "ready"
}

{
  "success": true,
  "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "processing",
  "message": "Upload started. Large files continue in the background: poll GET /api/v2/media?file_id=... until status is \"ready\" (the response includes progress), then use the file_id in create post.",
  "size": 3221225472,
  "type": "video/mp4"
}

Checking an Import

After a 202, ask for the status until it is "ready". Every 10 to 30 seconds is enough. Status requests are not throttled. The same request follows a file sent through an upload link (see Upload from a computer). If you create a post while the import is still running, the post endpoint answers 409 media_processing and nothing is published. A file_id that is not a UUID is answered 400, and one that is not on your account 404.

curl 'https://status200uploads.com/api/v2/media?file_id=a1b2c3d4-e5f6-7890-abcd-ef1234567890' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "success": false,
  "file_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "processing",
  "size": 3221225472,
  "type": "video/mp4",
  "public_url": "https://app.status200uploads.com/storage/v1/object/public/media-files/<user-id>/a1b2c3d4-e5f6-7890-abcd-ef1234567890.mp4",
  "error": null,
  "bytes_uploaded": 1358954496,
  "progress": 42
}

Full URLs: POST https://status200uploads.com/api/v2/media/uploads makes a link, POST https://status200uploads.com/api/v2/media/uploads/{file_id}/token gives it a fresh token, POST https://status200uploads.com/api/v2/media/uploads/{file_id}/complete checks the file and puts it in your media library, and DELETE https://status200uploads.com/api/v2/media/uploads/{file_id} cancels an unfinished upload. GET https://status200uploads.com/api/v2/media?file_id=<file_id> says how far it is. On this URL only, with the same API key.

For a file that is on a computer, not at a URL: your own script, or an AI app that runs commands on your computer (tested with Claude Code; other AI apps that can run commands may work). The file goes from that computer straight to storage, never through a public site, and it is in a private place, readable by no one, until it has been checked. A connected AI app does all of this itself with status200_create_upload_link and status200_finish_upload (see Connect an AI app).

How it works

1. 1. Measure the file: its exact size in bytes and its SHA-256. Windows PowerShell: (Get-Item -LiteralPath 'C:\Videos\EP01.mp4').Length and (Get-FileHash -Algorithm SHA256 -LiteralPath 'C:\Videos\EP01.mp4').Hash. macOS: stat -f %z EP01.mp4 and shasum -a 256 < EP01.mp4. Linux, WSL or Git Bash: stat -c %s EP01.mp4 and sha256sum < EP01.mp4. Hashing a large video takes a while.
2. 2. POST /api/v2/media/uploads with file_name, size_bytes and sha256 (and shell for a ready-made command). The answer is 201 with a file_id, the upload address upload.url and its token upload.token.
3. 3. Send the file: run uploader.command (no code to write), or use any TUS 1.0.0 client.
4. 4. POST /api/v2/media/uploads/{file_id}/complete: the file that arrived is checked (exact size, type, first bytes, SHA-256). 200 "ready": it is in your media library. 202 "verifying": ask GET /api/v2/media?file_id= every 15 seconds until it is ready (a 5 GB file can take about 15 minutes), and never upload it again: it finishes on its own.
5. 5. Post it: "mediaID": ["<file_id>"] in POST /api/v2/posts, like an imported file.

curl -X POST 'https://status200uploads.com/api/v2/media/uploads' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_your_api_key' \
  -d '{"file_name": "EP01.mp4", "size_bytes": 295698432, "sha256": "9f2c4b6a8e0d1c3b5a7f9e1d3c5b7a9f0e2d4c6b8a0f1e3d5c7b9a1f3e5d7c9b"}'

{
  "success": true,
  "file_id": "6b1d2f0e-3c4a-4b5d-8e6f-7a8b9c0d1e2f",
  "status": "uploading",
  "file_name": "EP01.mp4",
  "size": 295698432,
  "type": "video/mp4",
  "sha256": "9f2c4b6a8e0d1c3b5a7f9e1d3c5b7a9f0e2d4c6b8a0f1e3d5c7b9a1f3e5d7c9b",
  "renewed": false,
  "upload": {
    "protocol": "tus-1.0.0",
    "url": "https://yglvofckrdutesfzxwyb.storage.supabase.co/storage/v1/upload/resumable/sign/bWVkaWEtdXBsb2Fkcy84ZjE0ZTQ1Zi1jZWVhLTQ2N2EtOWEzNi0xZDViMGUzYTdjMjEvMGU5ZDhjN2ItNmE1Zi00ZTNkLTljMmItMWEwZjllOGQ3YzZiLm1wNC80ZjNlMmQxYy0wYjlhLTQ4NzYtOTU0My0yMTBmZWRjYmE5ODc",
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJvd25lciI6IjhmMTRlNDVmLWNlZWEtNDY3YS05YTM2LTFkNWIwZTNhN2MyMSIsInVybCI6Im1lZGlhLXVwbG9hZHMvOGYxNGU0NWYtY2VlYS00NjdhLTlhMzYtMWQ1YjBlM2E3YzIxLzBlOWQ4YzdiLTZhNWYtNGUzZC05YzJiLTFhMGY5ZThkN2M2Yi5tcDQiLCJ1cHNlcnQiOmZhbHNlLCJpYXQiOjE3OTEyODgwMDAsImV4cCI6MTc5MTI5NTIwMH0.Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-",
    "chunk_size": 6291456,
    "token_expires_at": "2026-10-06T14:00:00.000Z",
    "upload_expires_at": "2026-10-07T12:00:00.000Z",
    "resume_before": "2026-10-06T16:00:00.000Z"
  },
  "next_step": "Send the file to upload.url with a TUS 1.0.0 client (header x-signature: upload.token; 6291456-byte chunks from the offset a HEAD returns). Then POST /api/v2/media/uploads/6b1d2f0e-3c4a-4b5d-8e6f-7a8b9c0d1e2f/complete. A stopped upload can be continued (after a fresh token, once this one expired) until upload.resume_before (2026-10-06T16:00:00.000Z); after that, what was sent is deleted."
}

Our uploader: no code to write

Send shell (powershell or sh) and the answer adds an uploader block: shell, runner, version, download_url, sha256, max_run_seconds and command. The command downloads our uploader into a fresh folder, refuses to run it unless its SHA-256 is the published one, sends the file and removes the folder. Run it as it is in that shell (never inside another shell), with <PATH> in its S200_FILE line replaced by the file's full path, and with a command timeout of at least max_run_seconds + 60 seconds. It needs to reach status200uploads.com and yglvofckrdutesfzxwyb.storage.supabase.co. For "shell": "sh", "max_run_seconds": 540 it looks like this:

mktemp -d | { IFS= read -r d || exit 1
u="$d/s200-upload.sh"
curl -fsSL --proto '=https' --connect-timeout 15 --max-time 45 -o "$u" 'https://status200uploads.com/uploader/v1/s200-upload.sh' || { echo 'Could not download the uploader from status200uploads.com.'; rm -rf "$d"; exit 1; }
{ sha256sum < "$u" 2>/dev/null || shasum -a 256 < "$u"; } | cut -c1-64 | grep -qx 'e9eec70d103b51129a9a072e5ccf838e9ef68b70008d18b07bfc58740359ddbc' || { echo 'The uploader did not download correctly. Do not run it.'; rm -rf "$d"; exit 1; }
S200_UPLOAD_URL='https://yglvofckrdutesfzxwyb.storage.supabase.co/storage/v1/upload/resumable/sign/bWVkaWEtdXBsb2Fkcy84ZjE0ZTQ1Zi1jZWVhLTQ2N2EtOWEzNi0xZDViMGUzYTdjMjEvMGU5ZDhjN2ItNmE1Zi00ZTNkLTljMmItMWEwZjllOGQ3YzZiLm1wNC80ZjNlMmQxYy0wYjlhLTQ4NzYtOTU0My0yMTBmZWRjYmE5ODc' \
S200_UPLOAD_TOKEN='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJvd25lciI6IjhmMTRlNDVmLWNlZWEtNDY3YS05YTM2LTFkNWIwZTNhN2MyMSIsInVybCI6Im1lZGlhLXVwbG9hZHMvOGYxNGU0NWYtY2VlYS00NjdhLTlhMzYtMWQ1YjBlM2E3YzIxLzBlOWQ4YzdiLTZhNWYtNGUzZC05YzJiLTFhMGY5ZThkN2M2Yi5tcDQiLCJ1cHNlcnQiOmZhbHNlLCJpYXQiOjE3OTEyODgwMDAsImV4cCI6MTc5MTI5NTIwMH0.Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-Qx9_-' \
S200_CHECK='be11386c' \
S200_MAX_SECONDS='540' \
S200_FILE='<PATH>' \
sh "$u" </dev/null; c=$?; rm -rf "$d"; exit $c; }

Inside the single quotes of the S200_FILE line, write each ' of the path as '\'' in sh, and twice in PowerShell (there the typographic quotes ‘ ’ ‚ ‛ too). A run prints progress N% (X.X of Y.Y MiB) every 15 seconds and ends with one JSON line with its state. Its exit code says what to do:

Your own TUS client

Without shell, send the file to upload.url with any TUS 1.0.0 client (the Python tab above is one). HEAD the address for its Upload-Offset, then PATCH pieces of exactly chunk_size bytes (6,291,456, 6 MiB; the last one shorter) from that offset, each with the headers x-signature: <upload.token>, Tus-Resumable: 1.0.0, Upload-Offset and Content-Type: application/offset+octet-stream. After a failed PATCH, HEAD again and go on from the offset it gives. The token goes in that header only, never in a URL. The upload was created by us with the file's exact length and type, so a client never creates one.

{
  "success": true,
  "file_id": "6b1d2f0e-3c4a-4b5d-8e6f-7a8b9c0d1e2f",
  "status": "ready",
  "file_name": "EP01.mp4",
  "size": 295698432,
  "type": "video/mp4",
  "sha256": "9f2c4b6a8e0d1c3b5a7f9e1d3c5b7a9f0e2d4c6b8a0f1e3d5c7b9a1f3e5d7c9b",
  "message": "EP01.mp4 arrived complete (295,698,432 bytes, SHA-256 matches). Publish it with this file_id."
}

{
  "success": true,
  "file_id": "6b1d2f0e-3c4a-4b5d-8e6f-7a8b9c0d1e2f",
  "status": "verifying",
  "file_name": "EP01.mp4",
  "size": 295698432,
  "type": "video/mp4",
  "sha256": "9f2c4b6a8e0d1c3b5a7f9e1d3c5b7a9f0e2d4c6b8a0f1e3d5c7b9a1f3e5d7c9b",
  "message": "The file arrived and is being checked (size, type and SHA-256). Poll GET /api/v2/media?file_id=6b1d2f0e-3c4a-4b5d-8e6f-7a8b9c0d1e2f every 15 seconds until it is \"ready\". A 5 GB file can take about 15 minutes. It finishes on its own: do not upload it again.",
  "retry_after_seconds": 15
}

Status, fresh tokens, cancelling

• - GET /api/v2/media?file_id= answers for an upload too: "uploading" (not all of the file has arrived), "verifying" (it arrived and is being checked), "ready" (with its public_url, like any library file) or "failed" (with the reason in error). Before it is ready there is no public_url.
• - POST /api/v2/media/uploads/{file_id}/token gives the same address a fresh token when the old one expired before the whole file was sent (the uploader's exit 4): send shell (and runner, max_run_seconds) for a new command, or no body. Only the API key that made the link, at most 12 times and within 24 hours of the link.
• - A stopped upload can be continued until upload.resume_before: 2 hours after its newest token expired, at most 24 hours after the link was made. After that the upload is closed and what was sent is deleted; make a new link.
• - DELETE /api/v2/media/uploads/{file_id} cancels an upload that is not ready (200 "cancelled"): what arrived is deleted within a few minutes. Bytes that arrived still count in the day's budget. A ready upload is a media library file: delete it there.
• - Per account: 10 uploads open at once (a link that is never used closes on its own about 4 hours after it was made), 20 new links in 10 minutes and 100 a day, and 60 upload-link calls a minute (new links, tokens, complete and cancel together). A link holds its size of the day's budget until it closes; bytes that arrived still count when the check refuses them.
• - Every answer comes within about 22 seconds and carries Cache-Control: private, no-store. Refusals have the shape {"error": {"code", "message", "next_step", "retry", ...}}: next_step says what to do next, and retry (when there is one) is "never" (the same request cannot succeed now) or "after_reset" (after 00:00 UTC); a wait is in Retry-After and error.retry_after_seconds. A client that follows the OpenAPI file's x-status200-retry table reads its by_operation first: a paused check (503 upload_links_paused on complete, which keeps the file) is waited out and asked again.

{
  "error": {
    "code": "plan_limit_reached",
    "message": "Uploading a file from a computer needs a paid plan (Beginner or higher), and this account is on the Free plan.",
    "next_step": "Upload the file and make the post at status200uploads.com → Media, which every plan can use, or upgrade: https://status200uploads.com/pricing.",
    "retry": "never",
    "plan": "free",
    "upgrade_url": "https://status200uploads.com/pricing"
  }
}

{
  "error": {
    "code": "import_budget_exhausted",
    "message": "EP01.mp4 is 1.1 GB, and only 819.2 MB of today's 2 GB budget for files your apps upload or import is left on the Beginner plan. It resets at 00:00 UTC (in 12 h). 282 MB of it is reserved by upload links of this account whose file has not fully arrived; if they are not continued, that is free again by 13:51 UTC.",
    "next_step": "To post it now, upload it at status200uploads.com → Media (no daily budget there), or upgrade for a larger budget. Otherwise wait for 00:00 UTC.",
    "retry": "after_reset",
    "retry_after_seconds": 43200,
    "used_bytes": 1288490188,
    "held_bytes": 295698432,
    "held_until": "2026-10-06T13:51:00.000Z",
    "limit_bytes": 2147483648,
    "remaining_bytes": 858993460,
    "requested_bytes": 1182793728,
    "window": "day",
    "resets_at": "2026-10-07T00:00:00.000Z",
    "plan": "beginner",
    "upgrade_url": "https://status200uploads.com/pricing"
  }
}

The uploader's published versions

The uploader is code that runs on your computer, so every version is published at a fixed address under https://status200uploads.com/uploader/vN/ (served as text/plain), never changes once published (a new uploader is a new version), and is checked by its SHA-256 before it runs: the command carries the hash and refuses any other download. Anyone can check a copy against this list, for example curl -fsSL https://status200uploads.com/uploader/v1/s200-upload.sh | sha256sum (macOS: shasum -a 256), or in PowerShell (Get-FileHash -Algorithm SHA256 -LiteralPath .\s200-upload.ps1).Hash (it prints upper case). New links use v1.

What is kept and logged

• - A ready file is a media library file like any other: kept 7 days (and until a scheduled post that uses it goes out), and, like every library file, public at its exact address while it is kept, even when the post itself is private. Until it is ready it is in a private place, and a refused file is deleted.
• - Your API request log (Dashboard → API) has one row per answer with a summary: the ids, the status, the type and size, the uploader's shell, runner and version, and the times. Never the token, the upload address or the command.
• - The token works only for this one file, only to upload it, and for about 2 hours. Where it goes is up to you: an AI app's chat, a command line and the process list of your computer can show it.

Full URL: GET https://status200uploads.com/api/v2/media/files. Use it to find a file you uploaded in the dashboard (Media) and post it by its file_id in content.mediaID, instead of putting it anywhere public to import it. Every plan, Free included. Each file says whether it can be posted now (usable) and when it may be removed (expires_at: 7 days after upload, or later while a waiting scheduled post uses it). No file's address is ever answered here: GET /api/v2/media?file_id= gives one file's public_url.

• - The same API key as for posting, in Authorization: Bearer rl_your_api_key. You only ever see your own account: another account's id reads exactly like an id that does not exist.
• - On https://status200uploads.com/api/v2 only. The older URL answers a GET with 405.
• - 60 reads a minute per account, all your API keys together (posting options also 10 a minute, see Rate Limits). Over the limit: 429 rate_limited with a Retry-After header and error.retry_after_seconds. Reads are not counted in your API key's request count, so a key used only for reads shows 0 requests on the API page: it is still in use.
• - Answers carry Cache-Control: private, no-store: do not cache them between API keys.

curl 'https://status200uploads.com/api/v2/media/files?name_contains=beach&type=video' \
  -H 'Authorization: Bearer rl_your_api_key'

{
  "data": [
    {
      "file_id": "6b1d2f0e-1111-4222-8333-444444444444",
      "file_name": "Beach day.mp4",
      "type": "video/mp4",
      "kind": "video",
      "size": 48213377,
      "status": "ready",
      "usable": true,
      "source": "dashboard",
      "uploaded_at": "2026-10-07T12:08:20.740Z",
      "expires_at": "2026-10-14T12:08:20.740Z",
      "confirm_before_posting": false,
      "error": null
    }
  ],
  "next_cursor": null,
  "next_url": null,
  "now": "2026-10-07T12:31:02.118Z"
}

Your First API Call

This guide walks you through making your first successful API call to publish a post.

curl -X POST 'https://status200uploads.com/api/v2/media' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_YOUR_KEY' \
  -d '{"url": "https://example.com/video.mp4"}'

curl -X POST 'https://status200uploads.com/api/v2/posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer rl_YOUR_KEY' \
  -d '{
    "post": {
      "accountId": "@myprofile",
      "platform": "tiktok",
      "content": {
        "text": "Hello world! #firstpost",
        "mediaID": ["YOUR_FILE_ID"]
      },
      "tiktok": { "privacyLevel": "PUBLIC_TO_EVERYONE" }
    }
  }'

Posting to Several Networks

Publish the same content to several networks: import the media once, then send one request per network. Each request publishes to one network from one profile.

• - The file has to fit every network you send it to. A network whose limit is lower answers 413 MEDIA_TOO_LARGE and the other posts are not affected. See platform file limits.
• - Requests are throttled per network: two posts to the same network need 20 seconds between them, even from different profiles (429 otherwise, with a Retry-After header). One post to each of several networks can be sent back to back. Skool accepts one post per hour and 10 per day.
• - The post allowance counts successful posts, all networks combined. Once a daily allowance (Beginner, Apprentice: per profile per day) is used up, requests are answered 202 queued_for_next_day and publish on the next day; on Free, 429 monthly_limit_reached after 30 posts in a month.
• - A post that uses a file_id whose import is still running is answered with 409 media_processing after about 12 seconds. Wait for the import, then send the post again. A file_id that no longer exists (files are kept for 7 days, and a file a scheduled post uses until that post goes out) is answered with 404 media_not_found: import the file again.
• - A 202 with still_publishing means the network is slower than the request can wait. The post is on its way: do not send it again (with the same Idempotency-Key you only get this answer back).
• - Make one Idempotency-Key per post, once, outside the retry loop, and send it with every try: a timeout, a lost connection, a gateway's 5xx (no error.code of ours), a 409 idempotency_in_progress and the 503s that say nothing was sent can then be retried without posting twice (see Safe Retries). After any other 5xx, read the message and check History before sending it again.

import time
import uuid
import requests

API = "https://status200uploads.com/api/v2"
HEADERS = {
    "Content-Type": "application/json",
    "Authorization": "Bearer rl_your_api_key"
}

# One entry per network, with the options of that network
targets = [
    {"platform": "tiktok", "tiktok": {"privacyLevel": "PUBLIC_TO_EVERYONE"}},
    {"platform": "youtube", "youtube": {"privacyStatus": "public"}},
    {"platform": "facebook", "facebook": {"postType": "video"}},
    {"platform": "linkedin"},
]

# 1. Import the video once and wait until it is ready
media = requests.post(
    f"{API}/media",
    headers=HEADERS,
    json={"url": "https://example.com/content.mp4"}
).json()
file_id = media["file_id"]

while media["status"] == "processing":
    time.sleep(15)
    media = requests.get(
        f"{API}/media", headers=HEADERS, params={"file_id": file_id}
    ).json()

if media["status"] != "ready":
    raise SystemExit(media.get("error") or "Import failed")

# 2. One request per network
def publish(target):
    body = {
        "post": {
            "accountId": "@myprofile",
            "content": {
                "text": "Check out our latest content!",
                "mediaID": [file_id]
            },
            **target
        }
    }
    # One Idempotency-Key per post, made once: every try below sends the same key, so a post
    # that went out is answered again (Idempotent-Replayed: true), never posted twice.
    headers = {**HEADERS, "Idempotency-Key": str(uuid.uuid4())}
    status, data = 0, {"error": {"message": "no answer"}}
    for _ in range(5):
        try:
            # Every answer comes within about 25 seconds
            resp = requests.post(f"{API}/posts", headers=headers, json=body, timeout=60)
        except (requests.Timeout, requests.ConnectionError):
            time.sleep(5)
            continue  # safe with the same key
        status = resp.status_code
        try:
            data = resp.json()
        except ValueError:
            data = {}  # a gateway's page, not ours
        error = data.get("error") if isinstance(data.get("error"), dict) else {}
        code = error.get("code")
        wait = int(resp.headers.get("Retry-After", "5"))
        if status == 409 and code in ("media_processing", "idempotency_in_progress"):
            time.sleep(wait)  # import still running, or the first try still working: nothing new was sent
        elif status == 429 and code == "rate_limited":
            time.sleep(wait)  # throttled: wait, then send again (other 429s: stop)
        elif code in ("idempotency_unavailable", "caller_check_unavailable", "upstream_unavailable") or (status >= 500 and not code):
            time.sleep(wait)  # nothing was sent, or a gateway's page: safe with the same key
        else:
            break  # any other answer, another 5xx included: read it and check History first
    return status, data

for target in targets:
    status, data = publish(target)
    if status == 202 and data.get("code") == "scheduled":
        print(target["platform"], "scheduled for", data["scheduled_at"])  # never resend without its key
    elif status == 202 and data.get("queued"):
        print(target["platform"], "queued for", data["scheduled_at"])
    elif status == 202 and data.get("code") == "still_publishing":
        print(target["platform"], "still publishing: see History")  # never resend without its key
    elif status in (200, 202):
        print(target["platform"], "accepted")
    else:
        print(target["platform"], "failed:", status, data.get("error"))

Handling Media Uploads

Best practices for uploading images and videos through the API.

Using Python

The Status 200 Uploads package for Python, status200uploads, is on PyPI. Install it with pip install status200uploads. It needs Python 3.11 or newer. By default it sends an Idempotency-Key with every post. It sends a request again only when the API's retry table allows it, and it can wait until a post is done. Its README, on PyPI and with the source on GitHub, shows how to use it.

• - Put your API key in the STATUS200_API_KEY environment variable, or pass it as Status200(api_key=...). The package never prints it.
• - publish() returns a Result for a 200 and for every 202. A 202 is never a failure: the post is on its way, scheduled or queued, so do not send it again. result.code names the case, for example scheduled, queued_for_next_day or still_publishing (None on a 200, and on a 202 while the network is still processing the post).
• - A refusal raises Status200Error with the API's code and message: show the message. OutcomeUnknown means no clear answer came back and the post may have gone out: look at s200.list_posts() or History before you send it again.
• - s200.import_media(url) imports a file and waits until it is ready: send its file_id in the content.mediaID list, for example "mediaID": [media["file_id"]].s200.publish(post, scheduled_for=...) schedules a post, and s200.cancel(result.status200.scheduled_post_id) stops it before it goes out.

from status200uploads import OutcomeUnknown, Status200, Status200Error

s200 = Status200()  # the key comes from STATUS200_API_KEY

try:
    # 1. Your profiles, and the networks connected to each
    for account in s200.list_accounts():
        print(account["handle"], [network["platform"] for network in account["networks"]])

    # 2. Publish, then read the post every 30 seconds until the network is done (10 minutes at most)
    post = {"accountId": "@myprofile", "platform": "linkedin", "content": {"text": "Hello from Python"}}
    result = s200.publish(post, wait=True)
    if result.final:  # the post as last read: its status and link
        print(result.final.get("status"), result.final.get("permalink"))
    else:  # scheduled or queued (result.code says which), or it could not be read back
        print(result.code)
except OutcomeUnknown as error:
    print(error.message)  # no clear answer: it may have gone out, check s200.list_posts() first
except Status200Error as error:
    print(error.code, error.message)  # refused, or a wrong key (unauthorized): the message says why

Without the package

Any HTTP library works too. The whole API is described in OpenAPI 3.1 at https://status200uploads.com/openapi.yaml, so a client can also be generated from it. The example below uses requests.

• - Make one Idempotency-Key per post, once, before any retry, and send it on every try: a timeout, a lost connection or a gateway's page can then be sent again without posting twice (see Safe Retries).
• - Send again, after its wait, only what the OpenAPI file's x-status200-retry table answers wait_and_resend, and a timeout or an answer that is not JSON once (resend_once_with_key). A 202 is never a failure (the post is on its way, scheduled or queued), and a refusal carries code and message: show the message.
• - Set a timeout of 30 seconds or more: every answer of /api/v2 arrives within about 25 seconds.

import time, uuid, requests

API = "https://status200uploads.com/api/v2"
HEADERS = {"Authorization": "Bearer rl_your_api_key"}

# 1. Your profiles, and the networks that can post now
for profile in requests.get(f"{API}/accounts", headers=HEADERS, timeout=30).json()["data"]:
    print(profile["handle"], [n["platform"] for n in profile["networks"] if n["health"] == "ready"])

# 2. Publish, with one Idempotency-Key made once for this post
body = {"post": {"accountId": "@myprofile", "platform": "linkedin", "content": {"text": "Hello from Python"}}}
key = str(uuid.uuid4())
# The codes a publish can get that the OpenAPI file's x-status200-retry table answers
# "wait_and_resend" (all of them but cancel_unconfirmed, a DELETE's): nothing was sent, or the
# first answer comes back
WAIT_AND_RESEND = {"media_processing", "idempotency_in_progress", "rate_limited", "caller_check_unavailable",
                   "schedule_check_unavailable", "idempotency_unavailable", "dry_run_unavailable",
                   "upstream_unavailable", "skool_unavailable", "x_unavailable"}
resp, answer, resent_unknown = None, None, False
for attempt in range(5):
    try:
        resp = requests.post(f"{API}/posts", headers={**HEADERS, "Idempotency-Key": key}, json=body, timeout=40)
        answer = resp.json()
    except (requests.Timeout, requests.ConnectionError, ValueError):
        # No answer, or a gateway's page instead of ours: the table's "not_json" rule,
        # resend_once_with_key. The same key makes it safe: a post that went out is answered again.
        answer = None
        if resent_unknown:
            break
        resent_unknown = True
        time.sleep(5)
        continue
    error = answer.get("error") if isinstance(answer.get("error"), dict) else {}
    wait = int(resp.headers.get("Retry-After") or error.get("retry_after_seconds") or 5)
    if error.get("code") in WAIT_AND_RESEND and wait <= 60:
        time.sleep(wait)
        continue
    break  # any other answer: read it

# 3. Follow the post until it is done (10 minutes at most)
if answer and "status200" in answer:
    for _ in range(20):
        post = requests.get(answer["status200"]["status_url"], headers=HEADERS, timeout=30).json()["data"]
        if post["done"]:
            break
        time.sleep(30)
    print(post["status"], post.get("permalink"))
else:
    print(resp.status_code if resp is not None else "no answer", answer)

Integrating with n8n

Use n8n workflows to automate social media publishing with Status 200 Uploads.

The Status 200 Uploads community node, @status200uploads/n8n-nodes-status200uploads, is on npm. On self-hosted n8n, an owner or admin opens Settings, Community Nodes, Install, and enters the package name. In queue mode, install it with npm in ~/.n8n/nodes instead, as the node's README says. Then create a Status 200 Uploads API credential with your API key.

n8n Cloud installs only community nodes that n8n has verified. This node is not verified yet. Until n8n verifies it, use the HTTP Request node on n8n Cloud, as described below. The HTTP Request node works on self-hosted n8n too.

• - Post: Create publishes a post now, schedules it (When: At a Set Time) or only checks it (Check Only (Dry Run)). Post: Get and Get Many read your posts and scheduled posts, and Post: Cancel stops a scheduled or queued post that has not gone out.
• - Account: Get Many lists your profiles and their networks. Account: Get Posting Options gives what a profile may do on each network: TikTok privacy levels, Pinterest boards, Skool groups, the Instagram limit. Media: Import From URL imports a file and waits until it is ready, and Media: Get reads an import.
• - By default every Post: Create and Media: Import From URL sends an automatic Idempotency-Key, made from the workflow, the execution, the node, the item and the request. With Retry On Fail on, a retry in the same execution sends the same key and gets the first answer back instead of posting twice. Keep $now and random values out of the node's fields: a changed request is a new post.
• - One node sends one post to one network from one profile: to cross-post, use one node per network. The node can also be used as a tool by n8n's AI Agent.

Two example workflows are in the templates folder of the public repository: one cross-posts text and an image to X, LinkedIn and Facebook, the other posts a short video to TikTok, Instagram Reels and YouTube Shorts and waits until each network is done. The node's README describes its fields, its answers and the limits it works within.

With the HTTP Request node

On n8n Cloud until the node is verified, or wherever you prefer plain requests, the HTTP Request node does the same. Every request and answer it uses is described in the OpenAPI file at https://status200uploads.com/openapi.yaml.

Wait until a post is published

Every answer that made a post carries status200.status_url, the address that reads it back. A loop of a few nodes waits for the outcome, stops after 10 minutes, and never sends the post a second time:

To read your whole history, use an HTTP Request node on https://status200uploads.com/api/v2/posts?limit=100 with n8n's pagination: "Response Contains Next URL", next URL {{ $response.body.next_url }}, complete when {{ !$response.body.next_url }}. https://status200uploads.com/api/v2/accounts lists your profiles and their ids for post.accountId.

Integrating with Make.com

Build automated scenarios in Make.com that publish content through the Status 200 Uploads API.

Integrating with Zapier

Connect Status 200 Uploads to thousands of apps through Zapier's webhook integration.

Changelog

Changes to the API by month, newest first. Breaking changes are marked.