Skip to content

Content Repurposing API: Repurpose Content Across Every Platform

A content repurposing API helps a developer take a single source item and distribute adapted versions to destinations including Twitter, Instagram, YouTube, TikTok, Facebook, Threads, and Pinterest through one request.

Repurpose a blog post across platforms
curl -X POST {{API_BASE_URL}}/v1/posts \
  -H "x-access-key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "A short example update.",
    "mediaItems": [
      { "url": "https://cdn.example.com/blog-cover.jpg", "type": "image" }
    ],
    "platforms": [
      { "platform": "twitter", "accountId": "acc_tw" },
      { "platform": "instagram", "accountId": "acc_ig" },
      { "platform": "facebook", "accountId": "acc_fb" },
      { "platform": "threads", "accountId": "acc_th" },
      { "platform": "pinterest", "accountId": "acc_pin",
        "platformSpecificData": {
          "boardId": "board_blog",
          "link": "https://example.com/blog/api-first"
        }
      }
    ]
  }'
Illustrative request
Example line 1

curl -X POST {{API_BASE_URL}}/v1/posts \

Illustrative request
Example line 2

-H "x-access-key: your-api-key" \

Illustrative request
Example line 3

-H "Content-Type: application/json" \

Rather than maintaining a separate workflow for each network, you send the content once with multiple platform targets and let cross-platform publishing apply platform-specific adaptation for each destination.

What content repurposing means for cross-platform distribution

Creating content is expensive, and getting value from it means distributing it across every relevant platform in the right format. Content repurposing is the practice of taking a single source item, such as a blog post, and adapting it into a thread, a caption, a post, or an update for each destination. A content repurposing API supports this by accepting one input and multiple outputs: you send the content once, list the platform targets, and the request is delivered to each platform with its formatting and constraints applied.

One input, multiple outputs: field map and worked blog-post example

The workflow has four parts. First, one input with multiple outputs: a single content value is paired with a platforms array, where each entry names a platform and the accountId to publish to. Second, platform-specific adaptation: the same source becomes a Twitter thread, an Instagram caption, a Facebook post, and a Threads update, each adapted per platform. Third, media reuse: media is supplied once through mediaItems and published across platforms, with format compatibility validated for each target. Fourth, staggered publishing: repurposed content can be scheduled at different times per platform, including across time zones, rather than publishing everywhere simultaneously. The field map and worked example below show exactly which fields the captured request uses, and the decision criteria table helps you judge when this pattern fits.

Platform-specific adaptation and media reuse

Platform-specific adaptation is where a single source becomes several native-feeling posts. The source describes the forms illustratively as a Twitter thread, an Instagram caption, a Facebook post, and a Threads update; the exact length, splitting, or pairing rules for each form are not evidenced in the captured example and should not be assumed. The captured example shows how destination-specific requirements are handled without changing the shared content: the Pinterest target adds platformSpecificData with a boardId and a link to the original article, while the other targets rely on platform and accountId alone. Media reuse follows the same principle. The blog cover image appears once in mediaItems as a url with type image, and each target can reuse it, subject to per-platform format compatibility validation. If a format is incompatible with one destination, that target needs a different asset or should be removed from the request, rather than assuming the shared media works everywhere.

Staggered publishing and performance comparison criteria

Staggered publishing means scheduling repurposed content at different times per platform instead of sending every variant at once. The rationale is practical: audiences on different platforms are active at different times, and publishing across time zones can spread reach more evenly than a simultaneous blast. Performance comparison is the feedback loop for this workflow. By tracking which platform variant performs best, you can refine future adaptations, adjust timing, and decide which destinations deserve more effort. Note that the worked example in this guide does not include a scheduling field, so staggered publishing should be implemented through whatever scheduling contract is documented for your implementation, not by guessing a field name from this example.

Failure matrix: format, media, and account-targeting issues

Multi-target requests fail in predictable places, and each failure maps to a specific check. Platform format constraints can reject a variant that is too long or formatted incorrectly for one destination, so review the adapted text per platform before sending. Media compatibility validation can flag a shared asset that one platform cannot accept, so confirm each mediaItems entry against every target. Account targeting errors, such as a wrong or missing accountId, can send content to the wrong account or fail that target, so verify each accountId against the intended account before publishing. Missing platformSpecificData, such as a boardId for a Pinterest target, is another per-platform failure mode. The captured example does not evidence whether a failure on one target affects others, so treat each target as needing its own check and do not assume isolation. The failure matrix below turns these checks into a pre-flight list you can run before every repurposing request.

Field map for the captured POST /v1/posts request
FieldWhere it appearsExample valueNotes
contentRequest body"We just published our guide to API-first development."Shared text sent once for all targets
mediaItemsRequest body[{ "url": "https://cdn.example.com/blog-cover.jpg", "type": "image" }]Media supplied once and reused across targets; each item has url and type
platformsRequest bodyArray of five targetsOne entry per destination platform
platformEach platforms entry"twitter", "instagram", "facebook", "threads", "pinterest"Destination platform name
accountIdEach platforms entry"acc_tw", "acc_ig", "acc_fb", "acc_th", "acc_pin"Account to publish to for that target
platformSpecificDataPinterest platforms entry{ "boardId": "board_blog", "link": "https://example.com/blog/api-first" }Destination-specific fields; only shown on the Pinterest target
boardIdplatformSpecificData"board_blog"Pinterest board identifier in the example
linkplatformSpecificData"https://example.com/blog/api-first"Link to the original blog post in the example

Fields shown are those present in the captured request example; requiredness and response contract are not evidenced in source and are not asserted here.

When one-input multiple-output distribution fits
CriterionOne-input multiple-output distribution fits when...Separate per-platform workflows fit when...
Content sourceOne source item needs variants on several platformsEach platform needs a fundamentally different source or asset
FormattingDifferences are limited to adaptation such as thread, caption, post, and update formsFormatting rules require bespoke logic that cannot be expressed per target
MediaThe same media can be reused after per-platform compatibility validationEach platform requires unique media that cannot be shared
TimingStaggered publishing across platforms and time zones is desiredTiming must be coordinated through a separate scheduling system
MeasurementYou want to compare which platform variant performs bestEach platform is measured and optimized entirely independently

Decision guidance based on the workflow concepts in source; not a claim about any specific implementation's behavior.

Failure matrix for repurposing requests
Failure modeWhat to checkHow to fix it
Platform format constraintsAdapted text length and format for each platform targetShorten or reformat the variant for the affected platform
Media compatibilityEach mediaItems url and type against every target platformReplace the asset for incompatible targets or remove that target
Account targetingEach accountId matches the intended account for its platformCorrect the accountId or reconnect the intended account
Missing platformSpecificDataDestination-specific fields such as boardId and link where requiredAdd the required fields to that target's platformSpecificData
Simultaneous publishingWhether all variants are scheduled for the same momentStagger publish times per platform and time zone

Pre-flight checks derived from the workflow concepts in source; specific error codes, response shapes, and whether one target's failure affects others are not evidenced in source.

Frequently asked questions

How does one input become posts on multiple platforms?

Send one content value and a platforms array with one target per destination. Each target names a platform and an accountId, and may add platformSpecificData where that destination needs extra fields, as the Pinterest example adds boardId and link. The same mediaItems array can be reused across targets.

What should you check before sending a multi-platform request?

Check that every platform target has the correct accountId for the intended account, that platformSpecificData contains any destination-specific fields such as boardId for Pinterest, and that each media item is compatible with every target. Treat a mismatch in any one target as a per-platform issue to investigate; the captured example does not evidence whether one target's failure affects others, so do not assume isolation without a response contract.

Does the worked example include staggered publishing fields?

The captured request example does not show a scheduling field. Staggered publishing is described as a workflow goal of publishing at different times per platform, but you should not assume a field name for it from this example alone; confirm the scheduling contract in the relevant documentation before implementing it.