Twitter API cost in 2026: a calculator for X data workloads

The Twitter API cost for reading data is per item returned: $0.005 for every post and $0.010 for every user profile or follower, on X's pay-per-use pricing as listed on Oct 14, 2026. So the bill for any data job is rows times unit price. Twenty busy keywords can run $1,500 a month, a 200,000-row follower export $2,000, and a small timeline archive a few dollars.

Below is that arithmetic for three common data workloads, priced on X's official rates and on ChatterAPI's credits, plus a Python calculator you can rerun with your own numbers. It also shows where the official API comes out cheaper, which happens more often than API vendors tend to admit. If you're budgeting for posting, DMs and outreach rather than data, XAutoDM's guide to X API pricing and cheaper alternatives covers the write side.

The X API prices that matter for reading data

X's pricing page lists every rate. Below are the read rates a data workload touches, as listed on Oct 14, 2026:

Four billing rules on that page change the math:

1. You pay per resource, not per request. A search that returns 100 posts costs $0.50. A search that returns nothing costs nothing.
2. Charges are deduplicated within a UTC day. If you're charged for a post and request it again before midnight UTC, you aren't charged twice. X calls this "a soft guarantee."
3. Post reads are capped at 3 million per monthly billing cycle. Past that, X says to move to Enterprise.
4. There is no minimum: "No subscriptions, contracts, or minimum spend." You buy credits and can set a spending limit. Requests stop when the balance hits zero.

New accounts also get starter money. X's free credit page gives a new pay-per-use account $20 for saving its first eligible card, and matches the first auto-recharge up to $50. Those credits expire three months after they're granted.

How ChatterAPI prices the same reads

ChatterAPI is an independent API for X and Reddit data and is not affiliated with X Corp. Every X read endpoint costs 3 credits per call, and each call returns one page of about 20 rows: tweet search, timelines, followers, replies and list members. Failed calls cost 0 credits.

The plans are Starter at $19 a month for 25,000 credits, Growth at $49 for 70,000 and Scale at $149 for 240,000. Subscribers can buy top-ups of $10 (9,000 credits), $50 (47,500) or $100 (100,000).

At Starter rates a credit costs $0.00076. A full 20-row page comes to about $0.0023, roughly $0.00011 a row, but that per-row number depends on two conditions:

• Your pages have to be full. ChatterAPI bills the call, not the rows, so a poll that returns two new tweets costs the same 3 credits as one that returns twenty.
• You have to use the plan. The smallest bill is $19, and monthly credits reset at each renewal, so a job that needs 450 credits a month still costs $19.

X bills rows, so its cost tracks how much data exists. ChatterAPI bills calls, so its cost tracks how often you ask.

Twitter API cost for three real workloads

All figures below come from the calculator further down, using the listed prices above and 30-day months.

Monitoring 20 keywords

Say you track 20 keywords and poll each one through search. What changes the cost is how many new tweets each keyword gets a day and how often you poll.

In the quiet case, the official API is cheaper. Hourly polls of quiet keywords mostly come back nearly empty. On X that costs nothing, and on ChatterAPI it costs 3 credits a call. Polling every three hours closes most of the gap. The busy case goes the other way. X charges for every one of the 300,000 posts, while ChatterAPI charges for about two pages per poll.

The busy case also uses 10% of X's 3 million monthly post-read cap, so one product with 200 busy keywords would hit the cap. Our Twitter keyword alerts guide has the polling script itself.

Exporting 10 accounts' followers

Per-row billing adds up fastest on follower exports. Every follower is a $0.010 user read, and you can't skip rows.

Your own account is the exception. Owned Reads cost $0.001 per resource, so exporting 20,000 of your own followers on X costs $20, and the $20 card credit covers that. For a one-off export of your own followers, the official API is close to free. For anyone else's followers, it's the most expensive read on the price list. The free X follower exporter shows the ChatterAPI output without code, and our follower tracker guide covers repeated snapshots.

Archiving timelines

Archiving has two parts: a one-time backfill and a daily top-up. X's own timeline endpoint returns up to the 3,200 most recent posts per account, so we use that as the backfill ceiling here.

The last row matters most. A small archive costs pennies on X and the full $19 minimum on ChatterAPI, and X's $20 starter credit pays for months of it. If you go the API route, our post on searching tweets by date has an archive script.

A Twitter API cost calculator you can rerun

This is the calculator behind every table above. Change the inputs at the bottom to match your job. It only needs the standard library.

import math

# X pay-per-use, as listed on docs.x.com on Oct 14, 2026 (USD per resource returned)
X_POST_READ = 0.005
X_USER_READ = 0.010   # also Following/Followers: Read

# ChatterAPI: 3 credits per read page of about 20 rows
CREDITS_PER_PAGE, ROWS_PER_PAGE = 3, 20
PLANS = [("Starter", 19, 25_000), ("Growth", 49, 70_000), ("Scale", 149, 240_000)]
TOPUPS = [(10, 9_000), (50, 47_500), (100, 100_000)]

def chatter_plan(credits):
    """Cheapest plan, plus top-ups if needed, that covers a monthly credit need."""
    best = None
    for name, price, included in PLANS:
        cost, extra, need = price, [], credits - included
        while need > 0:
            usd, cr = next(((u, c) for u, c in TOPUPS if c >= need), TOPUPS[-1])
            cost += usd; extra.append(usd); need -= cr
        label = name + "".join(f" + ${u} top-up" for u in extra)
        if best is None or cost < best[0]:
            best = (cost, label)
    return best

def monitor_keywords(keywords, new_per_kw_day, polls_per_day, days=30):
    x = keywords * new_per_kw_day * days * X_POST_READ
    per_poll = new_per_kw_day / polls_per_day
    pages = keywords * polls_per_day * max(1, math.ceil(per_poll / ROWS_PER_PAGE)) * days
    return x, pages * CREDITS_PER_PAGE

def export_followers(accounts, avg_followers):
    rows = accounts * avg_followers
    return rows * X_USER_READ, math.ceil(rows / ROWS_PER_PAGE) * CREDITS_PER_PAGE

def show(label, x_usd, credits):
    usd, plan = chatter_plan(credits)
    print(f"{label:<42} X: ${x_usd:>9,.2f}   ChatterAPI: {credits:>7,} credits -> ${usd} ({plan})")

show("20 quiet keywords (10/day), hourly polls", *monitor_keywords(20, 10, 24))
show("20 busy keywords (500/day), hourly polls", *monitor_keywords(20, 500, 24))
show("Followers: 10 accounts x 20,000", *export_followers(10, 20_000))

Output:

20 quiet keywords (10/day), hourly polls   X: $    30.00   ChatterAPI:  43,200 credits -> $49 (Growth)
20 busy keywords (500/day), hourly polls   X: $ 1,500.00   ChatterAPI:  86,400 credits -> $99 (Growth + $50 top-up)
Followers: 10 accounts x 20,000            X: $ 2,000.00   ChatterAPI:  30,000 credits -> $29 (Starter + $10 top-up)

The script makes two simplifications. The keyword model assumes new tweets spread evenly across polls. It also ignores X's daily deduplication, which only helps you when the same post is fetched twice in one UTC day. Neither one changes which side wins in any row above.

When the official X API is the cheaper choice

Go direct to X when any of these is true:

• Your monthly X bill would be under about $19. At small volume no plan minimum beats pay-per-use, and the $20 card credit plus the auto-recharge match can cover the first months outright.
• You mostly read your own data. Owned Reads at $0.001 make dashboards over your own posts, followers and bookmarks cheap. @cooperx86 spotted one limit early: owned_lists returns information about your lists, but "you still need to fetch the actual tweets at $0.005 a go" (post).
• You poll many quiet queries often. X doesn't charge for empty responses.
• You need first-party access, X's newest endpoints, or posting. Our X API key guide walks through setup.

Per-row pricing hurts once volume grows. Before the Owned Reads cut, @KSimback wrote that "it was super expensive just to read my own feed, I often spent $1-2 a day!" (post). A builder working on crypto analytics summed up the problem: "X API is $0.005/tweet with no subscription" (post). @Jasonfx90 built an unfollow detector by diffing follower snapshots and said it "costs a lot" (post). The table explains why: every follower diff rereads the whole list at $0.010 a row.

Check a real request and its cost

Every ChatterAPI response carries a credits block, so you can measure a job instead of estimating it. Below is a tweet search. The response is a real sample recorded with a test key (test calls show charged: 0), trimmed to the useful fields:

curl "https://api.chatterapi.com/v1/x/tweets/search?q=%22crm+recommendation%22&sort=latest" \
  -H "Authorization: Bearer $CHATTERAPI_KEY"

{
  "data": [
    {
      "id": "2099495333231288346",
      "url": "https://x.com/HesomParhizkar/status/2099495333231288346",
      "createdAt": "2026-09-14T13:47:48.000Z",
      "likes": 2,
      "replies": 2,
      "views": 138,
      "author": { "handle": "HesomParhizkar", "followers": 584 }
    }
  ],
  "page": { "nextCursor": "AcWNIo1WFWYR…", "hasMore": true },
  "credits": { "charged": 0, "remaining": 717 },
  "requestId": "req_01M4X7DSE2G3Y0T7G3M8"
}

That page held 20 tweets. On a live key it costs 3 credits. On X's official API, the same 20 posts would cost $0.10. Log credits.charged per job for a week and you'll have your real Twitter API cost from measurement, not a guess. To run the same search without code, use the free X tweet search tool, or read timelines in the X timeline scraper.

The same key and balance cover Reddit too. Our guide to scraping Twitter and Reddit together prices a mixed job, and the comparison with other third-party X APIs and the snscrape alternative page cover the other routes. To see what you can do for $0 first, read is the X API free.

Try it

Run your own numbers through the calculator, then test the most expensive part of your workload on real data. Sign up with Google to get 100 free credits without a card. That covers about 33 pages of tweets or followers. Plans start at $19 a month for 25,000 credits.