X API pricing in 2026: costs, free credits, limits

Prices on this page are quoted from X's documentation as read on 29 October 2026. X says its prices are subject to change, and the current rates are always in the Developer Console. Check there before you budget.

How X API pricing works

X describes its pricing as pay-per-usage with no subscriptions, contracts, or minimum spend (pricing). The model has four parts:

Credits. You buy credits up front in the Developer Console, and requests deduct from the balance in real time. When the balance runs out, requests fail until you add more. The balance can dip slightly negative, and requests stay blocked until it is covered.
Per-resource reads, per-request writes. Reads are charged for each resource returned, so a search that returns 100 posts is 100 post reads. Writes are charged per request.
Daily deduplication. The same resource fetched again within one UTC day is charged once. X calls this a soft guarantee that can fail in edge cases such as outages.
Only successful requests bill. X's usage FAQ says failed requests are not charged; only successful responses that return data are (usage and billing).

Pay-per-use accounts are capped at 3 million post reads per monthly billing cycle. Above that, X points you to an Enterprise plan with custom pricing.

What posting costs

Write prices from X's pricing page, charged per request:

Action	Price per request
Post: Create	$0.015
Post: Create (with URL)	$0.200
Post: Create (summoned reply)	$0.010
Media Metadata (for example, alt text)	$0.005
DM Interaction: Create	$0.015
User Interaction: Create	$0.015
Interaction: Delete	$0.010

The URL surcharge drives most posting budgets: a post with a link costs over 13 times a plain post. At these rates, an account that posts 10 times a day for 30 days spends $4.50 on 300 plain posts, or $60 if every post carries a link. If links matter, put them in fewer posts, or in a reply only when the reply rules allow it.

What reading costs

Resource	Price per resource
Posts: Read	$0.005
User: Read	$0.010
Following/Followers: Read	$0.010
DM Event: Read	$0.010
Like, Mute, or Block: Read	$0.001
Owned Reads (your own data)	$0.001

Owned Reads apply when the developer app's owner reads their own account: their posts, mentions, likes, bookmarks, followers, following, and lists, on endpoints such as GET /2/users/{id}/tweets where {id} is the authenticated owner. That makes a dashboard of your own account five times cheaper per post than reading someone else's timeline. Reading posts from other accounts is the expensive part of most X apps, and it is where the 3 million cap applies.

Is there a free X API tier?

Not for new developers. X's pricing and getting-access pages describe only pay-per-use credits and Enterprise. When X launched pay-per-use on 6 February 2026, it gave recently active Legacy Free tier users a one-time $10 voucher, said Public Utility Apps keep free access, and said Basic and Pro subscribers could opt in to pay-per-use (changelog). Guides that still describe a free tier with a monthly post allowance predate that change.

What new accounts get instead is free credits (free credits):

$20 once an account with its first eligible credit or debit card completes its first credit purchase. Adding a card alone stopped qualifying on 13 October 2026, and prepaid cards don't qualify.
A match of the first successful auto-recharge, up to $50. It's granted when the recharge actually charges the card, not when you switch it on.

Each is once per account and once per physical card. Free credits are spent before purchased ones and expire three months after they are granted. X says these incentives are still rolling out, so an account may not receive them yet. X also gives back xAI API credits on spend: 10% from $200 in a billing cycle, 15% from $500, and 20% from $1,000, once you link an xAI team to the developer account.

Keeping the bill under control

Spending limit. Set a maximum spend per billing cycle in the Developer Console. Requests are blocked once it's reached, which is safer than an open balance while you develop.
Auto-recharge. Tops up when the balance falls below a threshold. It fires at most once per 5 minutes and doesn't run at a zero or negative balance, so a burst of traffic can still hit "out of credits" if the recharge amount is small.
Usage endpoint. Read daily post consumption from your code:

curl "https://api.x.com/2/usage/tweets" \
  -H "Authorization: Bearer <APP_BEARER_TOKEN>"

Don't retry writes blindly. If a create request times out after it was sent, the post may exist. Sending it again can publish a duplicate and pay for it twice. Check the account's recent posts first.

Posting rate limits

Billing and rate limits are separate: credits decide what you pay, rate limits decide how fast you can go. Limits from X's rate limit tables (rate limits):

Endpoint	Limit
Create a post (`POST /2/tweets`)	10,000 per 24 hours per app; 100 per 15 minutes per user
Delete a post (`DELETE /2/tweets/:id`)	50 per 15 minutes per user
Recent search (`GET /2/tweets/search/recent`)	450 per 15 minutes per app; 300 per 15 minutes per user
User's posts (`GET /2/users/:id/tweets`)	10,000 per 15 minutes per app; 900 per 15 minutes per user

Requests over a limit get HTTP 429. Read the x-rate-limit-reset header to see when the window resets.

Reply, like, and follow rules

Two 2026 policy changes limit what pay-per-use apps can automate (changelog):

Since 23 February 2026, programmatic replies through POST /2/tweets are allowed only when the original post's author "summoned" your account, by mentioning it or quoting one of its posts. Further restrictions apply to programmatic mentions and quotes. Enterprise access is not affected.
With the price update effective 20 April 2026, following, likes, and quote posts through the API were removed from all self-serve tiers.

Making a post

Posting needs a user-context token. Create an app in the Developer Console, enable OAuth 2.0, and get a user access token with the tweet.write scope (plus tweet.read and users.read). An app-only bearer token can read public data but can't post. One create call:

curl -X POST "https://api.x.com/2/tweets" \
  -H "Authorization: Bearer <USER_ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from the X API"}'
# {"data": {"id": "1850000000000000001", "text": "Hello from the X API"}}

Social SDK is an open-source TypeScript library with an X adapter. It uses your own X app and tokens, so X bills your developer account directly at the rates above. The adapter checks X's weighted 280-character count before sending, uploads media, and returns a typed outcome for each post. When the result of a create request is unclear, the outcome is unknown rather than a retry.

npm install @opencoredev/social-sdk

import { createSocial, connectedAccountRef } from "@opencoredev/social-sdk";
import { x } from "@opencoredev/social-sdk/x";

const userId = process.env["X_USER_ID"];
const accessToken = process.env["X_ACCESS_TOKEN"];
if (!userId || !accessToken) throw new Error("Set X_USER_ID and X_ACCESS_TOKEN");

// accessToken is an OAuth 2.0 user token with tweet.write; userId is that user's numeric ID.
const social = createSocial({ backend: x({ auth: { userId, accessToken } }) });
const account = connectedAccountRef({ backend: "default", platform: "x", accountId: userId });

// A text-only post is billed as Post: Create. Adding a URL to the text moves it to
// the Post: Create (with URL) rate.
const result = await social.posts.publish({
  targets: [{ account }],
  content: { text: "Shipped a new release today. Notes are pinned on our profile." },
});

for (const outcome of result.outcomes) {
  if (outcome.state === "published") console.log("published", outcome.post.postId);
  // unknown: the request went out but the result is unclear. Check the account's
  // posts before sending again; a blind retry can post (and bill) twice.
  else if (outcome.state === "unknown") console.log("check before retrying", outcome.diagnostic);
  else console.log(outcome.state, outcome);
}

We type-checked this example against @opencoredev/social-sdk 0.5.0 from npm and ran it on 29 October 2026 with a stub fetch standing in for api.x.com. It made one POST /2/tweets call with the user token and printed the new post ID. When the stub returned no post ID, it printed the "check before retrying" branch instead. It runs on Node.js 22.12 or later and Bun.

The X platform page covers the OAuth 2.0 connection flow, images, video, replies, search, and the filtered stream. The same client can post to X, Bluesky, and Threads in one call; the platforms overview shows how. To build and test without spending credits, start with the mock quickstart, which runs against a mock backend.

Common questions

How much does it cost to post a tweet with the API?: $0.015 per post on X's pricing page as read on 29 October 2026, or $0.20 if the post contains a URL. A summoned reply is $0.010.
Is the X API free?: Not in general. New developers pay per use with credits. New accounts can earn up to $70 in free credits that expire after three months, and X says Public Utility Apps keep free access.
Do Basic and Pro plans still exist?: X's February 2026 launch note said Basic and Pro remained available to existing subscribers, who could opt in to pay-per-use. X's current pricing documentation describes only pay-per-use and Enterprise.
Am I charged for failed requests?: X's usage FAQ says no: only successful responses that return data are billed. A request that timed out may still have succeeded, though, so check before you repeat a write.
How do I stop a runaway bill?: Set a spending limit per billing cycle in the Developer Console and watch /2/usage/tweets. Requests stop when the limit is reached.

Sources

Read on 29 October 2026:

X API pay-per-usage pricing and credits: read and write prices, Owned Reads, deduplication, the 3 million post-read cap, auto-recharge, spending limits, xAI credits
Free credit incentives: the $20 and up-to-$50 credits, eligibility, expiry
Usage and billing: tracked endpoints and the failed-request FAQ
Rate limits: per-app and per-user limits for posting, deleting, search, and timelines
Getting access: Developer Console, apps, and credentials
Changelog: pay-per-use launch (6 February 2026), reply restrictions (23 February 2026), price update and Owned Reads (16 April 2026, effective 20 April), free credits (2 October 2026)