v1

ShortSync API

Publish videos, images, carousels and text posts to 17 social platforms, including Instagram, TikTok, YouTube, LinkedIn and X, from a single HTTP call.

Anyone with a ShortSync account can mint a key from Settings → API, MCP & webhooks. Each plan has its own monthly request cap; see your GET /me response for the current limit. Questions: [email protected].

Where to go next

At a glance

  • REST over HTTPS at https://api.shortsync.app/v1.
  • Bearer tokens, JSON request/response, snake_case fields.
  • One token kind: workspace keys publish posts and read data for the workspace they're pinned to at creation.
  • Upload media, then fan out to multiple platforms in one POST.
  • Schedule, save as drafts, reschedule, or cancel: all from the posts endpoints.
  • Webhooks tell you when a post is published, fails or is scheduled, so you don't have to poll.

Use with an LLM

Want Claude or ChatGPT to write your integration? Paste the block below into a fresh chat, replace [YOUR TASK HERE] with what you want to build, and send. The block gives the LLM everything it needs about authentication, endpoints, scopes, and the v1 limitations.

You are helping me write code against the ShortSync API.

## Quick reference

- Base URL: https://api.shortsync.app/v1
- Auth: Authorization: Bearer <token>
  - ss_live_* tokens are pinned to one workspace at creation
- Content type: application/json for request and response bodies
- Field naming: snake_case
- IDs: UUIDs, treat as opaque strings
- Timestamps: ISO 8601 with timezone, e.g. 2026-06-07T13:30:00Z
- Errors: { status, code, message, details? }. Switch on `code`, never `message`.
- Request correlation: send X-Request-ID (UUID) with each request, or read it from the response on errors. Log it on your side so support tickets can reference the exact request.

## Scopes (granted on workspace key creation)

- uploads:write                 (upload media)
- posts:read, posts:write       (read or publish posts, Repurposing workflows)
- connections:read              (list connected platform accounts)
- webhooks:read, webhooks:write (manage webhook subscriptions)

## Core flow: publish a video to one or more platforms

1. POST /uploads
   body: {} or { filename } (filename is optional, display only)
   -> { upload_id, presigned_url, method: "PUT", expires_at, workspace_id,
        required_headers? }
   If required_headers is present, echo every key verbatim on the PUT.

2. PUT <presigned_url>
   Send the file bytes with a Content-Type header for your file's MIME
   (video/mp4, video/quicktime, video/webm, video/x-msvideo,
   video/x-matroska, image/jpeg, image/png, image/webp, image/heic,
   image/gif). The upload is finalized lazily on first use; no /complete
   call. Unsupported MIMEs return 415 UNSUPPORTED_FILE_TYPE at finalize.

3. GET /connections
   -> list of connected platform accounts. Each has { id, platform, status }.

4. POST /posts
   body: {
     upload_id,
     publish_mode: "immediate" | "scheduled" | "draft",
     scheduled_for: "2026-06-08T15:00:00Z",   // required when scheduled
     caption,                                 // top-level default (non-YouTube)
     first_comment,                           // top-level default
     targets: [
       {
         connection_id,                       // determines the platform
         caption,                             // overrides top-level caption
         title,                               // YouTube, Pinterest, Tumblr
         description,                         // YouTube, Pinterest, Tumblr
         first_comment,                       // overrides top-level first_comment
         scheduled_for,                       // per-target override
         platform_options: {                  // platform-specific settings
           tiktok: { privacy_level, disable_comment, ... },
           youtube: { privacy_status, made_for_kids, notify_subscribers, ... },
           instagram: { share_to_feed, share_to_story, ... }
         }
       }
     ]
   }
   -> 201 with one post object per target. Some posts may carry status: "failed"
      and an `error` object (per-target operational errors do NOT fail the
      whole call). Always iterate data[] and check each post.

## Key endpoints

GET    /me                                token scopes, plan, monthly API quota (any scope)

POST   /uploads                           reserve upload slot         (uploads:write)
GET    /uploads/{id}                      retrieve upload state       (uploads:write)

POST   /posts                             publish (fan-out)           (posts:write)
GET    /posts                             list, paginated, filterable (posts:read)
GET    /posts/{id}                        single post                 (posts:read)
PATCH  /posts/{id}                        reschedule or edit          (posts:write)
DELETE /posts/{id}                        cancel scheduled or draft   (posts:write)

GET    /connections                       list connected accounts     (connections:read)
GET    /connections/{id}                  single connection           (connections:read)

GET    /repurposing/workflows             list workflows              (posts:read)
POST   /repurposing/workflows             repost new or older posts   (posts:write)
PATCH  /repurposing/workflows/{id}        change settings, pause      (posts:write)
DELETE /repurposing/workflows/{id}        delete a workflow           (posts:write)
POST   /repurposing/workflows/{id}/sync   run it now                  (posts:write)
GET    /repurposing/workflows/{id}/posts  what it reposted/scheduled  (posts:read)

GET    /webhooks                          list webhooks               (webhooks:read)
POST   /webhooks                          subscribe a URL to events   (webhooks:write)
PATCH  /webhooks/{id}                     change url/events/active    (webhooks:write)
DELETE /webhooks/{id}                     unsubscribe                 (webhooks:write)
POST   /webhooks/{id}/test                send a signed test event    (webhooks:write)

## Webhooks (instead of polling)

POST /webhooks with { url, events: ["post.published", "post.failed", "post.scheduled"] }
returns the webhook with a one-time `secret` (whsec_...). ShortSync then POSTs
{ id, type, created_at, workspace_id, data: { post: { id, upload_id, platform,
status, caption, scheduled_for, published_at, url, error, ... } } } to the URL.
Verify X-ShortSync-Signature: t=<unix>,v1=<hex>, where v1 = HMAC-SHA256(secret,
"<t>.<raw body>"). Answer 2xx within 10s; failures are retried (6 tries).

## Platforms

instagram, youtube, tiktok, facebook, snapchat, pinterest, twitter, threads, bluesky

## Pagination

Every list endpoint is cursor-paginated, newest first. Pass ?cursor= from
pagination.next_cursor on the next call. Default limit=25, max 100.
next_cursor is null when there are no more pages.

## v1 limitations to plan around

- Upload.status only transitions between reserved and ready; the
  transitional uploaded/failed states are reserved for future use.
  For image uploads, Upload.media.* fields other than content_kind
  return null. Video uploads are probed server-side at finalize.
- Per-key rate limits (60/min) and a monthly request quota per
  organization are enforced. Plan for 429 RATE_LIMIT_EXCEEDED and
  429 QUOTA_EXCEEDED. The request quota is shared across all keys an
  organization mints. Rotating or adding keys does not reset or
  multiply the cap. There is no per-post cap; paid plans publish
  unlimited.
- Idempotency-Key is honored on POST /posts, POST /uploads/carousel-group and POST /repurposing/workflows (24h TTL). Not on POST /uploads.

## Full spec

OpenAPI 3.1: https://www.shortsync.app/openapi.yaml
Postman collection: https://www.postman.com/shortsync/shortsync-api
Docs: https://www.shortsync.app/docs/api

---

My task:

[YOUR TASK HERE]