# X API Pricing 2026: Costs and Cheaper Reads

X API pricing is pay-per-usage: $0.005 per post read, no free tier. See every rate, a cost table for 1,000 to 100,000 posts, and a read-only option.

Published: 2026-10-23 · Updated: 2026-10-23 · 14 min read
Page: https://twitterviewer.app/blog/x-api-pricing

![X API Pricing table with pay-per-usage rates, a price per post read and a running credit balance](https://twitterviewer.app/blog/x-api-pricing/x-api-pricing.webp)

X API pricing is now pay-per-usage: there are no subscription plans, you buy credits in advance, and each resource you read or write is charged at a fixed rate, starting at $0.005 for a post read. This guide lays out every official rate checked on 23 October 2026, explains how the bill is counted, answers whether there is a free tier and how to get an API key, and then compares the cost of reading posts with a read-only option that charges per post returned.

## X API pricing in 2026: how it works

The official [pricing page](https://docs.x.com/x-api/getting-started/pricing) opens with one line that sums it up: the X API uses pay-per-usage pricing with no subscriptions. We read it on 23 October 2026, and every official number in this guide comes from it. Prices change, so treat that page as the source of truth before you budget.

Here is how the model works in practice:

- **You buy credits first.** You top up a balance in the Developer Console, and requests draw it down.
- **Each request is metered.** Reads are charged per resource returned (a post, a user, a list). Writes are charged per request.
- **You can cap spending.** The console lets you turn on auto-recharge and set a spending limit for each billing period, which stops a runaway script from emptying the balance.
- **Repeats within a day are free.** Requesting the same resource again on the same UTC day counts as one charge.

People often search for X API pricing, Twitter API pricing or the Twitter API cost as if they were three products. They are one: X is the new name of Twitter, and the old Twitter API is the X API. The earlier Free, Basic and Pro subscription tiers are history for new developers, covered in the free-tier section below.

## X API pricing table: reads and writes

Reads are billed per resource returned. If a call returns 100 posts, that is 100 post reads.

| Read | Price per resource |
| --- | --- |
| Posts: Read | $0.005 |
| User: Read | $0.010 |
| Following / Followers: Read | $0.010 |
| DM Event: Read | $0.010 |
| List, Space, Community and Note: Read | $0.005 each |
| Like, Mute and Block: Read | $0.001 |
| Your own content (owned reads) | $0.001 |

Writes and counts are billed per request:

| Write or count | Price per request |
| --- | --- |
| Post: Create | $0.015 |
| Post: Create (with a URL) | $0.200 |
| User Interaction: Create (a like, follow or repost) | $0.015 |
| Counts: Recent | $0.005 |
| Counts: All | $0.010 |
| Trends | $0.010 |

Two details change the arithmetic. A post that contains a link costs more than thirteen times a plain post to publish, so a bot that shares URLs pays $0.200 each. And reading a user's profile costs twice as much as reading one of their posts, so a job that fetches many profiles is dominated by user reads, not post reads.

## What counts as one charge

The headline rates are simple, but three rules decide what you actually pay.

**Deduplication by day.** The docs say that requesting the same post several times in a day counts as one charge. The window is a UTC day, so a polling script that re-reads the same posts all afternoon is cheaper than it looks. It also means a job that runs once per day and re-reads old posts is billed again the next day.

**A monthly read cap.** A pay-per-usage account can read at most 3 million posts per billing period. At $0.005 a post, that ceiling is $15,000 of post reads. Going beyond it requires the Enterprise route, which is negotiated rather than listed.

**Per-resource billing.** Each distinct resource in a response has its own line in the table above. Before you estimate a budget, check how the user and media objects in your responses are counted, because a user read costs twice a post read.

There is also a promotion. At the time we checked, saving an eligible bank card and completing a first purchase earned $20 in X API credit, and the first auto-recharge was matched up to $50. Promotions come and go, so read the live page.

## Is there a free X API tier?

No. The pay-per-usage plan has no free tier. If you search for a free Twitter API or the X API free tier, you will find articles that describe the earlier subscription tiers: a Free tier with a tiny write allowance, Basic at $200 a month and Pro at $5,000 a month. Those tiers were reported as closed to new sign-ups when pay-per-usage arrived, and we do not give a date because the dates differ between reports. What the docs page lists today is credits, rates and a one-time promotion.

So "free" now means one of three things:

1. **The promotional credit.** The $20 first-purchase credit is not free, because you must buy something first.
2. **A small bill.** At $0.005 a post, reading 200 posts costs $1.00. Light use is cheap, just not free.
3. **A different tool.** If your job is reading public posts, some tools include free reads. On this site a new account gets 50 credits once, and the [X to Markdown](https://twitterviewer.app/x-to-markdown) page gives every visitor one free conversion a day of up to 25 posts.

The third point does not make the official API free; it only means the question depends on the job. Posting, liking and following can only go through the official X API, and those have no free path.

## How to get a Twitter API key

A Twitter API key is a credential that proves your app is allowed to call the API. The process is the same as before, with credits as the last step:

1. **Apply for a developer account.** Sign in with the X account that will own the app and accept the developer agreement.
2. **Create a project and an app.** The console gives the app an API key and secret, and you can generate a Bearer Token for read-only calls.
3. **Choose the access you need.** Reading public data works with the Bearer Token. Acting for a user, such as posting, needs OAuth with that user's permission.
4. **Buy credits.** Without a balance, calls are refused.
5. **Store the secrets safely.** Put the key and token in environment variables, never in a repository or client-side code.

On this site, a key is a smaller step: sign up, open the API page in your account and create a key that starts with `tv_live_`. There is no developer application, because the key only reads public content. The [API Docs](https://twitterviewer.app/docs/api) list every endpoint.

## Twitter API cost: what common jobs add up to

Rates are easiest to judge against real jobs. These examples use post reads at $0.005 and ignore the user and media lines, so treat them as the floor.

| Job | Posts read | Official cost |
| --- | --- | --- |
| Read one post | 1 | $0.005 |
| Read a thread of 31 posts | 31 | $0.155 |
| Read an account's last 200 posts | 200 | $1.00 plus the profile read at $0.010 |
| Monitor 50 accounts, 20 new posts each, every day | 1,000 a day | $5 a day, about $150 over 30 days |
| Collect 100,000 posts for a research set | 100,000 | $500 |

These totals show what the Twitter API cost looks like at scale. A hobby script that reads a few hundred posts a month costs a few dollars. A research pipeline that reads hundreds of thousands of posts a month costs hundreds of dollars before anything else. The deduplication rule helps when you poll the same posts, and it does not help when every run fetches new ones.

## Twitter API cost compared: official X API vs credits

If your work is reading, the main question is the price of one post. The official rate is $0.005. On this site the unit is a credit, and one credit is one post returned. The price of a credit depends on how you buy it.

![Twitter API Cost comparison: price per post read on the official X API and on each credit pack and plan](https://twitterviewer.app/blog/x-api-pricing/twitter-api-cost.webp)

The table shows the price per post at each rate and what 1,000, 10,000 and 100,000 posts cost at that rate. It assumes you use every credit you buy. Prices are rounded to the nearest cent, and the per-post price is the plan or pack price divided by its credits.

| Option | Price per post | 1,000 posts | 10,000 posts | 100,000 posts |
| --- | --- | --- | --- | --- |
| Official X API (post read) | $0.005 | $5.00 | $50.00 | $500.00 |
| Credit pack, 1,000 for $5 | $0.005 | $5.00 | $50.00 | $500.00 |
| Credit pack, 6,000 for $20 | $0.00333 | $3.33 | $33.33 | $333.33 |
| Credit pack, 20,000 for $50 | $0.0025 | $2.50 | $25.00 | $250.00 |
| Plus, $10 a month for 3,000 credits | $0.00333 | $3.33 | $33.33 | $333.33 |
| Pro, $20 a month for 8,000 credits | $0.0025 | $2.50 | $25.00 | $250.00 |
| Business, $50 a month for 25,000 credits | $0.002 | $2.00 | $20.00 | $200.00 |
| Plus, yearly: $60 for 36,000 credits | $0.00167 | $1.67 | $16.67 | $166.67 |
| Pro, yearly: $120 for 96,000 credits | $0.00125 | $1.25 | $12.50 | $125.00 |
| Business, yearly: $300 for 300,000 credits | $0.001 | $1.00 | $10.00 | $100.00 |

Three honest caveats come with these numbers.

- **Plan credits expire.** A monthly pool resets each month, so a Business plan is only $0.002 a post if you read all 25,000 posts that month. Read 2,500 and the effective price is ten times higher. Credit packs never expire, which suits uneven use.
- **Yearly plans add the whole year at once.** A yearly plan adds twelve months of credits up front, valid for the year, at half the price of paying monthly. The yearly rows assume you use all of them.
- **The two products do different things.** The official rate buys a post read through the full X API. The credit price buys a read-only service for public content. Comparing the prices is fair; treating them as the same service is not. The next sections cover where each belongs.

The figures come from the [pricing page](https://twitterviewer.app/pricing), where plans, packs and the monthly credit pools are listed.

## A read-only alternative to the official X API

The [Twitter API](https://twitterviewer.app/twitter-api) on this site is an independent, read-only service for public X content. It is not X's official API and is not affiliated with X Corp. You send a link to a post, a thread or a profile to one endpoint and receive Markdown, Obsidian notes, plain text, JSON or PDF.

A first call looks like this:

```bash
curl -X POST https://twitterviewer.app/api/v1/convert \
  -H "Authorization: Bearer $TWITTERVIEWER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://x.com/username/status/1234567890123456789", "scope": "thread", "format": "markdown" }'
```

How billing differs from the official model:

- **One unit.** One credit is one post returned, whichever endpoint you call. A quoted post counts as one more post.
- **Author details are free.** The official API charges $0.010 for a user read; here the profile summary costs nothing.
- **Failures are free.** A call that fails or returns nothing is not charged. If your balance is lower than the result, you get as many posts as it covers.
- **Short repeats are free.** The same link with the same options, requested again within 10 minutes by the same key, is not charged twice. The official window is a UTC day.
- **Rate limits.** Requests are limited per account per minute: 10 on a free account, 30 on Plus, 60 on Pro and 300 on Business.

The formats matter as much as the price. The Markdown output keeps the author, the date of each post, the text, image links and shared links, and the JSON carries the same posts as structured data. If the goal is to feed a model, save a note or archive a thread, the output is ready to use. Parameters, errors and field names are in the [API Docs](https://twitterviewer.app/docs/api).

## X MCP: how an agent reads X without writing code

MCP stands for Model Context Protocol, an open standard that lets an AI client call tools from another program. An X MCP server is a server that offers tools for reading X through that standard, so an assistant can fetch a post when you ask instead of you pasting text into the chat. People also search for it as Twitter MCP or X MCP server, and they mean the same thing.

![X MCP server connected to an AI assistant, with tools to convert a link, read replies and check trends](https://twitterviewer.app/blog/x-api-pricing/x-mcp.webp)

The [Twitter MCP Server](https://twitterviewer.app/twitter-mcp-server) on this site is remote and read-only. There is nothing to install: your client connects to `https://twitterviewer.app/mcp` over Streamable HTTP and signs in with the browser or an API key. It has five tools:

| Tool | What it does |
| --- | --- |
| `convert_x_url` | Turns a post, thread or profile link into Markdown, Obsidian, text or JSON |
| `search_x_posts` | Searches public posts with X search operators (Pro and Business) |
| `get_x_replies` | Reads the public replies under a post |
| `get_x_trends` | Lists what is trending in a region |
| `get_credits` | Shows your balance, free of charge |

To add it to Claude Code, run:

```bash
claude mcp add --transport http twitterviewer https://twitterviewer.app/mcp
```

Claude, Cursor and Codex connect the same way, with a URL in the connector or config file. The tools use the same credits as the REST API, so an agent that reads three threads of ten posts spends 30 credits. Because the server has no tool that writes, a confused agent cannot post, like or follow for you. The worst it can do is spend credits on reading, and the per-minute limit and your balance cap that.

## Official X API vs a read-only API: which to use

The choice depends on what your code does with X, not on which is cheaper.

| Your job | Use |
| --- | --- |
| Publish posts, reply, like, repost or follow | Official X API |
| Act on behalf of a signed-in user | Official X API |
| Read private data, such as your own DMs or bookmarks | Official X API |
| Stream or filter every new post in real time | Official X API (the volume may need Enterprise) |
| Read public posts, threads and profiles as text or JSON | Read-only API, or the official API if you prefer a single vendor |
| Feed threads to an AI model or save them as notes | Read-only API or MCP |
| Archive a thread as PDF | Read-only API with `format=pdf` (Pro and Business) |
| One thread, once, without code | The [X to Markdown](https://twitterviewer.app/x-to-markdown) page |

Many teams use both: the official API for the account they run and a read-only service for research and notes. Neither replaces the other.

## What a read-only API cannot do

Being clear about limits saves a wasted evening.

- **No writing.** It cannot post, reply, like, follow, block or send messages.
- **Public content only.** Private accounts, protected posts, direct messages and deleted posts are not returned, and suspended accounts answer with an error.
- **Slightly cached.** Posts are cached for around two minutes and profiles for around ten, so a call right after an edit may show the earlier text.
- **Search needs an X account.** X shows search results only to signed-in users, so the search endpoint is part of Pro and Business and uses an X account you connect yourself.
- **Not every X feature is converted.** X Articles, polls and link cards are not converted yet, and an article comes back as the post that shares it.
- **Not X's API.** It is an independent service, and X and Twitter are trademarks of their owners.

If one of these is a blocker, the official X API is the right tool, and the rates above are what it costs.

## How to estimate your own X API bill

A few minutes of arithmetic avoids surprises:

1. **List the resources you read,** and count posts, users and lists separately, because their rates differ.
2. **Multiply by how often you read.** A daily job that reads 1,000 new posts is 30,000 a month, or $150 at the post rate.
3. **Subtract same-day repeats,** which the UTC-day rule charges once, and add writes at $0.015 each ($0.200 with a link).
4. **Set a spending limit** you are happy to lose if a loop goes wrong, and check the 3 million cap if you read at volume.

Then compare with the cost of a read-only option for the reading part, using the table above and your real monthly volume. If your volume is uneven, packs that never expire usually beat a plan whose credits reset each month.

> **Read public X posts from code, billed per post returned** — [See the Twitter API](https://twitterviewer.app/twitter-api)

## X API Pricing FAQs

### What is X API pricing?

X API pricing is the pay-per-usage price list for the official X API. There are no subscriptions: you buy credits in the Developer Console, and each resource read or request made is charged at a fixed rate, such as $0.005 for a post read and $0.015 for creating a post. We checked the rates on 23 October 2026.

### How much does the Twitter API cost?

A post read costs $0.005, a user read $0.010, and creating a post $0.015, or $0.200 if the post contains a URL. Reading 1,000 posts costs $5, reading 10,000 costs $50 and reading 100,000 costs $500. Same-day repeats of the same resource count once.

### Is the X API free?

No. The pay-per-usage plan has no free tier, and the old Free tier is no longer offered to new developers. The docs list a promotion: saving an eligible card and completing a first purchase earned $20 in credit when we checked. Light use is cheap, just not free.

### Is there a free Twitter API alternative?

Not for posting or acting as a user. For reading public posts, this site gives a new account 50 credits once, and the [X to Markdown](https://twitterviewer.app/x-to-markdown) page gives every visitor one free conversion a day of up to 25 posts. That covers small jobs, not production use.

### What happened to the X API free tier?

The earlier subscription tiers, Free, Basic at $200 a month and Pro at $5,000 a month, were replaced by pay-per-usage pricing for new developers. This guide does not give a date because reports differ. The current docs page shows only credits and per-resource rates.

### How do I get a Twitter API key?

Create a developer account with the X account that will own the app, create a project and an app, generate the API key and Bearer Token, and buy credits. Without credits, calls are refused. A read-only key on this site starts with `tv_live_` and takes one click on the API page of your account.

### What is the monthly limit on the X API?

A pay-per-usage account can read up to 3 million posts per billing period. Going beyond that needs an Enterprise agreement. You can also set your own spending limit for each period, which stops requests when it is reached.

### Does requesting the same post twice cost twice?

On the official API, no: requesting the same post several times on the same UTC day counts as one charge. On this site's read-only API, the same link with the same options requested again within 10 minutes is not charged twice.

### What is X MCP?

X MCP is a Model Context Protocol server that gives an AI assistant tools for reading X. The [Twitter MCP Server](https://twitterviewer.app/twitter-mcp-server) here is remote and read-only, with five tools, and works with Claude, Claude Code, Cursor and Codex. It cannot post, like or follow.

### Can I use a read-only API instead of the official one?

Yes, if your job is reading public posts, threads and profiles. It cannot post, like, follow, send messages or open private accounts, so anything that writes to X or acts for a user needs the official X API. See the [API Docs](https://twitterviewer.app/docs/api) for what the read-only endpoints return.

### How much do credits cost on this site?

One credit is one post returned. Packs cost $5 for 1,000, $20 for 6,000 and $50 for 20,000 credits and never expire. Plus, Pro and Business cost $10, $20 and $50 a month for 3,000, 8,000 and 25,000 credits, and yearly billing costs half. See the [pricing](https://twitterviewer.app/pricing) page.