# Cancel still-scheduled targets of an operation
Source: https://docs.sydium.com/api-reference/cancel-still-scheduled-targets-of-an-operation
/api-reference/openapi.yaml delete /v1/posts/{id}
Cancels only targets still in the `scheduled` state. Targets that have already begun publishing (`processing`) or reached a terminal state (`published`/`failed`) are left unchanged - cancellation never races an in-flight publish. Returns the operation's current per-target state after cancellation.
# Capability limits for a single platform
Source: https://docs.sydium.com/api-reference/capability-limits-for-a-single-platform
/api-reference/openapi.yaml get /v1/platforms/{platform}
# Delete an idea you saved from the Chrome extension
Source: https://docs.sydium.com/api-reference/delete-an-idea-you-saved-from-the-chrome-extension
/api-reference/openapi.yaml delete /v1/ideas/{id}
# Edit an idea you saved from the Chrome extension
Source: https://docs.sydium.com/api-reference/edit-an-idea-you-saved-from-the-chrome-extension
/api-reference/openapi.yaml patch /v1/ideas/{id}
Only an idea the signed-in user saved through POST /v1/ideas. Any other id returns 404 and nothing is written.
# Edit still-scheduled targets of an operation
Source: https://docs.sydium.com/api-reference/edit-still-scheduled-targets-of-an-operation
/api-reference/openapi.yaml patch /v1/posts/{id}
Edits the `caption`, `media`, and/or `scheduleAt` of an operation's targets that are still in the `scheduled` state. Omitted fields are left unchanged; `media: []` clears media. Targets already `processing`/`published`/`failed`/`cancelled` are left untouched - an edit never races an in-flight publish. Cannot change which platforms the operation posts to (cancel and re-create for that). Returns `409` if no target is still scheduled.
# Fetch today's Muse content idea (a read; does not generate)
Source: https://docs.sydium.com/api-reference/fetch-todays-muse-content-idea-a-read;-does-not-generate
/api-reference/openapi.yaml get /v1/ideas/today
Returns the team's current Muse idea, resolved the same way the app does (paid plans see today's idea; free plans see the trailing 7-day idea), or a specific agency client's current idea when `clientId` is set. This is a read only - it never triggers idea generation or AI spend. When no idea is in window, `data.idea` is `null`.
# Generate a social caption with AI
Source: https://docs.sydium.com/api-reference/generate-a-social-caption-with-ai
/api-reference/openapi.yaml post /v1/generate
# Ingest media from a public URL into storage
Source: https://docs.sydium.com/api-reference/ingest-media-from-a-public-url-into-storage
/api-reference/openapi.yaml post /v1/media/from-url
Fetches the URL server-side and stores it as this team's media, returning the Sydium URL a post's `media` array requires. The fetch is pinned to the address validated by the SSRF guard, follows at most one redirect, and refuses anything resolving to a non-public address. Also returns the file's measured dimensions and duration where they can be determined.
# List connected accounts for the key's team (or an agency client)
Source: https://docs.sydium.com/api-reference/list-connected-accounts-for-the-keys-team-or-an-agency-client
/api-reference/openapi.yaml get /v1/accounts
# List the agency clients under the key's team
Source: https://docs.sydium.com/api-reference/list-the-agency-clients-under-the-keys-team
/api-reference/openapi.yaml get /v1/clients
Returns the team's agency clients (id/name/status). Use a client `id` as the `clientId` parameter on /v1/accounts, /v1/posts and /v1/ideas/today to act on that client's behalf.
# List upcoming scheduled posts (optionally within a from/to window)
Source: https://docs.sydium.com/api-reference/list-upcoming-scheduled-posts-optionally-within-a-fromto-window
/api-reference/openapi.yaml get /v1/posts
Returns the team's scheduled posts, one entry per operation with its target platforms, sorted by scheduled time. Pass `from`/`to` (ISO 8601) to bound a window - for example the current week. Published and failed posts are not included.
# Liveness probe (no auth)
Source: https://docs.sydium.com/api-reference/liveness-probe-no-auth
/api-reference/openapi.yaml get /v1/health
# MCP server (stateless Streamable HTTP, JSON-RPC 2.0). Send Accept= application/json, text/event-stream.
Source: https://docs.sydium.com/api-reference/mcp-server-stateless-streamable-http-json-rpc-20-send-accept=-applicationjson-textevent-stream
/api-reference/openapi.yaml post /v1/mcp
# Mint a presigned upload URL
Source: https://docs.sydium.com/api-reference/mint-a-presigned-upload-url
/api-reference/openapi.yaml post /v1/media/upload-url
# Operation status with per-target results
Source: https://docs.sydium.com/api-reference/operation-status-with-per-target-results
/api-reference/openapi.yaml get /v1/posts/{id}
# Per-day account analytics time-series
Source: https://docs.sydium.com/api-reference/per-day-account-analytics-time-series
/api-reference/openapi.yaml get /v1/analytics
# Per-platform capability limits
Source: https://docs.sydium.com/api-reference/per-platform-capability-limits
/api-reference/openapi.yaml get /v1/platforms
# Publish now to one or more connected platforms
Source: https://docs.sydium.com/api-reference/publish-now-to-one-or-more-connected-platforms
/api-reference/openapi.yaml post /v1/posts
# Save a clip as an idea in the content library
Source: https://docs.sydium.com/api-reference/save-a-clip-as-an-idea-in-the-content-library
/api-reference/openapi.yaml post /v1/ideas
Used by the Sydium Chrome extension. The text is saved verbatim, with the page it came from, and appears in the app's Ideas tab at once.
# The ideas you saved from the Chrome extension, newest first
Source: https://docs.sydium.com/api-reference/the-ideas-you-saved-from-the-chrome-extension-newest-first
/api-reference/openapi.yaml get /v1/ideas/recent
Only ideas the signed-in user saved through POST /v1/ideas, up to 50. Readable without an active plan; `canSave` says whether new ideas can be saved.
# Authentication
Source: https://docs.sydium.com/authentication
Authenticate with an opaque API key sent as `Authorization: Bearer sk_live_...`. Keys are scoped (e.g. `posts:write`, `analytics:read`); a key can never exceed the issuing member's team role.
# Commands
Source: https://docs.sydium.com/cli/commands
Full command and flag reference for the Sydium CLI
Every command prints JSON to stdout, so you can pipe it into `jq` or a script.
## auth:login
Save your API key.
```bash theme={null}
sydium auth:login --key sk_live_...
```
| Flag | Required | Description |
| - | - | - |
| `--key` | yes | Your `sk_live_...` API key |
## auth:status
Show whether the CLI is authenticated (the key is masked).
```bash theme={null}
sydium auth:status
```
## clients:list
List the agency clients under your team (`id`, `name`, `status`). Use a client's `id` with `--client` on `accounts:list`, `posts:create`, and `posts:list` to act on that client's behalf.
```bash theme={null}
sydium clients:list
```
## accounts:list
List connected social accounts. Pass `--client` to list a specific agency client's accounts instead of your team's.
```bash theme={null}
sydium accounts:list
sydium accounts:list --client cl_9f2a
```
## platforms:list
List supported platforms and their posting capabilities.
```bash theme={null}
sydium platforms:list
```
## posts:create
Publish now, or schedule, to one or more platforms.
```bash theme={null}
sydium posts:create --platforms x,linkedin --caption "Hello world"
sydium posts:create --platforms linkedin --caption "Later" --schedule-at 2026-07-01T09:00:00Z
```
| Flag | Required | Description |
| - | - | - |
| `--platforms` | yes | Comma-separated target platforms |
| `--caption` | no | Post text |
| `--media` | no | Comma-separated Sydium-hosted media URLs |
| `--schedule-at` | no | Future ISO 8601 timestamp; omit to publish now |
| `--client` | no | Agency client id (see `clients:list`); publishes with that client's accounts |
Returns an operation `id` you can pass to `posts:get` and `posts:cancel`.
## posts:list
List upcoming scheduled posts. Pass `--from` / `--to` (ISO 8601) to bound a window, for example this week. Pass `--client` to list a specific agency client's scheduled posts.
```bash theme={null}
sydium posts:list
sydium posts:list --from 2026-06-29 --to 2026-07-05
sydium posts:list --client cl_9f2a
```
Each entry is one operation with its `id`, `scheduledFor`, `caption`, and target `platforms`.
## posts:get
Per-target status of an operation.
```bash theme={null}
sydium posts:get op_6d28cc8ebc8dde89f1f3fa19
```
## posts:cancel
Cancel a scheduled operation (only targets still scheduled are cancelled).
```bash theme={null}
sydium posts:cancel op_6d28cc8ebc8dde89f1f3fa19
```
## idea
Fetch today's Muse content idea for your team. This is a read - it never generates a new idea or spends tokens.
```bash theme={null}
sydium idea
```
Returns the current idea (`topic`, `angle`, `format`, `hashtags`, `whyItFits`, and an optional `anchor`), or `{ "idea": null }` when none is in window. Paid plans see today's idea; free plans see the current week's.
## analytics:get
Account analytics over a date range (defaults to the last 30 days). Dates are `YYYY-MM-DD`.
```bash theme={null}
sydium analytics:get --from 2026-06-01 --to 2026-06-30
```
## generate
Draft a caption in your brand voice.
```bash theme={null}
sydium generate --topic "our new pricing" --platform linkedin --tone professional
```
| Flag | Required | Description |
| - | - | - |
| `--topic` | yes | What the post is about |
| `--platform` | no | Target platform |
| `--tone` | no | Tone hint |
| `--language` | no | Output language |
# Introduction
Source: https://docs.sydium.com/cli/introduction
Drive Sydium from your terminal and scripts
Run Sydium from your terminal: publish, schedule, cancel, list accounts, and pull analytics without opening the app. Handy for cron jobs, CI, and quick one-offs. (It calls the [REST API](/quickstart) under the hood.)
## Install
```bash npm theme={null}
npm install -g @sydium/cli
```
```bash npx theme={null}
npx @sydium/cli --help
```
The binary is `sydium`. Verify it:
```bash theme={null}
sydium --help
```
## Authenticate
The CLI uses an API key. Grab one from your Sydium account settings, then:
```bash theme={null}
sydium auth:login --key sk_live_...
```
This saves your key locally. Check it any time:
```bash theme={null}
sydium auth:status
```
## Quick start
```bash theme={null}
# what's connected
sydium accounts:list
# publish now to two platforms
sydium posts:create --platforms x,linkedin --caption "Shipping > talking."
# schedule for later
sydium posts:create --platforms linkedin --caption "Recap thread" --schedule-at 2026-07-01T09:00:00Z
# pull last month's analytics
sydium analytics:get --from 2026-06-01 --to 2026-06-30
```
The full command and flag reference.
# Errors
Source: https://docs.sydium.com/errors
Errors return a JSON body `{ "success": false, "error": { "code", "message" } }` with a standard HTTP status: `401` unauthenticated, `403` insufficient scope/permission, `422` validation, `429` rate-limited / insufficient tokens, `404` not found.
# Client setup
Source: https://docs.sydium.com/mcp/connect
Connect Claude, ChatGPT, or Cursor to the Sydium MCP server
The Sydium MCP server lives at:
```
https://api.sydium.com/v1/mcp
```
Connecting is the same everywhere: add that URL as a custom MCP server, then click **Authorize** on the Sydium consent screen. There is **nothing to register and no key to paste** - the client registers itself and you approve access in the browser.
Go to **Settings -> Connectors -> Add custom connector**.
Set the name to `Sydium` and the URL to `https://api.sydium.com/v1/mcp`. Leave the optional **OAuth Client ID / Secret** fields blank - Sydium registers your client automatically.
Click **Add**. Your browser opens the Sydium consent screen. Review the access and click **Authorize**.
Back in a chat, Sydium's tools are available. Try: *"List my connected accounts."*
In **Settings -> Connectors**, choose to add a custom connector / MCP server.
Enter `https://api.sydium.com/v1/mcp`. Leave any optional OAuth client fields blank.
Approve access on the Sydium consent screen that opens.
Custom MCP connectors are rolling out across ChatGPT tiers; the exact menu names may differ in your build.
Add Sydium to your MCP configuration:
```json theme={null}
{
"mcpServers": {
"sydium": {
"url": "https://api.sydium.com/v1/mcp"
}
}
}
```
Cursor will prompt you to authorize in the browser on first use.
## What the consent screen shows
The Authorize screen names the client that is connecting, the workspace it will access, and the exact scopes requested (for example "Read your connected accounts", "Publish and schedule posts"). Nothing happens outside the scopes you approve, and a connected agent can never exceed your own team role.
## Disconnecting
Remove the connector in your client to stop it making requests. Tokens are scoped to what you approved and short-lived, so access ends there.
# Examples
Source: https://docs.sydium.com/mcp/examples
Things you can ask an agent connected to Sydium
Once your client is [connected](/mcp/connect), you drive everything in plain language. The agent picks the right tools and shows you what it did.
## Start from today's idea
```
What's my Sydium idea for today? Draft it for LinkedIn and let me review.
```
The agent calls `get_today_idea` to pull the brand-grounded idea Sydium already generated, then `generate_caption` to draft it - so the post starts from a real angle, not a blank page.
## Publish now
```
Post this to all my accounts: "Shipping > talking. New build is live."
```
The agent calls `list_accounts`, then `publish_post` with your text across every connected target.
## Schedule for later
```
Draft a post about our pricing change in my voice and schedule it
for Friday at 9am on LinkedIn and X.
```
The agent calls `generate_caption`, then `publish_post` with `scheduleAt` set to Friday 9am and two targets.
## Draft a carousel
```
Turn this week's blog post into a 7-slide Instagram carousel.
```
The agent writes the slide text and calls `draft_carousel`, then gives you a link. It opens the draft in Sydium with the Carousel Studio showing the slides in your brand's style - adjust them there and schedule. The agent never publishes a carousel it cannot see.
## Cancel a scheduled post
```
Actually, cancel that Friday post.
```
The agent calls `cancel_post` with the operation id from the previous step. Only targets still scheduled are cancelled.
## See what's scheduled
```
What posts do I have scheduled this week?
```
The agent calls `list_scheduled_posts` with this week's `from`/`to` and lists each scheduled post with its platforms and time - no post ids needed.
## Check status
```
Did my morning posts go out?
```
The agent calls `get_post_status` and reports the per-platform result (published, scheduled, or failed).
## Pull analytics
```
How did last month do across my accounts?
```
The agent calls `get_analytics` for the last 30 days and summarizes reach, engagement, and growth.
## Post to a specific format
```
Publish my new clip to YouTube as a Short with this caption: ...
```
The agent calls `get_platform_capabilities` to confirm the post type, then `publish_post` with a `youtube` target and the `short` post type.
You always stay in control. The agent shows the draft and the action it is about to take, and nothing posts outside the scopes you approved when you connected.
# Introduction
Source: https://docs.sydium.com/mcp/introduction
Drive Sydium from your AI agent over MCP
Connect an AI agent to Sydium and run your accounts by talking to it - draft in your brand voice, publish, schedule, cancel, and pull analytics.
The connect is one browser click: no API keys to paste, no developer app to register. Sydium's MCP server is a real OAuth 2.1 server with dynamic client registration, so the agent registers itself and you just approve the scopes. Works with Claude, ChatGPT, Cursor, or any MCP client.
**Endpoint**
```
https://api.sydium.com/v1/mcp
```
## How it works
Your agent gets **9 tools**. Connecting takes three steps - nothing to install:
Point your client at the Sydium MCP endpoint and click **Authorize** in the browser. No developer app to register, no API keys to paste - Sydium registers your client automatically, and you approve exactly which scopes it gets.
On connect, the agent reads the 9 Sydium tools and their schemas - so it knows precisely what it can do and how to call each one.
Ask for what you want - *"publish this everywhere,"* *"schedule the recap for Friday."* The agent calls the right tools and reports back. You keep the final say, always within the scopes you approved.
## Available tools
| Tool | Scope | What it does |
| - | - | - |
| `list_accounts` | `accounts:read` | List connected social accounts (yours, or an agency client's via `clientId`) |
| `list_clients` | `clients:read` | List the agency clients under your team, to act on their behalf |
| `get_platform_capabilities` | `capabilities:read` | Per-platform posting limits, formats, and post types |
| `generate_caption` | `generate:write` | Draft a caption in your brand voice |
| `get_today_idea` | `ideas:read` | Fetch today's brand-grounded Muse content idea (a read) |
| `draft_carousel` | `posts:write` | Draft a carousel from slide text; the user reviews the rendered slides in Sydium and schedules |
| `publish_post` | `posts:write` | Publish now or schedule to one or more platforms |
| `get_post_status` | `posts:read` | Per-target status of a publish or schedule operation |
| `list_scheduled_posts` | `posts:read` | List upcoming scheduled posts (optional date window) |
| `cancel_post` | `posts:write` | Cancel a still-scheduled operation |
| `get_analytics` | `analytics:read` | Account analytics time-series |
**Agencies:** call `list_clients` to get your clients, then pass a client's `id` as the `clientId` argument to `publish_post`, `draft_carousel`, `list_accounts`, or `list_scheduled_posts` to act on that client's connected accounts instead of your team's own.
Full input schema and behavior for every tool.
## Authentication
Your client connects over OAuth: it sends you to a Sydium consent screen, you pick **Authorize**, and the agent gets a scoped token. The agent never sees a password, and it can never do more than the scopes you grant - or more than your own team role allows. The [Client setup](/mcp/connect) guide has the per-client steps and a walkthrough of the consent screen.
## Connect your client
Step-by-step for Claude Desktop, ChatGPT, and Cursor.
## Quick example
Once connected, just talk to your agent:
```
Publish my launch post to all my accounts in my voice,
then schedule the recap thread for Friday at 9am.
```
The agent calls `list_accounts`, `generate_caption`, and `publish_post` (with `scheduleAt`), then reports back. You keep the final say.
## FAQ
No. MCP uses one-click browser OAuth with dynamic client registration. API keys are only for the REST API and CLI.
Any MCP-compatible client - Claude (desktop and web), ChatGPT, Cursor, and others. See [Client setup](/mcp/connect).
Yes. `add_media` stores an image or video and returns the URL that `publish_post` needs, and it tells you which platforms will accept the file before you schedule anything. Give it a public link to the file, or - in ChatGPT on the web - drag the file straight into the conversation. Claude chat connectors cannot pass attachments yet, so there a link is the way in. An agent that runs on your computer, like Claude Code, can upload a file straight from your disk with `create_upload_url`, no link needed.
Only the scopes you approve on the consent screen, and never more than your own team role allows.
# Tools reference
Source: https://docs.sydium.com/mcp/tools
The tools the Sydium MCP server exposes, with input schemas
Every tool is scoped. A connected agent can only call a tool if the scope was granted on the consent screen, and never beyond your team role.
## list\_accounts
List connected social accounts. Returns each account's platform and handle.
An agency client id (see `list_clients`). When set, returns that client's connected accounts instead of the team's own.
## list\_clients
List the agency clients under this team - each with its `id`, `name`, and `status`. Pass a client `id` as the `clientId` argument to `publish_post`, `list_accounts`, or `list_scheduled_posts` to act on that client's behalf instead of the team's own accounts. No arguments.
## get\_platform\_capabilities
Per-platform posting limits, formats, and supported post types.
A single platform (for example `instagram`, `youtube`, `linkedin`). Omit to get every platform.
## generate\_caption
Draft a caption in your brand voice.
What the post is about (1-2000 characters).
Target platform, so the draft fits its norms and limits.
A tone hint (for example `casual`, `professional`).
Output language.
## get\_today\_idea
Fetch today's Muse content idea for the team - the daily, brand-grounded idea Sydium already generated. This is a read: it never generates a new idea or spends tokens. No arguments.
Returns the current idea (`topic`, `angle`, `format`, `hashtags`, `whyItFits`, and an optional `anchor` - the one concrete detail to hang the post on), or `null` when none is in window. Paid plans see today's idea; free plans see the idea for the current week.
## add\_media
Store an image or video in Sydium and return the media URL that `publish_post` and `update_post` require. Media must be Sydium-hosted - an external URL passed straight to `publish_post` is rejected - so call this first.
Pass **either** `file` (a file attached to the conversation) **or** `url` (a direct link to the image or video itself, not a web page containing it). Returns the media URL plus its measured size, dimensions and duration, and `acceptedBy` / `rejectedBy` - which platforms will take this file.
Supported: `jpeg`, `png`, `gif`, `webp`, `mp4`, `mov`, `webm`, up to 200MB. For a larger video, or a file on the user's own computer, see `create_upload_url`. HEIC and AVIF (the iPhone photo defaults) are not supported - convert to JPEG first.
The media is removed once its post publishes, so a URL cannot be reused for a second post. Call `add_media` again.
A direct, publicly reachable link to an image or video file. Redirects are followed and each destination is re-validated.
A file the user attached to the conversation, supplied by the host as `{ download_url, file_id, mime_type?, file_name? }`. Only hosts that support file parameters populate this - see the note below.
The post type this media is for (`reel`, `story`, `carousel`, `short`...). Story and carousel limits are stricter than the platform default, so without it `acceptedBy` is optimistic. Check `rejectedBy` before scheduling.
**File attachments are ChatGPT-only today.** ChatGPT reads the tool's file parameter declaration and passes attachments through, which is what makes drag-and-drop work - on the **web** client; ChatGPT mobile currently sends incomplete file references. Claude chat connectors have no equivalent mechanism, so there `url` is the only path. If a user wants to post a file from their device and attaching it is not available, ask them for a public link - or, in an agent that runs on their computer (Claude Code), use `create_upload_url`.
`add_media` is for real photos and videos. Do not generate or upload placeholder or text-only images to stand in for carousel slides - use `draft_carousel`.
## create\_upload\_url
Upload a file from the user's own computer. For agents that can run shell commands on that machine, such as Claude Code: `add_media` can only fetch a public link, and a file on the user's disk has none. It is also the way in for a video over `add_media`'s 200MB limit - up to 2GB for video, 50MB for images.
Returns a one-time `uploadUrl` (valid for an hour) and the `url` to pass to `publish_post` or `update_post`. The agent PUTs the file's bytes to `uploadUrl` with `Content-Type` set to exactly the returned `contentType`; the returned `curl` field is that command, with `FILE` standing for the path:
```bash theme={null}
curl --fail -X PUT -H 'Content-Type: video/mp4' --upload-file '/Users/me/reel.mp4' ''
```
The upload is bound to the declared size, so the file must be exactly `fileSize` bytes. Unlike `add_media`, the file is not measured, so no `acceptedBy` / `rejectedBy` is returned; `publish_post` still checks the file exists before scheduling. The media is removed once its post publishes.
The file's MIME type: `image/jpeg`, `image/png`, `image/gif`, `image/webp`, `video/mp4`, `video/quicktime` (`.mov`) or `video/webm`.
The file's exact size in bytes.
## draft\_carousel
Draft a carousel from slide text the agent writes. Sydium stores it as a draft and returns `openUrl`, a link that opens it in the Sydium composer. There the user sees the slides rendered in the brand's carousel style and colors in the Carousel Studio, adjusts them, and schedules the post.
**Nothing is published or scheduled.** An agent cannot see a rendered slide, so a carousel is always approved by a person in Sydium. Give the user `openUrl`.
Returns `draftId`, `openUrl`, the number of `slides`, the `platforms` it is planned for, and `status: "draft"`.
What the carousel is about, in a sentence (1-300 characters).
3-20 slides in reading order, each `{ headline, body?, altText? }`. The first slide is the cover (a hook as the headline) and the last is the close (what to do next). Keep headlines short (up to 200 characters) and put the substance in `body` (up to 1000).
Exactly two other cover hooks, different from the first slide's headline and from each other. The user picks one of the three in the studio.
The post caption. Omit and the user writes it in Sydium.
`teach`, `sell`, or `story`. Defaults to `teach`.
What the close slide asks for: `save`, `share`, `follow`, or `click`. Defaults to `save`.
The platforms to plan it for (for example `instagram`, `linkedin`, `tiktok`). Defaults to `instagram`. The composer opens with these selected.
ISO 639-1 code. Omit unless the user asks for a specific language - the draft uses the brand voice's language.
An agency client id (see `list_clients`). The draft uses that client's brand voice, and opening it switches Sydium to that client.
The link opens in the workspace the connector was authorized for. A user signed in to a different workspace sees a "could not be opened" message - they switch workspace and open it again.
## publish\_post
Publish now, or schedule for later, to one or more platforms. Returns an operation `id`, a rollup `status`, and per-target results.
The post text.
Up to 35 **Sydium-hosted** media URLs, as returned by `add_media`. Arbitrary external URLs are rejected.
A future timestamp with offset (for example `2026-07-01T09:00:00Z`). Omit to publish immediately.
1-10 targets, each `{ platform, postType?, options? }`. `postType` and `options` are platform-specific (for example a YouTube `short`).
An agency client id (see `list_clients`). When set, the post publishes using that client's connected accounts. Connectivity is checked against the client, not the team.
## get\_post\_status
Per-target status of a publish or schedule operation.
The operation `id` returned by `publish_post`.
## update\_post
Edit a scheduled operation: change its `caption`, `media`, and/or `scheduleAt`. Only targets that are **still scheduled** are updated - a target already publishing or published is left untouched, and the edit never races an in-flight publish. Omitted fields are left unchanged; `media: []` clears media. You cannot change which platforms the operation posts to - cancel and re-create for that. Returns the operation's state after the edit, or a `409` if no target is still scheduled.
The operation `id` returned by `publish_post`.
Replacement post text.
Up to 35 **Sydium-hosted** media URLs from `add_media` (same rules as `publish_post`). Pass `[]` to remove all media.
A new future timestamp with offset. The scheduled publish is moved to this time.
An agency client id (see `list_clients`). When set, scopes the edit to that client's post.
## list\_scheduled\_posts
List the team's upcoming scheduled posts. Each entry is one operation with its target platforms, scheduled time, and caption - so an agent can answer "what's scheduled this week?" without knowing any ids. The `caption` is the post's display text as shown in the app: the video title for YouTube, the caption for caption-first platforms. Published and failed posts are not included.
Window start. Omit for everything upcoming.
Window end. Pass `from` and `to` together to bound a range, for example the current week.
An agency client id (see `list_clients`). When set, lists only that client's scheduled posts.
## cancel\_post
Cancel a scheduled operation. Only targets that are **still scheduled** are cancelled - a target already publishing or published is left untouched. Returns the operation's state after cancellation.
The operation `id` to cancel.
## get\_analytics
Account analytics as a daily time-series.
Start date. Defaults to 30 days ago.
End date. Defaults to today.
# Quickstart
Source: https://docs.sydium.com/quickstart
The Sydium API lets you publish, schedule, read analytics, and generate captions programmatically. Base URL: `https://api.sydium.com`.
```bash theme={null}
curl https://api.sydium.com/v1/accounts -H "Authorization: Bearer sk_live_..."
```
CLI: `npx @sydium/cli auth:login --key sk_live_...` then `sydium accounts:list`.