Publish LinkedIn Posts with the OutFlo Public API and MCP

OutFlo’s Public API lets you run a complete LinkedIn posting workflow from your own application, automation, or agent. You can create and edit drafts, keep a revision history, collect approval, reserve a time, check usage, and publish through an eligible connected LinkedIn account.

If your workflow does not need a separate editorial review, you can also create, approve, and schedule a ready post in one request. Set its scheduled time to now to publish as soon as OutFlo’s delivery queue can process it.

This guide explains both paths and how the same operations are available through the OutFlo MCP server for compatible AI assistants.

Before You Start

You need:

• An OutFlo API key from Integrations & API in your OutFlo workspace.
• An active, connected LinkedIn account in the workspace you want to post from.
• The required posting scopes. New OutFlo API keys receive posts.read, posts.write, posts.approve, and posts.publish by default.
• A publishing workflow that respects your organization’s posting allowance. Free organizations receive 25 successful publications per UTC calendar month; scheduled work reserves capacity before delivery.

The Posting API base URL is:

`https://api.outflo.io/api/public/v1/posting`

Send your key in the `x-api-key` header. If your key is authorized for more than one workspace, send the intended workspace in `x-workspace-id`.

For the full endpoint reference and request schemas, see the LinkedIn Posting API documentation.

Choose Your Publishing Workflow

Both paths preserve OutFlo’s account checks, usage controls, publication history, provider retries, and status visibility. They do not bypass LinkedIn account eligibility.

1. Discover Eligible LinkedIn Accounts

Start by listing the accounts that can be used as a posting target. This prevents an automation from guessing or storing stale account IDs.

curl --request GET \
  --url https://api.outflo.io/api/public/v1/posting/accounts \
  --header "x-api-key: $OUTFLO_API_KEY"

Choose the returned `id` for the `accountId` in later calls. The account must remain active and connected when OutFlo reaches the scheduled time.

You can also inspect your entitlement and current usage:

curl --request GET \
  --url https://api.outflo.io/api/public/v1/posting/entitlement \
  --header "x-api-key: $OUTFLO_API_KEY"

curl --request GET \
  --url https://api.outflo.io/api/public/v1/posting/usage \
  --header "x-api-key: $OUTFLO_API_KEY"

The usage response distinguishes consumed successful publications from reserved pending or scheduled publications. Remaining capacity is calculated after both.

2. Create and Manage a Draft

Use a draft when writing, review, and publishing should remain separate. A post has immutable revisions, so the exact version that gets approved and scheduled is traceable later.

{
  "title": "A clearer view of pipeline health",
  "bodyText": "A short LinkedIn post written by your application.",
  "firstCommentText": "Optional first comment.",
  "editorialState": "DRAFT"
}

Send that body to `POST /posts`. The response contains the post and its current revision. Save the post ID and revision ID in your system.

To edit, call `PATCH /posts/{postId}` with the latest `expectedVersion` (or the returned ETag through `If-Match`). This optimistic-version check prevents one editor or automation from silently overwriting a newer draft.

Useful read endpoints include:

• `GET /posts` for posts and filtered views.
• `GET /posts/{postId}` for the post, current revision, approval, and publication state.
• `GET /posts/{postId}/revisions` to inspect immutable history.
• `POST /posts/{postId}/revisions/{revisionId}/restore` to make an earlier revision current again.
• `GET /calendar` to see scheduled work and unscheduled drafts together.

3. Request and Decide Approval

Request review for the exact current revision:

{
  "revisionId": "CURRENT_REVISION_ID"
}

Send it to `POST /posts/{postId}/approval-requests`. An authorized reviewer can then call one of these endpoints:

• `POST /approval-requests/{requestId}/approve`
• `POST /approval-requests/{requestId}/request-changes`

Add comments and feedback threads through the post comment endpoints when the writer and reviewer need a documented conversation. Changing the content creates a new revision, which means the revised content needs its own approval.

4. Prepare and Commit a Scheduled Publication

For the standard external-client flow, publishing is intentionally two steps. The first call prepares a short-lived OutFlo-issued intent bound to the post revision, account, schedule, workspace, and caller. The second call commits the exact intent after your application has presented or recorded confirmation.

Prepare the publication:

{
  "accountId": "LINKEDIN_ACCOUNT_ID",
  "revisionId": "CURRENT_REVISION_ID",
  "scheduledFor": "2026-08-06T15:30:00.000Z",
  "sourceTimezone": "Asia/Kolkata"
}

Send this to `POST /posts/{postId}/publication-intents`. The response includes `intentId`, `confirmationToken`, an expiry time, and an allowance summary. Before committing, verify that the account, post, revision, and schedule are still exactly what your workflow expects.

Then commit it:

{
  "confirmationToken": "OUTFLO_ISSUED_CONFIRMATION_TOKEN"
}

Send that body to `POST /publication-intents/{intentId}/commit`.

OutFlo generates and manages the idempotency key internally. Do not ask end users to invent one or send an `Idempotency-Key` header. The intent ID is the handle your integration should store for retries, support, and audit trails.

To change an existing publication, use the same prepare-and-commit pattern with the publication action endpoints. They support CANCEL and RESCHEDULE with an expected row version, so a stale client cannot accidentally change a newer schedule.

5. Create, Approve, and Schedule in One Request

For trusted automations, use the direct endpoint:

`POST /publications/direct`

It creates a ready post, records an auditable approval under the API-key owner’s existing administrative authority, and schedules the publication. It requires both posts.write and posts.publish.

curl --request POST \
  --url https://api.outflo.io/api/public/v1/posting/publications/direct \
  --header "Content-Type: application/json" \
  --header "x-api-key: $OUTFLO_API_KEY" \
  --data '{
    "title": "A product update",
    "bodyText": "We have shipped a new workflow for our customers.",
    "firstCommentText": "Tell us what you think.",
    "accountId": "LINKEDIN_ACCOUNT_ID",
    "scheduledFor": "2026-08-06T15:30:00.000Z",
    "sourceTimezone": "Asia/Kolkata"
  }'

The endpoint returns HTTP `202 Accepted`. That means OutFlo accepted and queued the work; it does not mean LinkedIn has already published the post. Store the returned `requestId` (the publication ID), then inspect the post or calendar to monitor its state.

Publish Now Directly

To publish immediately, use the same direct endpoint and set `scheduledFor` to the current ISO 8601 timestamp. OutFlo accepts a timestamp up to 60 seconds in the past to tolerate small clock differences, then queues the publication for asynchronous delivery.

NOW=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")

curl --request POST \
  --url https://api.outflo.io/api/public/v1/posting/publications/direct \
  --header "Content-Type: application/json" \
  --header "x-api-key: $OUTFLO_API_KEY" \
  --data "{
    "title": "Published from our workflow",
    "bodyText": "This post is queued for immediate delivery.",
    "accountId": "LINKEDIN_ACCOUNT_ID",
    "scheduledFor": "$NOW",
    "sourceTimezone": "UTC"
  }"

Monitor Publication Status

Use `GET /calendar` for a time-window view, or `GET /posts/{postId}` for the editorial post and its latest publication. Common publication states include:

If you need event-driven monitoring, configure your posting webhooks and verify signatures on receipt. Webhook delivery is separate from the publication queue, so your application can keep its own status record without polling continuously.

Use Posting Through MCP

The OutFlo MCP server gives compatible AI assistants a safe, bounded interface to the same public posting adapter. It does not write directly to OutFlo’s database or bypass the Posting API.

MCP tools cover:

• Posting entitlement, usage, and eligible LinkedIn accounts.
• Draft creation and updates, revision history, and restoration.
• Approval requests, decisions, private notes, feedback, replies, and resolution.
• Calendar and post-status reads.
• The standard prepare/commit publication and publication-action flows.
• A direct create-and-schedule tool that requires posts.write, posts.publish, and explicit confirmation of the exact external publication.

For connection instructions, read Connect a coding assistant to the OutFlo MCP server or connect OutFlo MCP to Claude.ai.

The safety model is deliberate: an assistant can prepare content and inspect status, but an external post should only be scheduled or published after the person operating the assistant has clearly approved the content, target account, and time.

A Practical Production Checklist

Before enabling an automation in production:

1. 1.List eligible accounts and select one explicitly; never infer a LinkedIn account from a person’s name.
2. 2.Use the draft-and-approval path when more than one person owns editorial quality or brand safety.
3. 3.Use the direct endpoint only for content and accounts your automation is authorized to publish.
4. 4.Store post IDs, revision IDs, intent IDs, and direct `requestId` values in your own system.
5. 5.Check entitlement and usage before generating a batch; scheduled posts reserve the monthly allowance.
6. 6.Treat `202 Accepted` as queued work, then monitor for `SUCCEEDED`, a retry state, or a final failure.
7. 7.Keep API keys server-side and rotate them if they are ever exposed.

With these controls in place, you can use OutFlo as the posting layer for a CMS, a social workflow, an internal tool, an automation platform, or an AI assistant—while retaining a clear audit trail from draft to LinkedIn delivery.