# Publishing API documentation

## Connect AI clients with MCP

MCP endpoint: **https://usecloudconnect.com/mcp**. Transport: **Streamable HTTP**, stateless JSON responses. Runs inside the existing web service; no extra server, port or paid service is required. This server covers the implemented publishing API; it does not expose unimplemented advertising, inbox or telephony operations.

### Connect an AI client

1. In **API & integrations**, create an integration at the platform, Agency, Group or Account level. Select business/connection scope and only the permissions the AI needs. Account-owned integrations remain restricted to that business.
2. Add the MCP endpoint to your AI client. Choose OAuth and dynamic client registration (DCR), where requested. You do not need to generate an API key for OAuth.
3. Sign in with your existing invited user, verify with a passkey or TOTP, choose the integration and approve specific scopes. Read-only scopes are selected initially. Select publishing permissions only when you want the client to publish. Select **offline_access** to allow token refresh for up to 30 days.
4. Ask the agent to list Accounts and Connections, inspect capabilities, and prepare drafts. Publishing remains subject to your integration’s configured trust, business approval policy and platform readiness.

**ChatGPT:** add a custom MCP app/plugin in your workspace’s developer settings using the endpoint above and OAuth. Use DCR (the server advertises its registration endpoint). Availability and approval depend on your ChatGPT plan and workspace settings. [Official setup](https://help.openai.com/en/articles/12584461-developer-mode-and-full-mcp-connectors-in-chatgpt-beta) · [OAuth configuration](https://developers.openai.com/plugins/build/auth).

**Claude:** in Settings → Connectors, add a custom connector using the endpoint and complete OAuth. Workspace administrators may need to approve it. [Official setup](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp).

**Claude Code:**

```sh
claude mcp add --transport http publishing https://usecloudconnect.com/mcp
```

Then use `/mcp` in Claude Code to authenticate. [Official CLI reference](https://code.claude.com/docs/en/mcp).

**Codex:**

```sh
codex mcp add publishing --url https://usecloudconnect.com/mcp
codex mcp login publishing --scopes discovery.read,posts.read,posts.write,posts.publish,posts.cancel,posts.retry,media.read,media.write,offline_access
```

For server-to-server developer clients, existing API keys also work through an Authorization bearer header. Codex can read the key from your secret-managed environment:

```sh
codex mcp add publishing --url https://usecloudconnect.com/mcp --bearer-token-env-var PUBLISHING_API_KEY
```

Never paste credentials into prompts or commit them in configuration. OAuth is recommended for interactive clients. Client-side tool confirmation is an additional safeguard; it does not replace server permissions. Connecting a client does not authorize an agent to publish unspecified content.

### Tool reference

Tools are listed only when the credential has the required base scope. Every call rechecks current integration access. Discovery and list tools accept cursor/limit; follow nextCursor until null.

| Tools | Scope | Purpose |
| --- | --- | --- |
| list_accounts, list_connections, get_connection_capabilities | discovery.read | Resolve exact destinations, health and supported formats |
| list_posts, get_post, get_post_batch | posts.read | Read this integration’s posts, versions and per-item outcomes |
| validate_post_batch | posts.write | Validate up to 100 items without storing or publishing |
| create_post_batch, edit_post | posts.write | Create drafts or delivery requests, edit exact versions; publishing additionally requires posts.publish |
| submit_post | posts.publish | Submit a post for its configured delivery |
| cancel_post, unpublish_post | posts.cancel | Cancel pending delivery or remove a supported published post |
| retry_post | posts.retry | Retry eligible failures with reconciliation protection |
| create_media_upload, complete_media_upload, import_media | media.write | Prepare durable media and inspection |
| get_media | media.read | Inspect processing state and metadata |
| list_webhook_endpoints, create_webhook_endpoint, disable_webhook_endpoint | webhooks.manage | Manage outbound signed status notifications |
| list_webhook_deliveries, replay_webhook_delivery | webhooks.manage | Inspect and replay failed delivery |
| read_documentation | Any authenticated access | Read this entire Markdown guide |

MCP resources: `workspace://docs/publishing` (this complete Markdown guide), `workspace://docs/openapi` (REST OpenAPI). Prompt: `prepare_social_posts`, with a required brief and optional accountId, prepares drafts and asks for missing destination choices. Tools have machine-readable input schemas and read-only/destructive/idempotency annotations.

### Batch arguments

`create_post_batch` uses the REST batch payload plus an `idempotencyKey` argument. Each item has its own connectionId, content, title, format, media, platformOptions and delivery. IDs are local application IDs from discovery. Exact platform options and media constraints are documented below.

```json
{
  "accountId": "11111111-1111-4111-8111-111111111111",
  "idempotencyKey": "crm-article-847-v1",
  "externalReference": "article-847",
  "items": [{
    "clientReference": "article-847-facebook",
    "connectionId": "22222222-2222-4222-8222-222222222222",
    "title": "Our latest article",
    "format": "text",
    "content": "A summary tailored to this connection.",
    "delivery": {"mode": "draft"}
  }]
}
```

For immediate delivery use `{"mode":"now"}`. For scheduling use `{"mode":"scheduled","scheduledAt":"2027-01-15T09:00:00-07:00"}`. Confirm the actual business timezone and intended date; the example date is a placeholder. Validate first with validate_post_batch (same arguments without idempotencyKey).

Post actions use postId, current version and idempotencyKey. edit_post also takes the complete replacement input as post. Media upload tools return short-lived signed URLs; send binary bytes directly to storage, never as base64 inside MCP. Then complete the upload and poll get_media until ready. import_media accepts accountId, a public HTTPS url, optional name, and idempotencyKey.

Successful tool results expose `{httpStatus,result}` in both text JSON and structuredContent. Business errors set isError and return a stable code/message. Partial batch acceptance retains per-item results. HTTP 202 means accepted, never proof of publication. Preserve idempotency keys and clientReference values on retries; poll uncertain jobs rather than issuing duplicates. Rate limits are shared with REST at integration and owner levels, including MCP discovery requests.

### Authorization and revocation

OAuth uses exact registered redirect URIs, authorization-code flow with S256 PKCE, one-time two-minute codes, hashed opaque access/refresh tokens and resource-bound grants. Access tokens last at most 15 minutes. With offline_access, refresh tokens rotate; reuse revokes the whole grant. Reconnect after 30 days or after revocation. This server supports DCR with public clients (none) and client_secret_post/client_secret_basic. CIMD and legacy HTTP+SSE are not advertised. POST /mcp handles requests; GET/DELETE return 405 because the server has no persistent transport sessions. Poll post tools or use publishing webhooks for asynchronous outcomes.

Use the **central** MCP URL above, including for branded Agencies. Tenant boundaries come from integration ownership and authorized scopes. Unknown hosts are rejected. OAuth tokens work only at /mcp; browser session cookies cannot authenticate tool calls and MCP tokens cannot authenticate the REST API. Existing API keys can authenticate both interfaces. Untrusted Origin headers are rejected.

OAuth access is tied to both the consenting user and the selected integration. Disabled users, lost management permission, removed business access, disabled integrations, grant expiry or revocation restrict future requests. Accounts are fixed to the authorized set at consent; newly created businesses require a new consent. Connection restrictions remain enforced. API keys retain their existing service-identity semantics.

Manage or revoke your connected clients at **[AI client access](https://usecloudconnect.com/mcp/access)**. An authorized integration administrator can disable the integration to stop all its API/MCP access. Revocation stops new requests; already accepted publishing jobs must be cancelled separately. The audit log records tool name, integration and the consenting user without credentials or content payloads. Webhook signing secrets are returned once and must stay in secure storage.

### Troubleshooting

- 401: reauthenticate or replace an expired/revoked API key. The WWW-Authenticate header links protected-resource discovery.
- No integration choices: create an integration or ask an administrator for integrations.manage access.
- Missing tools: grant the corresponding integration scope, then reconnect and approve it. Missing posts.publish blocks delivery even if draft tools are present.
- No businesses: check current memberships and the integration’s scope. OAuth cannot grant broader access than the user possesses.
- Readiness or approval errors: resolve them in the workspace; MCP cannot bypass them.
- 429: wait for Retry-After and reduce concurrency.
- Broken client setup: use Streamable HTTP and DCR OAuth, confirm the central URL, and check `/.well-known/oauth-authorization-server`. Actual client availability is controlled by the client vendor and workspace settings.


## Start here

API version: **1.0.0**. Base URL: **https://usecloudconnect.com/api/v1**.

This API connects a CRM, content generator, or AI agent to social Connections owned by business Accounts. An Account is a business; a Connection is one connected destination. All IDs in requests are this application's IDs, obtained through discovery. Example UUIDs below are placeholders.

1. An authorized administrator creates an integration in **API & integrations**, selects its scope and generates an API key.
2. Discover authorized Accounts and Connections. Inspect the target Connection's capabilities.
3. Validate a batch, then create drafts. Prepare and inspect any media.
4. Request immediate or scheduled delivery only when the operator intends to publish. Follow business approval policy and live readiness gates.
5. Store batch/post IDs, client references, versions and idempotency keys in the CRM. Poll status or receive signed webhooks.

**For AI agents:** use the documented public API only. Keep bearer keys in the caller's server-side secret store; never place them in prompts, client-side JavaScript or URLs. Do not invent Connection IDs, platform options or supported formats. Do not treat HTTP 202 as publication success. Never resubmit uncertain writes under a different key.

API customer payment is disabled during beta. Storage allowances and rate limits still apply. A connected channel does not imply that every publishing format is enabled or live-verified. The capability endpoint reports readiness; approval, feature pauses, platform consent and platform-specific restrictions still apply.

This reference covers the implemented publishing API, not advertising campaigns, direct-message campaigns, Shopify article management or voice operations.

## Authentication and scope

Send these headers on JSON mutations:

```http
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
Idempotency-Key: crm-article-847-v1
```

The documentation page, raw Markdown and OpenAPI document are public on verified hosts and need no API key. All other public API endpoints require bearer authentication; browser login cookies do not authenticate them. Use HTTPS on the verified application host. The central application host can serve the key's full authorized scope; an agency domain further limits business access to that agency's descendants.

| Key owner | Available business scope |
| --- | --- |
| Super Admin / platform | Explicit selected roots or opted-in descendants |
| Agency | Selected descendant Accounts or subtrees; optionally all current/future descendants |
| Group | Selected descendant Accounts; optionally all current/future descendants |
| Account | Permanently restricted to that one Account |

An explicit subtree includes future Accounts inside it; selecting an individual Account does not include new siblings. Integrations may also restrict exact Connection IDs. The `accountId` field is required even with an Account-owned key and must equal that key's Account. Keys cannot manage another integration's posts.

| Scope | Operations |
| --- | --- |
| `discovery.read` | Accounts, Connections and capabilities |
| `posts.read` | Post and batch status |
| `posts.write` | Validate, create and edit post inputs |
| `posts.publish` | Non-draft delivery, submit and unpublish; also required for retries and published edits |
| `posts.cancel` | Cancellation, including cancellation needed for external rescheduling |
| `posts.retry` | Retry confirmed failed deliveries |
| `media.read` | Read media readiness |
| `media.write` | Upload/import media, including URLs and uninspected attachments used by posts |
| `webhooks.manage` | Register, list, disable and replay outgoing webhooks |

Generate and manage keys through the authenticated administration UI; public bearer keys cannot grant themselves additional permissions. Secrets are displayed once and stored hashed. Rotate by creating a replacement key, updating the CRM, and revoking the old key. Expired/revoked keys cannot authenticate. Revocation does not cancel previously accepted work. Disabling the integration blocks pending execution, but cannot recall work already accepted by a platform.

Trusted publishing is an explicit administrator exception to independent human review. It does not bypass scope, connection health, media inspection or feature gates. Human edits remove the exception for that revision.

## Discover Accounts, Connections and capabilities

All paths below are relative to `https://usecloudconnect.com/api/v1`.

| Method | Path | Result |
| --- | --- | --- |
| GET | `/accounts` | `{data:[{id,name,timezone}],nextCursor}` |
| GET | `/accounts/{accountId}/connections` | `{data:[{id,name,platform,status}],nextCursor}` |
| GET | `/accounts/{accountId}/connections/{connectionId}/capabilities` | Platform, formats, limits, options schema, operation support and readiness |

List endpoints accept `limit` (1–100) and `cursor`. Send the returned `nextCursor` unchanged to retrieve the next page; null means the end. Removed/disconnecting Connections are excluded. Use healthy Connections for delivery.

Capabilities contain `platform`, `formats`, `textLimit`, `maxMedia`, `platformOptionsSchema`, `operations`, and `readiness`. A readiness entry is `{format,enabled,liveVerified}`; entries include lifecycle actions as well as formats. Both readiness booleans must be true before execution can pass that gate. A global publishing pause can still prevent execution. The platform schema constrains only that platform's options; wrap them inside `platformOptions[platform]` in a post.

## Batch publishing and validation

`POST /post-batches/validate` validates the batch without creating posts or importing URLs. No idempotency header is required. HTTP 200 can contain per-item errors; inspect every item. `mediaInspectionPending:true` means this is not a media inspection or live-publication check.

`POST /post-batches` accepts one business per request, up to **100 items**, and at most **2 MiB of JSON**. An `Idempotency-Key` of 8–200 characters is required. Each item targets one Connection and has its own content, media, options and delivery. Use multiple items for multiple Connections, or multiple posts on one Connection. Submit separate batches for different Accounts.

Example containing distinct Facebook and Instagram drafts (replace both destination IDs):

```json
{
  "accountId": "11111111-1111-4111-8111-111111111111",
  "externalReference": "crm-article-847",
  "items": [
    {
      "clientReference": "article-847-facebook",
      "connectionId": "22222222-2222-4222-8222-222222222222",
      "title": "Our latest article",
      "format": "text",
      "content": "A summary written for Facebook.",
      "delivery": {
        "mode": "draft"
      }
    },
    {
      "clientReference": "article-847-instagram",
      "connectionId": "33333333-3333-4333-8333-333333333333",
      "format": "image",
      "content": "An Instagram-specific caption.",
      "media": [
        {
          "url": "https://YOUR_MEDIA_HOST/article-847.jpg",
          "altText": "Describe the actual image."
        }
      ],
      "delivery": {
        "mode": "draft"
      }
    }
  ]
}
```

| Post field | Meaning |
| --- | --- |
| `clientReference` | Required, 1–200 characters, unique within this integration and Account |
| `connectionId` | Required application Connection UUID |
| `title` | Optional internal title, up to 200 characters; use required platform title options separately |
| `format` | Required supported format from capabilities |
| `content` | Caption/text, default empty; platform and format requirements apply |
| `linkUrl` | HTTPS link required for link format; appended to the caption |
| `media` | Array of `{id,altText?}` or `{url,altText?}`; exactly one of id/url per attachment |
| `delivery` | Required draft, now, or scheduled object |
| `platformOptions` | Optional object keyed by the Connection's exact platform identifier |

Text and link formats require nonempty content. Image, video, reel, story, document and GIF formats require exactly one attachment. Carousel requires at least two. Text/link/thread formats do not accept top-level attachments; thread media belongs in supported thread options. Media count, text and alt-text limits vary by platform. Unknown fields and mismatched platform options are rejected.

Valid items are accepted independently. If any succeeds the response is HTTP 202; if none succeeds it is HTTP 422. Authorization/business-scope failure accepts nothing. Example mixed result:

```json
{
  "id": "44444444-4444-4444-8444-444444444444",
  "items": [
    {
      "index": 0,
      "clientReference": "article-847-facebook",
      "postId": "55555555-5555-4555-8555-555555555555",
      "status": "draft"
    },
    {
      "index": 1,
      "clientReference": "article-847-instagram",
      "error": {
        "code": "INVALID_CONTENT",
        "message": "Media is required for this format."
      }
    }
  ]
}
```

Persist every accepted `postId`. Correct and resubmit only rejected items with a new request key. Do not resend accepted items in a fresh batch.

## Delivery, scheduling and approvals

Choose one delivery object:

```json
{
  "mode": "draft"
}
```
```json
{
  "mode": "now"
}
```
```json
{
  "mode": "scheduled",
  "scheduledAt": "2030-01-15T09:00:00-07:00"
}
```

Replace the example schedule with a future ISO 8601 timestamp including Z or an explicit UTC offset. A timezone name alone is insufficient; resolve the intended business-local time and daylight-saving offset in the CRM. UTC instants are stored for execution.

Drafts do not dispatch. `now` queues asynchronous delivery and may wait for media or approval; it does not promise publication before the HTTP response. Long-range schedules remain local and are submitted within a rolling 24-hour window. If a schedule passes before submission, execution blocks with `SCHEDULE_MISSED`; explicitly reschedule or request now.

Business approval policies require a different authorized reviewer. Reviews bind to content, media, destination, options and schedule; material edits require fresh review. Media inspection must finish before approval. Use Content in the business workspace for human review. There is no public approval-bypass endpoint.

## Post status and lifecycle endpoints

| Method | Path | Request / result |
| --- | --- | --- |
| GET | `/post-batches/{batchId}` | Original item outcomes plus current `posts` records |
| GET | `/accounts/{accountId}/posts` | `{data:[post],nextCursor}`; filters: `status`, `clientReference`; limit defaults to 50 |
| GET | `/posts/{postId}` | Current post record |
| PATCH | `/posts/{postId}` | `{version,post:completePostInput}` |
| POST | `/posts/{postId}/submit` | `{version}`; submit eligible draft/approved/blocked work |
| POST | `/posts/{postId}/cancel` | `{version}`; cancel eligible local or scheduled work |
| POST | `/posts/{postId}/retry` | `{version}`; retry eligible failed/blocked work |
| POST | `/posts/{postId}/unpublish` | `{version}`; remove published content where supported |

Every mutation above requires an idempotency key. Read the latest `version` first; stale versions return 409. Successful mutation responses are post records, and may describe queued lifecycle work rather than completed external actions.

A public post contains `id`, `accountId`, `connectionId`, `clientReference`, `status`, `version`, normalized `input`, nullable `platformPostUrl`, nullable `errorCode`, `createdAt`, and `updatedAt`. Imported URLs in top-level media become stored media IDs. GET a batch returns `{id,accountId,externalReference,items,posts}`.

PATCH replaces the full input; clientReference and connectionId must stay the same. Before submission, content and schedules can be changed. For an externally scheduled post, revision first confirms cancellation and then queues the replacement. That operation needs cancellation permission too. Published PATCH changes **content only** on supported platforms; media, title, schedule and other fields remain identical. It requires publishing permission and fresh approval unless trusted. Platform edit windows, account requirements and text limits still apply. A rejected edit preserves the previously published content and exposes its error.

Unpublishing and retry availability are platform-specific and independently gated. A retry requires a confirmed failed destination; it cannot bypass uncertain execution. Cancellation and unpublishing are distinct: deleting an already published post requires the unpublish endpoint.

| Status | Meaning / next action |
| --- | --- |
| draft | Editable, no dispatch until submitted |
| pending_approval | Await independent review in Content |
| processing | Waiting for media or a retryable preparation condition |
| queued / scheduled | Waiting for dispatch or scheduled time |
| publishing | External publication in flight; do not duplicate |
| published | Publication confirmed; inspect platformPostUrl if supplied |
| uncertain | Outcome unknown; reconcile by polling, never blindly resend |
| blocked | Resolve errorCode, then explicitly retry/reschedule as appropriate |
| failed | Confirmed failure; inspect errorCode before retrying |
| cancelled | Cancellation or supported unpublishing completed |
| revising / cancelling / retrying / unpublishing / editing | Lifecycle operation in progress |
| pending_edit_approval | Published-content revision awaits independent review |

A batch's accepted-item response is an immutable receipt. GET status is authoritative for later changes. Poll with reasonable backoff and respect rate limits.

## Media uploads and URL imports

Media stays within its Account. Use HTTPS URL imports or upload directly to the returned signed storage URLs. Do not place binary data or base64 files inside a JSON batch. Supported upload types: image/jpeg, image/png, image/webp, image/gif, video/mp4, video/quicktime, application/pdf. Maximum file size is **1 GiB**.

**Single upload**

1. POST `/accounts/{accountId}/media/uploads` with `{name,contentType,bytes}`. HTTP 201 returns `{id,url}`.
2. PUT exactly those bytes to the returned URL using matching Content-Type and Content-Length. Do not attach your API bearer key to storage requests. The signature lasts 10 minutes.
3. POST `/accounts/{accountId}/media/uploads/{mediaId}/complete` with `{}`.
4. Poll GET `/accounts/{accountId}/media/{mediaId}` until `status:ready`, then use its ID in post media.

**Multipart upload**

Set `multipart:true` on upload creation. The response is `{id,partSize,parts:[{partNumber,url}]}`, using 16 MiB parts with signatures valid for one hour. Upload each part and retain its ETag. Complete with:

```json
{
  "parts": [
    {
      "partNumber": 1,
      "etag": "ETAG_RETURNED_BY_STORAGE"
    }
  ]
}
```

**URL import**

POST `/accounts/{accountId}/media/imports` with an idempotency key and `{url,name?}`. HTTP 202 returns `{id,status:processing}`. A post can also use `media:[{url:...}]` directly; accepted URLs are imported asynchronously, even for drafts.

Source URLs must be public HTTPS, without embedded credentials, and return a valid Content-Length. Private/reserved IPs, unsafe redirects, files over 1 GiB, unsupported signatures and failed downloads are rejected. Downloads have a five-minute deadline. Some public URLs without Content-Length are therefore unsuitable; use direct upload instead.

GET media returns `{id,name,content_type,bytes,status,metadata}`; bytes may be serialized as a string. Metadata includes inspected dimensions/duration/codec, or PDF page information. Treat completion receipts as provisional and use GET for readiness. Failed or expired media cannot publish.

Files are inspected and copied to separate immutable publishing objects. An unexpired upload URL cannot replace approved media. Advanced platform media URLs are also captured. Storage allowance is reserved before ingestion; already stored files consume storage even if a post is cancelled. Temporary uploads and failed imports are cleaned up. Platform-specific dimensions, codecs, size limits and live acceptance still matter.

## Outgoing webhooks

All endpoint operations require `webhooks.manage`.

| Method | Path | Behavior |
| --- | --- | --- |
| POST | `/webhook-endpoints` | `{url}` registers public HTTPS endpoint; returns `{id,url,secret}` once |
| GET | `/webhook-endpoints` | Array of `{id,url,enabled,created_at}` |
| GET | `/webhook-endpoints/{endpointId}` | Up to 100 recent deliveries as an array |
| DELETE | `/webhook-endpoints/{endpointId}` | Disable endpoint; returns `{ok:true}` |
| POST | `/webhook-endpoints/{endpointId}` | `{deliveryId}` requests replay; returns `{ok:true}` |

Save the signing secret at creation. It is distinct from the API key. Delivery history exposes `id,event_id,status,attempts,last_status,available_at`. Use the delivery's `id` for replay, not its `event_id`. Replay does not create another social post.

Events have `id`, `createdAt`, and `type`:

- `post.accepted`: postId, batchId, clientReference, status.
- `post.status_changed`: a public `post` record.
- `batch.completed`: batchId, when all accepted items are in a terminal state. This can include failures or blocked items; it does not mean all items published.

Verify `X-Webhook-Signature` as `v1=` followed by hex HMAC-SHA256 over the exact bytes of `X-Webhook-Timestamp + '.' + rawRequestBody`. Use a constant-time comparison, reject timestamps outside five minutes, and persist/deduplicate `X-Webhook-Id` before acknowledging with 2xx. Do not parse and reserialize JSON before verifying its signature.

Events may repeat or arrive out of order. Retrieve current post state when needed. Delivery retries use exponential backoff for 72 hours, then mark the delivery failed; administrators may replay it. A disabled integration or removed scope prevents delivery outside its authorized businesses. Private-network URLs and redirects are not valid webhook destinations.

## Idempotency, rate limits and error handling

Keep a stable idempotency key for one logical batch, post mutation, or media import. Reuse that key with the identical payload after a timeout or lost HTTP response. Reusing it for different content returns `IDEMPOTENCY_CONFLICT` (409). A new key does not bypass clientReference uniqueness; an already accepted reference returns a per-item `REFERENCE_EXISTS` error. Keys are 8–200 characters.

Default limits: 120 requests/minute per integration and 600/minute per owning entity. Read `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset` (Unix seconds), and `Retry-After` on 429. Limits are independent of free beta billing. `X-Request-Id` identifies requests for support.

Top-level errors use this envelope:

```json
{
  "error": {
    "code": "VERSION_CONFLICT",
    "message": "Post changed; reload its current version."
  },
  "requestId": "REQUEST_UUID"
}
```

Validation may additionally include `error.fields:[{path,message}]`. Batch item errors are nested inside `items[index].error` instead. Inspect both HTTP status and every item result.

| HTTP / code | Caller action |
| --- | --- |
| 401 UNAUTHENTICATED | Supply a valid, unexpired bearer key |
| 403 SCOPE_REQUIRED / INTEGRATION_DISABLED | Ask an authorized admin to review access |
| 404 NOT_FOUND | Rediscover IDs and scope; do not guess another business's IDs |
| 409 VERSION_CONFLICT | GET the current post before making a new decision |
| 409 IDEMPOTENCY_CONFLICT | Restore the original body/key pair; a new logical request needs a new key |
| 413 BODY_TOO_LARGE | Reduce JSON below 2 MiB; upload binary media separately |
| 415 CONTENT_TYPE_REQUIRED | Send application/json on JSON mutations |
| 422 INVALID_CONTENT / INVALID_PLATFORM_OPTIONS / VALIDATION_ERROR | Correct the indicated content or fields |
| 429 RATE_LIMITED | Wait for Retry-After; preserve the original mutation key and body |
| 500 INTERNAL_ERROR / transport timeout | Retry the same logical request with the same key, then inspect status |

Async post errorCode can include APPROVAL_REQUIRED, CONTRACT_UNVERIFIED, PUBLISHING_PAUSED, CONNECTION_UNHEALTHY, SCHEDULE_MISSED, MEDIA_PENDING, MEDIA_FAILED or PLATFORM_REJECTED. These are not proof of successful publication. An uncertain external operation must be reconciled rather than force-retried.

## cURL and agent integration example

Set `API_BASE` to the full base URL (including /api/v1) and `API_KEY` to a server-side secret. This example creates a draft only:

```bash
export API_BASE="https://usecloudconnect.com/api/v1"
# Load API_KEY from your secret store; do not commit it.
curl "$API_BASE/post-batches" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: article-847-facebook-v1" \
  --data '{"accountId":"11111111-1111-4111-8111-111111111111","items":[{"clientReference":"article-847-facebook","connectionId":"22222222-2222-4222-8222-222222222222","title":"Our latest article","format":"text","content":"A summary written for Facebook.","delivery":{"mode":"draft"}}]}'
```

Server-side TypeScript:

```typescript
const base = process.env.API_BASE!; // includes /api/v1
const key = process.env.API_KEY!;
// Persist this key and the exact payload before the first send.
const requestKey = "article-847-facebook-v1";
const payload = {
  "accountId": "11111111-1111-4111-8111-111111111111",
  "items": [
    {
      "clientReference": "article-847-facebook",
      "connectionId": "22222222-2222-4222-8222-222222222222",
      "title": "Our latest article",
      "format": "text",
      "content": "A summary written for Facebook.",
      "delivery": {
        "mode": "draft"
      }
    }
  ]
};
const response = await fetch(base + "/post-batches", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + key,
    "Content-Type": "application/json",
    "Idempotency-Key": requestKey,
  },
  body: JSON.stringify(payload),
});
const result = await response.json();
if (!response.ok && response.status !== 422) throw new Error(result.error?.message || "Request failed");
for (const item of result.items || []) {
  if (item.postId) {
    // Persist postId; GET /posts/{postId} for its current state.
  } else {
    // Store the per-item error; correct only the rejected item.
  }
}
```

Recommended CRM mapping: article ID → batch externalReference; article ID + destination + revision → clientReference; application Connection ID → destination; desired local business time → explicit-offset scheduledAt. Store each postId separately. An article destined for five Connections is five independent items with five client references.

## Platform formats and options

This is the implemented format catalog, not a claim of live readiness. Always query the Connection's capabilities at runtime.

| Platform identifier | Formats | Text limit | Maximum attachments |
| --- | --- | --- | --- |
| twitter | text, link, image, carousel, video, thread, poll, article, gif | 280 | 4 |
| threads | text, link, image, carousel, video, thread | 500 | 20 |
| facebook | text, link, image, carousel, video, reel, story | 63206 | 10 |
| instagram | image, carousel, video, reel, story | 2200 | 10 |
| linkedin | text, link, image, carousel, video, document, poll, reshare | 3000 | 20 |
| pinterest | image, video | 500 | 1 |
| youtube | video | 5000 | 1 |
| googlebusiness | text, link, image | 1500 | 1 |
| tiktok | video, carousel | 2200 | 35 |
| telegram | text, link, image, carousel, video | 4096 | 10 |
| snapchat | image, video, story | 5000 | 1 |
| reddit | text, link, image, carousel, video | 40000 | 1 |
| bluesky | text, link, image, carousel, video, thread | 300 | 4 |
| discord | text, link, image, carousel, video, poll | 2000 | 10 |
| slack | text, link, image, carousel, video | 4000 | 10 |

YouTube video options require title, visibility and madeForKids. TikTok requires privacyLevel and explicit contentPreviewConfirmed / expressConsentGiven values of true after the actual preview/consent step. Pinterest requires boardId. Reddit requires subreddit and title. Thread format requires threadItems. Poll, article and reshare formats require their matching options. Instagram placement must agree with the format. Account/profile/channel routing IDs cannot be overridden inside platform options.

Example YouTube options (alongside video format and one inspected video attachment):

```json
{
  "platformOptions": {
    "youtube": {
      "title": "Your video title",
      "visibility": "private",
      "madeForKids": false
    }
  }
}
```

The schema appendix below contains the exact supported option properties and enums. Resolve the schema name through its platforms map and the shared $defs. Do not send the catalog wrapper itself in a post.

## Platform option schemas

```json
{
  "platforms": {
    "twitter": "TwitterPlatformData",
    "threads": "ThreadsPlatformData",
    "facebook": "FacebookPlatformData",
    "instagram": "InstagramPlatformData",
    "linkedin": "LinkedInPlatformData",
    "pinterest": "PinterestPlatformData",
    "youtube": "YouTubePlatformData",
    "googlebusiness": "GoogleBusinessPlatformData",
    "tiktok": "TikTokPlatformData",
    "telegram": "TelegramPlatformData",
    "snapchat": "SnapchatPlatformData",
    "reddit": "RedditPlatformData",
    "bluesky": "BlueskyPlatformData",
    "discord": "DiscordPlatformData",
    "slack": "SlackPlatformData"
  },
  "$defs": {
    "TwitterPlatformData": {
      "type": "object",
      "properties": {
        "article": {
          "$ref": "#/$defs/XArticle"
        },
        "replyToTweetId": {
          "type": "string"
        },
        "quoteTweetId": {
          "type": "string"
        },
        "replySettings": {
          "type": "string",
          "enum": [
            "following",
            "mentionedUsers",
            "subscribers",
            "verified"
          ]
        },
        "threadItems": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "content": {
                "type": "string"
              },
              "mediaItems": {
                "type": "array",
                "items": {
                  "$ref": "#/$defs/MediaItem"
                }
              }
            },
            "additionalProperties": false
          }
        },
        "poll": {
          "type": "object",
          "properties": {
            "options": {
              "type": "array",
              "minItems": 2,
              "maxItems": 4,
              "items": {
                "type": "string",
                "minLength": 1,
                "maxLength": 25
              }
            },
            "duration_minutes": {
              "type": "integer",
              "minimum": 5,
              "maximum": 10080
            }
          },
          "required": [
            "options",
            "duration_minutes"
          ],
          "additionalProperties": false
        },
        "longVideo": {
          "type": "boolean"
        },
        "geoRestriction": {
          "$ref": "#/$defs/GeoRestriction"
        },
        "paidPartnership": {
          "type": "boolean"
        },
        "madeWithAi": {
          "type": "boolean"
        },
        "sensitiveMedia": {
          "type": "object",
          "properties": {
            "adultContent": {
              "type": "boolean"
            },
            "graphicViolence": {
              "type": "boolean"
            },
            "other": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    "XArticle": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "title",
        "content_state"
      ],
      "properties": {
        "title": {
          "type": "string",
          "minLength": 1
        },
        "content_state": {
          "$ref": "#/$defs/XArticleContentState"
        },
        "mode": {
          "type": "string",
          "enum": [
            "publish",
            "draft"
          ]
        },
        "cover": {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "url"
          ],
          "properties": {
            "url": {
              "type": "string",
              "format": "uri",
              "pattern": "^https?://.+\\.(?:[jJ][pP][eE]?[gG]|[pP][nN][gG]|[wW][eE][bB][pP])(?:[?#].*)?$"
            },
            "altText": {
              "type": "string",
              "maxLength": 1000
            }
          }
        }
      }
    },
    "XArticleContentState": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "blocks",
        "entities"
      ],
      "properties": {
        "blocks": {
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/$defs/XArticleBlock"
          }
        },
        "entities": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/XArticleEntity"
          }
        }
      }
    },
    "XArticleBlock": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "type",
        "text"
      ],
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "unstyled",
            "header-one",
            "header-two",
            "header-three",
            "unordered-list-item",
            "ordered-list-item",
            "blockquote",
            "atomic"
          ]
        },
        "text": {
          "type": "string"
        },
        "key": {
          "type": "string",
          "minLength": 1
        },
        "data": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "cashtags": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/XArticleTextRange"
              }
            },
            "hashtags": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/XArticleTextRange"
              }
            },
            "mentions": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/XArticleTextRange"
              }
            },
            "urls": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/XArticleTextRange"
              }
            }
          }
        },
        "inline_style_ranges": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/XArticleInlineStyleRange"
          }
        },
        "entity_ranges": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/XArticleEntityRange"
          }
        }
      }
    },
    "XArticleTextRange": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "from_index",
        "to_index",
        "text"
      ],
      "properties": {
        "from_index": {
          "type": "integer",
          "minimum": 0
        },
        "to_index": {
          "type": "integer",
          "minimum": 0
        },
        "text": {
          "type": "string"
        }
      }
    },
    "XArticleInlineStyleRange": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "offset",
        "length",
        "style"
      ],
      "properties": {
        "offset": {
          "type": "integer",
          "minimum": 0
        },
        "length": {
          "type": "integer",
          "minimum": 0
        },
        "style": {
          "type": "string",
          "enum": [
            "bold",
            "italic",
            "strikethrough"
          ]
        }
      }
    },
    "XArticleEntityRange": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "key",
        "offset",
        "length"
      ],
      "properties": {
        "key": {
          "type": "integer",
          "minimum": 0
        },
        "offset": {
          "type": "integer",
          "minimum": 0
        },
        "length": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "XArticleEntity": {
      "oneOf": [
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "const": "post"
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "post_id"
                  ],
                  "properties": {
                    "post_id": {
                      "type": "string",
                      "minLength": 1
                    }
                  }
                }
              }
            }
          }
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "const": "link"
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string",
                      "format": "uri"
                    }
                  }
                }
              }
            }
          }
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "const": "image"
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string",
                      "format": "uri",
                      "pattern": "^https?://.+\\.(?:[jJ][pP][eE]?[gG]|[pP][nN][gG]|[wW][eE][bB][pP]|[gG][iI][fF]|[mM][pP]4)(?:[?#].*)?$"
                    },
                    "caption": {
                      "type": "string"
                    },
                    "altText": {
                      "type": "string",
                      "maxLength": 1000
                    }
                  }
                }
              }
            }
          }
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "const": "emoji"
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "entity_key"
                  ],
                  "properties": {
                    "entity_key": {
                      "type": "string",
                      "minLength": 1
                    }
                  }
                }
              }
            }
          }
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "const": "markdown"
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "markdown"
                  ],
                  "properties": {
                    "markdown": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "key",
            "value"
          ],
          "properties": {
            "key": {
              "type": "string",
              "minLength": 1
            },
            "value": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "type",
                "mutability",
                "data"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "divider",
                    "latex"
                  ]
                },
                "mutability": {
                  "type": "string",
                  "enum": [
                    "immutable",
                    "mutable",
                    "segmented"
                  ]
                },
                "data": {
                  "type": "object",
                  "additionalProperties": false
                }
              }
            }
          }
        }
      ]
    },
    "MediaItem": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "image",
            "video",
            "gif",
            "document"
          ]
        },
        "url": {
          "type": "string",
          "format": "uri"
        },
        "title": {
          "type": "string"
        },
        "altText": {
          "type": "string"
        },
        "filename": {
          "type": "string"
        },
        "size": {
          "type": "integer"
        },
        "mimeType": {
          "type": "string"
        },
        "thumbnail": {
          "type": "string",
          "format": "uri"
        },
        "instagramThumbnail": {
          "type": "string",
          "format": "uri"
        },
        "tiktokProcessed": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "GeoRestriction": {
      "type": "object",
      "properties": {
        "countries": {
          "type": "array",
          "minItems": 1,
          "maxItems": 25,
          "items": {
            "type": "string",
            "pattern": "^[A-Z]{2}$"
          }
        }
      },
      "required": [
        "countries"
      ],
      "additionalProperties": false
    },
    "ThreadsPlatformData": {
      "type": "object",
      "properties": {
        "topic_tag": {
          "type": "string",
          "minLength": 1,
          "maxLength": 50
        },
        "firstComment": {
          "type": "string",
          "maxLength": 500
        },
        "threadItems": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "content": {
                "type": "string"
              },
              "mediaItems": {
                "type": "array",
                "items": {
                  "$ref": "#/$defs/MediaItem"
                }
              }
            },
            "additionalProperties": false
          }
        }
      },
      "additionalProperties": false
    },
    "FacebookPlatformData": {
      "type": "object",
      "properties": {
        "contentType": {
          "type": "string",
          "enum": [
            "story",
            "reel"
          ]
        },
        "title": {
          "type": "string"
        },
        "firstComment": {
          "type": "string"
        },
        "geoRestriction": {
          "$ref": "#/$defs/GeoRestriction"
        },
        "facebookSettings": {
          "$ref": "#/$defs/FacebookSettings"
        }
      },
      "additionalProperties": false
    },
    "FacebookSettings": {
      "type": "object",
      "properties": {
        "draft": {
          "type": "boolean"
        },
        "carouselCards": {
          "type": "array",
          "minItems": 2,
          "maxItems": 10,
          "items": {
            "type": "object",
            "required": [
              "link"
            ],
            "properties": {
              "link": {
                "type": "string",
                "format": "uri"
              },
              "name": {
                "type": "string",
                "maxLength": 255
              },
              "description": {
                "type": "string",
                "maxLength": 255
              }
            },
            "additionalProperties": false
          }
        },
        "carouselLink": {
          "type": "string",
          "format": "uri"
        },
        "textFormatPresetId": {
          "type": "string",
          "pattern": "^\\d+$"
        }
      },
      "additionalProperties": false
    },
    "InstagramPlatformData": {
      "type": "object",
      "properties": {
        "contentType": {
          "type": "string",
          "enum": [
            "story"
          ]
        },
        "shareToFeed": {
          "type": "boolean"
        },
        "collaborators": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "firstComment": {
          "type": "string"
        },
        "trialParams": {
          "type": "object",
          "properties": {
            "graduationStrategy": {
              "type": "string",
              "enum": [
                "MANUAL",
                "SS_PERFORMANCE"
              ]
            }
          },
          "additionalProperties": false
        },
        "userTags": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "username"
            ],
            "properties": {
              "username": {
                "type": "string"
              },
              "x": {
                "type": "number",
                "minimum": 0,
                "maximum": 1
              },
              "y": {
                "type": "number",
                "minimum": 0,
                "maximum": 1
              },
              "mediaIndex": {
                "type": "integer",
                "minimum": 0
              }
            },
            "additionalProperties": false
          }
        },
        "audioName": {
          "type": "string"
        },
        "audioConfiguration": {
          "type": "object",
          "required": [
            "audioId"
          ],
          "properties": {
            "audioId": {
              "type": "string"
            },
            "audioVolume": {
              "type": "integer",
              "minimum": 0,
              "maximum": 100
            },
            "videoVolume": {
              "type": "integer",
              "minimum": 0,
              "maximum": 100
            }
          },
          "additionalProperties": false
        },
        "muteAudio": {
          "type": "boolean"
        },
        "thumbOffset": {
          "type": "integer",
          "minimum": 0
        },
        "instagramThumbnail": {
          "type": "string",
          "format": "uri"
        },
        "reelCover": {
          "type": "string",
          "format": "uri"
        },
        "isAiGenerated": {
          "type": "boolean"
        },
        "isPaidPartnership": {
          "type": "boolean"
        },
        "brandedContentSponsors": {
          "type": "array",
          "maxItems": 2,
          "items": {
            "type": "string"
          }
        },
        "commentsEnabled": {
          "type": "boolean"
        },
        "locationId": {
          "type": "string",
          "pattern": "^[0-9]+$"
        },
        "placement": {
          "type": "string",
          "enum": [
            "feed",
            "reel",
            "story"
          ]
        }
      },
      "additionalProperties": false
    },
    "LinkedInPlatformData": {
      "type": "object",
      "properties": {
        "documentTitle": {
          "type": "string"
        },
        "firstComment": {
          "type": "string"
        },
        "disableLinkPreview": {
          "type": "boolean"
        },
        "reshareUrl": {
          "type": "string"
        },
        "geoRestriction": {
          "$ref": "#/$defs/GeoRestriction"
        },
        "poll": {
          "type": "object",
          "properties": {
            "question": {
              "type": "string",
              "minLength": 1,
              "maxLength": 140
            },
            "options": {
              "type": "array",
              "minItems": 2,
              "maxItems": 4,
              "items": {
                "type": "string",
                "minLength": 1,
                "maxLength": 30
              }
            },
            "duration": {
              "type": "string",
              "enum": [
                "ONE_DAY",
                "THREE_DAYS",
                "SEVEN_DAYS",
                "FOURTEEN_DAYS"
              ]
            }
          },
          "required": [
            "question",
            "options"
          ],
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    "PinterestPlatformData": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "maxLength": 100
        },
        "boardId": {
          "type": "string"
        },
        "boardSectionId": {
          "type": "string"
        },
        "link": {
          "type": "string",
          "format": "uri"
        },
        "coverImageUrl": {
          "type": "string",
          "format": "uri"
        },
        "coverImageKeyFrameTime": {
          "type": "integer"
        },
        "isAiGenerated": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "YouTubePlatformData": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "maxLength": 100
        },
        "visibility": {
          "type": "string",
          "enum": [
            "public",
            "private",
            "unlisted"
          ]
        },
        "madeForKids": {
          "type": "boolean"
        },
        "firstComment": {
          "type": "string",
          "maxLength": 10000
        },
        "containsSyntheticMedia": {
          "type": "boolean"
        },
        "categoryId": {
          "type": "string"
        },
        "playlistId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "GoogleBusinessPlatformData": {
      "type": "object",
      "properties": {
        "languageCode": {
          "type": "string"
        },
        "topicType": {
          "type": "string",
          "enum": [
            "STANDARD",
            "EVENT",
            "OFFER"
          ]
        },
        "callToAction": {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "enum": [
                "LEARN_MORE",
                "BOOK",
                "ORDER",
                "SHOP",
                "SIGN_UP",
                "CALL"
              ]
            },
            "url": {
              "type": "string",
              "format": "uri"
            }
          },
          "required": [
            "type",
            "url"
          ],
          "additionalProperties": false
        },
        "event": {
          "type": "object",
          "properties": {
            "title": {
              "type": "string"
            },
            "schedule": {
              "type": "object",
              "properties": {
                "startDate": {
                  "type": "object",
                  "properties": {
                    "year": {
                      "type": "integer"
                    },
                    "month": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 12
                    },
                    "day": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 31
                    }
                  },
                  "required": [
                    "year",
                    "month",
                    "day"
                  ],
                  "additionalProperties": false
                },
                "startTime": {
                  "type": "object",
                  "properties": {
                    "hours": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 23
                    },
                    "minutes": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 59
                    }
                  },
                  "additionalProperties": false
                },
                "endDate": {
                  "type": "object",
                  "properties": {
                    "year": {
                      "type": "integer"
                    },
                    "month": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 12
                    },
                    "day": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 31
                    }
                  },
                  "required": [
                    "year",
                    "month",
                    "day"
                  ],
                  "additionalProperties": false
                },
                "endTime": {
                  "type": "object",
                  "properties": {
                    "hours": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 23
                    },
                    "minutes": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 59
                    }
                  },
                  "additionalProperties": false
                }
              },
              "required": [
                "startDate",
                "endDate"
              ],
              "additionalProperties": false
            }
          },
          "required": [
            "title",
            "schedule"
          ],
          "additionalProperties": false
        },
        "offer": {
          "type": "object",
          "properties": {
            "redeemOnlineUrl": {
              "type": "string",
              "format": "uri"
            },
            "termsConditions": {
              "type": "string"
            },
            "couponCode": {
              "type": "string"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    "TikTokPlatformData": {
      "type": "object",
      "properties": {
        "draft": {
          "type": "boolean"
        },
        "privacyLevel": {
          "type": "string"
        },
        "allowComment": {
          "type": "boolean"
        },
        "allowDuet": {
          "type": "boolean"
        },
        "allowStitch": {
          "type": "boolean"
        },
        "commercialContentType": {
          "type": "string",
          "enum": [
            "none",
            "brand_organic",
            "brand_content"
          ]
        },
        "brandPartnerPromote": {
          "type": "boolean"
        },
        "isBrandOrganicPost": {
          "type": "boolean"
        },
        "contentPreviewConfirmed": {
          "type": "boolean"
        },
        "expressConsentGiven": {
          "type": "boolean"
        },
        "mediaType": {
          "type": "string",
          "enum": [
            "video",
            "photo"
          ]
        },
        "videoCoverTimestampMs": {
          "type": "integer",
          "minimum": 0
        },
        "videoCoverImageUrl": {
          "type": "string",
          "format": "uri"
        },
        "photoCoverIndex": {
          "type": "integer",
          "minimum": 0
        },
        "autoAddMusic": {
          "type": "boolean"
        },
        "videoMadeWithAi": {
          "type": "boolean"
        },
        "description": {
          "type": "string",
          "maxLength": 4000
        }
      },
      "additionalProperties": false
    },
    "TelegramPlatformData": {
      "type": "object",
      "properties": {
        "parseMode": {
          "type": "string",
          "enum": [
            "HTML",
            "Markdown",
            "MarkdownV2"
          ]
        },
        "disableWebPagePreview": {
          "type": "boolean"
        },
        "disableNotification": {
          "type": "boolean"
        },
        "protectContent": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "SnapchatPlatformData": {
      "type": "object",
      "properties": {
        "contentType": {
          "type": "string",
          "enum": [
            "story",
            "saved_story",
            "spotlight"
          ]
        }
      },
      "additionalProperties": false
    },
    "RedditPlatformData": {
      "type": "object",
      "properties": {
        "subreddit": {
          "type": "string"
        },
        "title": {
          "type": "string",
          "maxLength": 300
        },
        "url": {
          "type": "string",
          "format": "uri"
        },
        "forceSelf": {
          "type": "boolean"
        },
        "flairId": {
          "type": "string"
        },
        "flairText": {
          "type": "string"
        },
        "nsfw": {
          "type": "boolean"
        },
        "spoiler": {
          "type": "boolean"
        },
        "sendreplies": {
          "type": "boolean"
        },
        "nativeVideo": {
          "type": "boolean"
        },
        "videogif": {
          "type": "boolean"
        },
        "videoPosterUrl": {
          "type": "string",
          "format": "uri"
        }
      },
      "additionalProperties": false
    },
    "BlueskyPlatformData": {
      "type": "object",
      "properties": {
        "langs": {
          "type": "array",
          "minItems": 1,
          "maxItems": 3,
          "items": {
            "type": "string"
          }
        },
        "threadItems": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "content": {
                "type": "string"
              },
              "mediaItems": {
                "type": "array",
                "items": {
                  "$ref": "#/$defs/MediaItem"
                }
              }
            },
            "additionalProperties": false
          }
        }
      },
      "additionalProperties": false
    },
    "DiscordPlatformData": {
      "type": "object",
      "required": [],
      "properties": {
        "embeds": {
          "type": "array",
          "maxItems": 10,
          "items": {
            "type": "object",
            "properties": {
              "title": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "url": {
                "type": "string"
              },
              "color": {
                "type": "integer"
              },
              "image": {
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "thumbnail": {
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "footer": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "icon_url": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "author": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "url": {
                    "type": "string"
                  },
                  "icon_url": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "fields": {
                "type": "array",
                "maxItems": 25,
                "items": {
                  "type": "object",
                  "required": [
                    "name",
                    "value"
                  ],
                  "properties": {
                    "name": {
                      "type": "string"
                    },
                    "value": {
                      "type": "string"
                    },
                    "inline": {
                      "type": "boolean"
                    }
                  },
                  "additionalProperties": false
                }
              }
            },
            "additionalProperties": false
          }
        },
        "poll": {
          "type": "object",
          "properties": {
            "question": {
              "type": "object",
              "required": [
                "text"
              ],
              "properties": {
                "text": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            },
            "answers": {
              "type": "array",
              "maxItems": 10,
              "items": {
                "type": "object",
                "properties": {
                  "poll_media": {
                    "type": "object",
                    "properties": {
                      "text": {
                        "type": "string"
                      }
                    },
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              }
            },
            "duration": {
              "type": "integer",
              "minimum": 1,
              "maximum": 768
            },
            "allow_multiselect": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        },
        "crosspost": {
          "type": "boolean"
        },
        "forumThreadName": {
          "type": "string"
        },
        "forumAppliedTags": {
          "type": "array",
          "maxItems": 5,
          "items": {
            "type": "string"
          }
        },
        "threadFromMessage": {
          "type": "object",
          "properties": {
            "name": {
              "type": "string"
            },
            "autoArchiveDuration": {
              "type": "integer",
              "enum": [
                60,
                1440,
                4320,
                10080
              ]
            },
            "rateLimitPerUser": {
              "type": "integer",
              "minimum": 0,
              "maximum": 21600
            }
          },
          "additionalProperties": false
        },
        "tts": {
          "type": "boolean"
        },
        "webhookUsername": {
          "type": "string"
        },
        "webhookAvatarUrl": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "SlackPlatformData": {
      "type": "object",
      "properties": {
        "threadTs": {
          "type": "string"
        },
        "unfurlLinks": {
          "type": "boolean"
        },
        "unfurlMedia": {
          "type": "boolean"
        },
        "username": {
          "type": "string"
        },
        "iconUrl": {
          "type": "string"
        }
      },
      "additionalProperties": false
    }
  }
}
```

## Complete OpenAPI specification

Machine-readable download: [OpenAPI JSON](https://usecloudconnect.com/api/v1/openapi.json). Request schemas and endpoint definitions are included here so a copied guide remains self-contained. The operational sections above specify response shapes and runtime restrictions beyond the schema.

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "Workspace Publishing API",
    "version": "1.0.0",
    "description": "Scoped server-to-server publishing for Agencies, Groups and business Accounts. No customer API payment is required during beta."
  },
  "servers": [
    {
      "url": "https://usecloudconnect.com/api/v1"
    }
  ],
  "components": {
    "securitySchemes": {
      "ApiKey": {
        "type": "http",
        "scheme": "bearer"
      }
    },
    "schemas": {
      "PostInput": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "clientReference": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "connectionId": {
            "type": "string",
            "format": "uuid",
            "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
          },
          "title": {
            "type": "string",
            "maxLength": 200
          },
          "format": {
            "type": "string",
            "enum": [
              "text",
              "link",
              "image",
              "carousel",
              "video",
              "reel",
              "story",
              "thread",
              "document",
              "poll",
              "article",
              "reshare",
              "gif"
            ]
          },
          "content": {
            "default": "",
            "type": "string",
            "maxLength": 64000
          },
          "linkUrl": {
            "type": "string",
            "format": "uri",
            "pattern": "^https:\\/\\/.*"
          },
          "media": {
            "default": [],
            "maxItems": 35,
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "format": "uuid",
                  "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
                },
                "url": {
                  "type": "string",
                  "maxLength": 4096,
                  "format": "uri",
                  "pattern": "^https:\\/\\/.*"
                },
                "altText": {
                  "type": "string",
                  "maxLength": 2000
                }
              },
              "additionalProperties": false
            }
          },
          "delivery": {
            "oneOf": [
              {
                "type": "object",
                "properties": {
                  "mode": {
                    "type": "string",
                    "const": "draft"
                  }
                },
                "required": [
                  "mode"
                ],
                "additionalProperties": false
              },
              {
                "type": "object",
                "properties": {
                  "mode": {
                    "type": "string",
                    "const": "now"
                  }
                },
                "required": [
                  "mode"
                ],
                "additionalProperties": false
              },
              {
                "type": "object",
                "properties": {
                  "mode": {
                    "type": "string",
                    "const": "scheduled"
                  },
                  "scheduledAt": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  }
                },
                "required": [
                  "mode",
                  "scheduledAt"
                ],
                "additionalProperties": false
              }
            ]
          },
          "platformOptions": {
            "default": {},
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "required": [
          "clientReference",
          "connectionId",
          "format",
          "content",
          "media",
          "delivery",
          "platformOptions"
        ],
        "additionalProperties": false
      }
    }
  },
  "paths": {
    "/accounts": {
      "get": {
        "summary": "List authorized businesses",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "query",
            "name": "cursor",
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          }
        ]
      }
    },
    "/accounts/{accountId}/connections": {
      "get": {
        "summary": "List connected destinations",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "query",
            "name": "cursor",
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/connections/{connectionId}/capabilities": {
      "get": {
        "summary": "Inspect supported formats and live readiness",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        },
        {
          "in": "path",
          "name": "connectionId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/post-batches": {
      "post": {
        "summary": "Submit up to 100 independent posts",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "accountId",
                  "items"
                ],
                "properties": {
                  "accountId": {
                    "type": "string",
                    "format": "uuid"
                  },
                  "externalReference": {
                    "type": "string"
                  },
                  "items": {
                    "type": "array",
                    "minItems": 1,
                    "maxItems": 100,
                    "items": {
                      "$ref": "#/components/schemas/PostInput"
                    }
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      }
    },
    "/post-batches/validate": {
      "post": {
        "summary": "Validate content without creating posts",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "accountId",
                  "items"
                ],
                "properties": {
                  "accountId": {
                    "type": "string",
                    "format": "uuid"
                  },
                  "items": {
                    "type": "array",
                    "items": {
                      "$ref": "#/components/schemas/PostInput"
                    }
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      }
    },
    "/post-batches/{batchId}": {
      "get": {
        "summary": "Retrieve item outcomes and current post status",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "batchId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/posts": {
      "get": {
        "summary": "List posts with cursor, status and clientReference filters",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "query",
            "name": "cursor",
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          },
          {
            "in": "query",
            "name": "status",
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "clientReference",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/posts/{postId}": {
      "get": {
        "summary": "Inspect a post",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "patch": {
        "summary": "Edit a post or supported published text with optimistic version",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "version",
                  "post"
                ],
                "properties": {
                  "version": {
                    "type": "integer"
                  },
                  "post": {
                    "$ref": "#/components/schemas/PostInput"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "postId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/posts/{postId}/submit": {
      "post": {
        "summary": "submit a post where supported",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "version"
                ],
                "properties": {
                  "version": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "postId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/posts/{postId}/cancel": {
      "post": {
        "summary": "cancel a post where supported",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "version"
                ],
                "properties": {
                  "version": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "postId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/posts/{postId}/retry": {
      "post": {
        "summary": "retry a post where supported",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "version"
                ],
                "properties": {
                  "version": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "postId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/posts/{postId}/unpublish": {
      "post": {
        "summary": "unpublish a post where supported",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "version"
                ],
                "properties": {
                  "version": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "postId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/media/uploads": {
      "post": {
        "summary": "Create signed upload or multipart session",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "name",
                  "contentType",
                  "bytes"
                ],
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "contentType": {
                    "type": "string"
                  },
                  "bytes": {
                    "type": "integer"
                  },
                  "multipart": {
                    "type": "boolean"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/media/uploads/{mediaId}/complete": {
      "post": {
        "summary": "Complete and inspect uploaded media",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        },
        {
          "in": "path",
          "name": "mediaId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/media/imports": {
      "post": {
        "summary": "Import a public HTTPS media URL",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string",
                    "format": "uri"
                  },
                  "name": {
                    "type": "string"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 8,
              "maxLength": 200
            }
          }
        ]
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/accounts/{accountId}/media/{mediaId}": {
      "get": {
        "summary": "Inspect media readiness",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "accountId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        },
        {
          "in": "path",
          "name": "mediaId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    },
    "/webhook-endpoints": {
      "get": {
        "summary": "List webhook endpoints",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "post": {
        "summary": "Create endpoint and reveal signing secret once",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string",
                    "format": "uri"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      }
    },
    "/webhook-endpoints/{endpointId}": {
      "get": {
        "summary": "Inspect latest deliveries",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "delete": {
        "summary": "Disable endpoint",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "post": {
        "summary": "Replay a delivery",
        "security": [
          {
            "ApiKey": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "deliveryId"
                ],
                "properties": {
                  "deliveryId": {
                    "type": "string",
                    "format": "uuid"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "202": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "403": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "409": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "422": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "429": {
            "description": "Operation result. Publication acceptance is asynchronous.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      },
      "parameters": [
        {
          "in": "path",
          "name": "endpointId",
          "required": true,
          "schema": {
            "type": "string",
            "format": "uuid"
          }
        }
      ]
    }
  }
}
```