All features

Developer APIs

Social Media Post API: Generate Humanized, Platform-Native Posts in One Call

Last updated

Every social scheduling tool solves publishing. None of them solve the blank box at the start, where somebody still has to write the post. If you are building a social media product, an agency dashboard, or an AI agent that manages accounts, that gap lands on you. The SpeedContent social media post API closes it with one call: give it a topic and a platform, and it returns a finished post written to that network's conventions, humanized so it does not read as machine-written, scored against an AI detector, and illustrated if you want it to be.

Why use a social media post API?

All social scheduling tools do the publishing for you. You authorise an account, add a post to the queue and, at the correct time, it goes out on whichever networks you like. But none of them address the empty box at the beginning of that flow. Someone still has to write the post.

If you're building a social media product, an agency dashboard, or an AI agent that manages accounts, that's where the gap falls on you. You can hook up a language model and get text out, but raw model output has two problems here. It reads like every other scheduled post in the feed, and it increasingly gets flagged as machine-written by both readers and platform classifiers.

The SpeedContent social media post API fills that space in a single call. Provide a topic and a platform and it returns a finished post written in the style of that network, rewritten so it doesn't sound like a bot produced it, scored by an AI detector, and illustrated with a generated image if you want one.

One call, seven platforms

Generation is multi-stage, so the API is asynchronous. You submit a job, get an ID back immediately, and poll until it finishes. A typical post takes between 20 and 90 seconds depending on length, quantity, and whether you asked for an image.

curl -X POST https://generatecontentwithaiservice-g5zrtckfda-ue.a.run.app/api/v1/social/generate \
  -H "Authorization: Bearer sc_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Why small teams ship faster than big ones",
    "platform": "linkedin",
    "tone": "professional"
  }'

Response:

{
  "job_id": "68d4f1a2c9b17e0012ab34cd",
  "status": "queued",
  "poll_url": "/api/v1/social/jobs/68d4f1a2c9b17e0012ab34cd",
  "estimated_seconds": 23,
  "estimated_credits": 30
}

Poll the poll_url until status reads completed, and the finished post arrives with its hashtags, image URL, and detection score.

Every post is humanized before you see it

What makes this different from wrapping a language model yourself is everything that happens once the first draft exists — and the humanization pass is the heart of it.

Raw model output has a signature. It reaches for the same connectives, settles into a uniform sentence length, and leans on filler like "in today's fast-paced world" and "it's worth noting." Readers notice it even when they can't name it, and classifiers are trained on exactly those patterns.

Every post generated through this API is passed through the same engine behind the AI humanizer API. It restructures the prose rather than swapping synonyms: sentence length and rhythm are varied to produce the burstiness human writing has, filler phrasing is stripped, and overall perplexity is shifted out of the band detectors look for. Your topic, your keywords, and your brand voice survive intact.

This is not an optional extra you call separately afterwards. It runs on every post, on every platform, before the result is ever returned to you.

The result is then scored by an AI detector on a scale where zero reads as human. Platform-appropriate emoji are injected, and suppressed entirely on LinkedIn and YouTube where they read as unprofessional. If the score comes back too high, the post is humanized and scored again automatically.

Each of those steps is a separate service call. Building the same chain yourself means integrating a language model, a humanizing service, a detection service, and an image generator, then coordinating retries between them. Here it's one endpoint.

Why the detection score matters

The detection score is the part worth watching, because it's the only step that tells you something you couldn't otherwise know.

Anyone can attach a prompt to a model. What you can't easily discover is whether the text you're about to publish will read as machine-written to someone else's classifier. The score comes back attached to the post, so your application can decide before anything goes out: publish automatically below a threshold, route higher-scoring posts to a human, or simply show the number to your user and let them judge.

When a post hasn't been scored, the field comes back empty rather than zero. That distinction is bigger than it first appears. Zero means scored and reads as human. Empty means nothing measured it. Returning zero for both would hand you a confident-looking result for a check that never ran.

Platform-native, not one prompt reskinned

Seven platforms are supported, each with its own writing guide and default length.

PlatformDefault lengthEmojiWritten as
LinkedIn100 wordsNoneInsight-led, counter-intuitive hook, reflective close
Facebook75 wordsHeavyConversational, story-led, strong call to action
Instagram50 wordsHeavyCaption-style, visual-first
X (Twitter)40 wordsModerateOne quotable idea, built to be shared
Pinterest75 wordsModerateDescriptive, keyword-aware, inspirational
YouTube150 wordsNoneDescription-style, longer form
TikTok50 wordsHeavyHook-first, trend-aware, casual

These aren't length settings on one shared prompt. They're genuinely different instructions producing genuinely different copy. You can override the word count per request, from 10 to 500, and request up to 10 variations in a single call.

Credits and what you pay for

Pricing is credit-based and you only pay for the steps you use. A post up to 200 words costs 20 credits, with one extra credit per additional 10 words. An image adds 10 credits and AI detection adds 8. The total is multiplied by the number of variations you asked for.

Detection defaults to automatic, meaning it only runs on posts of 150 words or more. Short posts score unreliably, and the detector charges a flat rate regardless of length, so running it on a 40-word post would cost about as much as writing the post and tell you very little. You can force it on or off per request.

Credits are reserved when the job is accepted and refunded in full if generation fails. You're never charged for a post you didn't receive.

For AI agents: the MCP server

The same capability is available to AI agents through a remote server listed in the official Model Context Protocol registry. There's nothing to install.

{
  "mcpServers": {
    "speedcontent-social": {
      "url": "https://speedcontent.online/mcp",
      "headers": { "X-API-Key": "sc_your_api_key" }
    }
  }
}

An agent in Claude, Cursor, or any MCP-compatible client gets five tools, and they split into two jobs.

If the agent has already written the post, score_text tells it how machine-written the copy reads, and humanize_text rewrites it if the score is too high — preserving brand names, domains and any lines you mark as fixed. These are the parts an agent genuinely cannot do for itself, because both call paid external services.

If the agent needs a draft written from scratch, generate_social_post starts a job, check_social_job collects it, and list_social_platforms reports what each network expects.

This complements the publishing tools agents already use — an agent can draft, check it will pass, and publish through whichever scheduling API it's already connected to, without the user leaving the conversation.

Using it from an agent

Once the server is connected an agent sees five tools, and they split on one question: does it already have the words?

If the agent wrote the post itself, the useful tools are the ones that check and repair that writing. If it needs a draft from nothing, the generation tools take over. Pointing an agent at the right half matters more than any individual setting, because the two paths cost different amounts and produce different results.

Check writing the agent already did

score_text is the one thing an agent cannot work out alone, because it means asking an external detector what it thinks.

{ "name": "score_text", "arguments": {
    "text": "Content teams write dozens of social posts every week, then rewrite each one to fit every platform."
}}
AI detection score: 12.0 out of 65 — reads as human-written and should pass.

_Cost: 8 credits._

The scale runs 0 to 65. Zero reads as human, anything above 30 is likely to be flagged, and the reply says which in plain words rather than leaving the agent to interpret a bare number.

Fix it when the score is too high

humanize_text takes the agent's own words and returns them rewritten. The arguments that matter are the protective ones.

{ "name": "humanize_text", "arguments": {
    "text": "Our new analytics dashboard is now live. Try it at northwind.example today.",
    "preserve": ["Try it at northwind.example today."],
    "brand_terms": ["Northwind Analytics"],
    "score_after": true
}}

Rewriting engines split brand names in two, mangle domains, and reword whole lines into something merely adjacent. Anything whose exact wording matters goes in preserve; any name that must stay intact goes in brand_terms. Both are restored after the rewrite. Pricing is one credit per twenty words, plus eight if you ask it to score the result.

Write a post from nothing

generate_social_post returns a job id immediately, because the work runs through several stages and takes longer than a tool call should block for.

{ "name": "generate_social_post", "arguments": {
    "topic": "Why small teams ship faster than big ones",
    "platform": "linkedin",
    "tone": "professional",
    "emoji": false,
    "preserve": ["How is your team shipping this quarter?"],
    "brand_name": "Northwind Analytics"
}}

The draft is scored before it is rewritten, and if it already passes the rewrite is skipped entirely — which keeps the original wording and costs less. Set humanize to true or false to decide that yourself.

Collect the result

{ "name": "check_social_job", "arguments": { "job_id": "68d4f1a2c9b17e0012ab34cd" } }

It reports progress while the job runs and the finished posts once it completes. Free to call, so polling every few seconds is fine.

Look up what a platform expects

{ "name": "list_social_platforms", "arguments": {} }

Every supported platform with its default length and emoji policy. No network call, no cost.

Chaining them

The arrangement that works best puts the agent in charge of the words and this server in charge of checking them.

  1. The agent drafts the post — a modern assistant writes well and that draft costs nothing.
  2. score_text says whether it will pass.
  3. Only if the score is poor does humanize_text run, with preserve protecting the lines that matter.
  4. The result goes out through whichever publishing tool the agent is already connected to, frequently a second MCP server entirely.

What you can build

The most direct use is adding generation to a product that already publishes. If your users schedule posts, they're writing them somewhere else first, usually a chat window they copy out of. Moving that step inside your product removes the copy-paste and gives you a feature your competitors don't have.

Agencies run the same workflow at volume across many client accounts, where brand voice parameters keep each client sounding like themselves. Content teams repurpose a single blog post into a week of platform-specific copy.

Start generating

Create an API key from the API Keys page in the SpeedContent dashboard. Free credits on signup are enough to generate several posts end to end before you commit to anything.

Ready to try Social Media Post API?

Free signups get credits to test Social Media Post API on real keywords before upgrading. No credit card required.

Free credits on signup No credit card 60–90s per article