Idempotency and Client-Request-ID Patterns for Telegram→X Publish Retries in 2026
When a Telegram→X scheduler times out on POST /2/tweets, a naïve retry can create a second Post even though the first request already succeeded on X’s side. Official X create-Post documentation describes a JSON body with text/media and a successful 201 response that returns the new Post id—it does not document a server-accepted idempotency key or client-request-id that would make the create call safe to replay. Telegram’s Bot API similarly treats outbound sendMessage-style calls as ordinary HTTPS methods without a built-in send idempotency key (receive-side update_id dedupe is a different problem). This article is educational ops hygiene for tools discussed on AutoX: client-owned claim keys, ambiguous-timeout handling, and reconciliation—distinct from content fingerprint guards and from 429/dead-letter backoff covered elsewhere. Not a growth guarantee.
What X and Telegram document (and what they omit)
Primary references operators should re-check before shipping retry logic:
- X create Post — X’s manage-Posts / create-Post API reference documents
POST https://api.x.com/2/tweetswith a JSON body (at leasttextor media) and OAuth user scopes such astweet.write. A success path returns the new Post’sid. The documented request schema does not include an idempotency-key or client-request-id field that the platform guarantees to deduplicate retries. - Telegram Bot API requests — Making requests describes HTTPS
getMe/METHOD_NAMEcalls with JSON or form bodies and anokresult. For inbound updates, Telegram documentsupdate_idso bots can ignore repeated webhook deliveries—useful for receive dedupe, not for making outbound publishes idempotent. - Ambiguous transport failures — a TCP reset or client read-timeout after the server accepted the write still looks like “failure” to the worker. Blindly re-POSTing creates duplicates on both Telegram outbound notices and X Posts.
Foundations: how to schedule X posts from Telegram, step by step and Telegram bots that auto-post to X, compared. Retries that are safe for rate limits are a separate topic—see failed-publish retries and dead-letter queues.

Client-request-id as a local claim, not an X header fantasy
Because the create-Post endpoint does not advertise server-side idempotency, the durable key lives in your datastore before the HTTP call leaves the worker:
- Mint a client_request_id — UUID (or hash of tenant + scheduled_slot_id + content revision) stored with the job row.
- Atomic claim — transactionally move the row from
queued→publishingonly if no other worker holds the claim; losers exit without calling X. - Call X once under the claim — send
POST /2/tweets; on definitive201, persist returned Postidand markpublished. - On ambiguous timeout — do not immediately retry create. Mark
reconcile_needed, page ops if needed, and let a sweeper decide. - Definitive client/server errors — 4xx policy/auth failures can mark
failedwithout create-retry; 429 belongs to rate/credit budgets, not a second create under a new claim.
This is complementary to—not a substitute for—duplicate content fingerprint guards (which catch identical text across jobs). Fingerprints compare payload similarity; client_request_id compares “this exact fire attempt.” Pair with rate-limit budgets and credits so reconcile work does not burn your write window.

Reconciliation after ambiguous outcomes
When the create call’s outcome is unknown, prefer lookup over replay:
- Store correlation fields — scheduled_at, text fingerprint, media ids, and the client_request_id in your job log before the request.
- Search / timeline check — after a cool-down, query the authenticated user’s recent Posts (or a stored lookup by known markers) to see whether the Post already exists; if yes, attach the id and close the job as published.
- Only then allow a new claim — if reconciliation proves absence, mint a new client_request_id (never reuse a burned claim blindly) under operator or policy approval.
- Telegram admin notices — apply the same non-idempotent rule to bot
sendMessagestatus updates: do not stack retries on read-timeouts; use edit/delete where appropriate for state changes that are safer to replay.
OAuth refresh races are a related but different failure mode—see OAuth 2.0 refresh-token rotation. Approval gates still decide whether to fire—see approval gates and API token hygiene.

Operational checklist for fire-time workers
- Persist client_request_id + claim state before any create-Post HTTP call.
- Single-flight per job (and ideally per X account write lane) so two containers cannot both believe they own the claim.
- Classify errors: definitive fail vs 429 backoff vs ambiguous timeout (no inline create-retry).
- Run a reconcile sweeper with budget caps; never infinite create loops.
- Keep quiet hours and cadence policy upstream of claims—see timezone-safe quiet hours and sustainable posting cadence.

Practical checklist
- Do not invent X headers the create-Post docs do not promise; own idempotency in your DB.
- Treat Telegram outbound sends and X creates as non-idempotent under transport timeouts.
- Separate fingerprint dedupe (content) from claim dedupe (attempt).
- Route 429/credit exhaustion to DLQ/backoff paths, not to a second create under the same confused worker.
- Document the reconcile runbook for on-call before the first production timeout.
Key takeaways
- X’s documented create-Post flow returns a Post id on success but does not give schedulers a portable server-side idempotency key—client claims fill that gap.
- Ambiguous timeouts are the classic double-post trigger; reconcile by lookup, do not blind-retry create.
- Telegram
update_idhelps inbound webhook dedupe; it does not make outbound publish retries safe. - No affiliate links in this article. Re-verify request schemas on docs.x.com and core.telegram.org before production changes.
FAQ
Does X’s create-post endpoint accept an idempotency key?
Its documented request body has no idempotency-key field, so the API will not deduplicate a retried POST for you. Keep the claim on your side: write a publish record with your own request ID before calling X, and reconcile against the account’s recent posts when the outcome is unclear. Generic patterns such as the IETF Idempotency-Key header draft show the idea, but they only help where the server supports them.
Why does my bot receive the same Telegram update twice?
Telegram retries a webhook delivery when your endpoint answers with anything other than a 2xx status, and gives up after a number of attempts. Every update has an update_id that is unique and increases sequentially, so store the IDs you have processed and skip repeats. Answer 200 quickly and do the slow work afterwards.
What format should the client request ID use?
A UUID is enough. RFC 9562 defines version 4 (random) and version 7 (time-ordered) UUIDs; version 7 sorts by creation time, which makes publish logs easier to read. Generate it once when the job is created and reuse the same ID on every retry, never a new one per attempt.
Sources
- X API documentation: create a post (POST /2/tweets) (checked 2026-10-18)
- Telegram Bot API reference (checked 2026-10-18)
- RFC 9562, Universally Unique IDentifiers (UUIDs) (checked 2026-10-18)
- IETF HTTPAPI draft: the Idempotency-Key HTTP header field (checked 2026-10-18)
Educational product ops guidance. X API request fields, response codes, and Telegram Bot API behavior change over time; re-verify on official documentation before production use. Last verified 2026-10-04.