X API Pricing (October 2026): What Posting Costs

How much does the X API cost in October 2026?

X API v2 is pay-per-usage: no subscription, credits are deducted per request, and you watch usage in the Developer Console. These are the posting-related rates from the official pricing page:

Operation	Price
Post: create	$0.015 per request
Post: create (with URL)	$0.200 per request
Interaction delete	$0.010 per request
Media metadata	$0.005 per request
Read posts	$0.005 per resource
Read users, followers/following, DM events	$0.010 per resource
Read likes, mutes, blocks	$0.001 per resource
Owned reads (your own posts, mentions, followers via your own app)	$0.001 per resource

A few rules on that page change the math:

• Reads are deduplicated within a 24-hour UTC window. Request the same resource twice in a day and you pay once. X calls this a soft guarantee.
• Post reads are capped at 3 million per monthly billing cycle on pay-per-use. Past that, X points you to an Enterprise plan.
• A negative balance blocks requests until you add credits. You can set a spending limit per billing cycle, and requests are blocked once you hit it.
• Auto-recharge tops your balance up when it drops below a threshold you choose. It runs at most once every five minutes and needs a saved card.

There are sign-up incentives too: $20 in credits after you save an eligible card and make your first purchase, and your first auto-recharge matched with up to $50. Linking an xAI team earns xAI API credits once your X API spend in a cycle passes $200 (10%, rising to 20% above $1,000).

The pricing page does not list a separate line for uploading media, and it does not define exactly what makes a post count as "with URL". If either matters to your budget, test it on a small balance and watch the console.

What happened to the Free, Basic and Pro tiers?

They are gone as tiers you can sign up for. The sequence, from X's own announcements:

• February 2026: pay-per-use launches. X's launch announcement made it the flagship plan. @XDevelopers said that only "for-good Public Utility apps" would keep free scaled access, that recently active legacy Free users would move to pay-per-use with a one-time $10 voucher, and that Basic and Pro would stay available for the time being.
• June 2026: Basic is retired. X announced that legacy Basic plans, monthly and annual, were deprecated, with subscribers moved to pay-per-use at the end of their billing cycle after June 1, 2026.
• September 2026: Pro is retired. A matching announcement did the same for legacy Pro plans, after September 1, 2026.
• Enterprise remains. The pricing page sends anyone who needs more than 3 million post reads a month to an Enterprise interest form. X does not publish Enterprise prices.

So if you read a guide that compares "Basic at $X a month" with "Pro at $Y a month", it was written before mid-2026. For posting, there is now one price list.

How much does it cost to post a tweet through the API?

One POST /2/tweets call costs $0.015, or $0.20 if the post contains a link. That is the whole answer for a plain post. The parts that add up:

• Threads are one charge per post. A thread is a chain of posts, each one a reply to the last via reply.in_reply_to_tweet_id on the create post endpoint. A five-post thread is five creates: $0.075, or more if any of them carries a link.
• Links are the expensive line. At $0.20, one link post costs the same as about 13 plain posts. If you share a blog post every day, links will be most of your bill.
• Deletes cost money. "Interaction delete" is $0.010 per request.
• Reading your own replies is cheap, other data less so. Owned reads are $0.001 per resource. Pulling other people's posts is $0.005 each, and users are $0.010 each.

Some quick monthly figures, using only the create rates above:

What you post	Requests a month	Cost
1 plain post a day	30	$0.45
10 plain posts a day	300	$4.50
10 posts a day, all with links	300	$60.00
50 accounts × 3 posts a day, 1 in 3 with a link	4,500	$30.00 + $300.00 = $330.00

The last row is the one agencies and SaaS products should look at. At scale, the link rate costs more than everything else on the list.

What are the X API rate limits for posting?

Pay-per-use changed what you pay. It did not remove rate limits. From X's rate limits reference:

Endpoint	Per user	Per app
POST /2/tweets (create a post)	100 requests / 15 minutes	10,000 requests / 24 hours
DELETE /2/tweets/:id	50 requests / 15 minutes	not listed

Every response carries x-rate-limit-limit, x-rate-limit-remaining and x-rate-limit-reset (a Unix timestamp). The docs say Enterprise customers get custom limits.

The per-app 10,000-a-day cap matters more than it looks. If your product posts for many users through one X app, all of them share it.

What do you need to post natively?

The pieces, all from X's docs:

1. An app in the Developer Console with credits on the account.
2. OAuth 2.0 user context. Create post needs the tweet.read, tweet.write and users.read scopes.
3. POST https://api.x.com/2/tweets with a JSON body: text, optionally media.media_ids (1 to 4), a poll (2 to 4 options of 1 to 25 characters, duration_minutes from 5 to 10080), or reply.in_reply_to_tweet_id.
4. Media through the v2 chunked upload: POST /2/media/upload/initialize, /2/media/upload/{id}/append, /2/media/upload/{id}/finalize, and GET /2/media/upload for status, per the chunked upload guide. The old command=INIT/APPEND/FINALIZE form is no longer the one to use.

A minimal call:

curl -X POST "https://api.x.com/2/tweets" \
  -H "Authorization: Bearer <USER_ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "text": "Shipping today." }'

Then the real work starts: refreshing tokens, retrying on 429 without posting twice, resuming a thread that broke halfway, and checking that each video finished processing before you attach it.

How do you keep the X API bill down?

• Count links first. Look at how many of your posts carry a URL. That number drives the bill more than anything else.
• Set a spend limit. The console lets you cap spend per billing cycle. A runaway retry loop on a $0.20 endpoint is an expensive bug.
• Don't poll for things you posted. Owned reads are $0.001, but a tight polling loop over many accounts still adds up. Read once, after the post settles.
• Make writes idempotent. A post sent twice is charged twice. Retry only when you know the first attempt failed.
• Keep reads deduplicated. Same resource, same UTC day, one charge. Cache inside that window instead of fighting it.

Is posting through a unified API cheaper?

Not on X's side of the bill, and any unified API that says otherwise deserves a second look.

Bulkit posts to X through your own X developer app. You create the app, paste its OAuth 2.0 keys into Bulkit, and connect accounts through it. The X app guide says it plainly: "the X API is pay per use. Each post costs credits, so add some under Billing → Credits in the Developer Console, or posts fail." Your X credits pay for X's API calls whether the request comes from your code or from Bulkit.

What a unified API saves is the engineering: OAuth, token refresh, chunked uploads, retries that don't double-post, threads that resume where they stopped, and the same code for eleven other networks. Bulkit's own price is $4.99 a month with 500 actions included, then $0.01 per action, where an action is a published post or a sent comment, with unlimited profiles. For X that is a fixed cost on top of your X credits. You are paying to not build and maintain the integration, not buying cheaper X access.

If you only post to X, a direct integration may well be the cheaper option. If X is one of several networks, or you are building for many accounts, the integration work is where the money goes.

How do you post to X with Bulkit?

Once your X app is connected, an X post is the same request as any other network. From the Twitter / X platform page: 280 characters (25,000 on accounts with a paid X subscription), every link counted as 23 characters, up to 4 files, and threads of up to 25 posts.

A thread with a poll, using the Node SDK:

import { Bulkit } from "bulkit";

const bulkit = new Bulkit(); // reads BULKIT_API_KEY

const post = await bulkit.posts.create({
  intent: "now",
  channels: [
    {
      channelId: "CHANNEL_X",
      options: {
        poll_options: ["Tabs", "Spaces"],
        poll_duration_minutes: "1440",
      },
      blocks: [
        { content: "Settle this once and for all 👇" },
        { content: "Results tomorrow." },
      ],
    },
  ],
});

Each block is one post in the thread, and each one is a create on your X bill. If a thread stops halfway, a retry carries on from the block that failed and does not repost the first ones, so a failure does not cost you duplicate posts. The other X option is reply_settings (following or mentionedUsers; subscribers or verified for paid accounts).

Publishing is asynchronous: intent: "now" returns publishing, not published. Call posts.retrieve(post.id) or use webhooks to find out what happened. The X channel page covers the rest. If you'd rather have an agent draft and schedule posts, the same API is available over MCP. To compare unified APIs on price and coverage, see the comparisons.

The numbers to remember

As of October 2026:

• No monthly tiers for new developers. Free, Basic and Pro are retired; you buy credits.
• $0.015 per post, $0.20 per post with a link, $0.010 per delete.
• 100 posts per user per 15 minutes, 10,000 per app per day.
• 3 million post reads a month is the pay-per-use ceiling. Above it, you need Enterprise.
• A unified API doesn't change what X charges. It changes how much code you write.