If your code calls the X API with expansions=author_id, your bill is about to change. On the pay-per-use (PPU) plan, the user, post, media, poll and place objects that come back in the includes section of a response have not counted toward usage. From 22 November 2026 they do, at the same rate as a direct lookup. For a keyword monitor that pulls each post's author, that can mean the author objects cost more than the posts themselves.
This post covers what X announced, which rates X's own pages show today, three worked cost examples with labeled inputs, a standard-library Python script that estimates the change from responses you've saved, and ways to cut the bill.
Rates and rules below come from three X pages opened on 16 Nov 2026: the X Developer Community announcement [Inform] X API PPU - Expansions Update (posted 23 Oct 2026), the docs page X API pay-per-usage pricing and credits, and the docs page Usage and Billing. All prices are in USD and are as of 16 Nov 2026. X says prices are subject to change and that current rates are always in the Developer Console, so check there before you budget. Appie details are from appie.run/pricing and appie.run/twitter-marketing, checked 16 Nov 2026. The estimator script was tested on Python 3.13.5 against fixture JSON files, not live API calls.
Disclosure: Appie.run publishes this article. Appie's Twitter Marketing app, covered in one short section near the end, is our product. Nothing else in this post depends on it.
What X announced
The forum post from the X Developer Platform team says that on PPU, "usage is based on the data objects the API returns," and that "right now, objects that come back through expansions aren't counted towards usage." Then the change:
"From November 22nd, objects returned through expansions will be billed at the standard PPU rate for that resource, the same as direct lookups. This covers post, user, media, poll and place expansions."
The post lists the rates:
- Object returned through an expansion: Post; Rate per resource (X forum post, read 16 Nov 2026): $0.005; Also on the docs pricing page today?: Yes, as "Posts: Read" $0.005 per resource
- Object returned through an expansion: User; Rate per resource (X forum post, read 16 Nov 2026): $0.010; Also on the docs pricing page today?: Yes, as "User: Read" $0.010 per resource
- Object returned through an expansion: Media; Rate per resource (X forum post, read 16 Nov 2026): $0.005; Also on the docs pricing page today?: No, not listed
- Object returned through an expansion: Poll; Rate per resource (X forum post, read 16 Nov 2026): $0.005; Also on the docs pricing page today?: No, not listed
- Object returned through an expansion: Place; Rate per resource (X forum post, read 16 Nov 2026): $0.005; Also on the docs pricing page today?: No, not listed
X calls this "not a new pricing model," and that is accurate: the Post and User rates are the same ones you already pay for data. What changes is how many objects count.
Some gaps you should know about, because X's pages don't fill them as of 16 Nov 2026:
- No time of day or time zone. The post says "November 22nd." X's pricing docs say deduplication resets at midnight UTC, so the safe plan is to treat 00:00 UTC on 22 Nov as the start. That is 7:00 PM EST and 4:00 PM PST on Saturday 21 Nov, and 5:30 AM IST on 22 Nov. This is our planning assumption, not X's statement.
- The docs haven't caught up. The Expansions page doesn't mention billing, the pricing page has no Media, Poll or Place rows, and the changelog had no entry about this change when we checked.
-
Owned Reads. Your own app reading your own mentions (
GET /2/users/{id}/mentions) is billed at $0.001 per resource as an Owned Read. X doesn't say whether the users expanded on that call get the $0.001 rate or the standard $0.010. The post says "standard PPU rate for that resource," so the examples below use $0.010. - The 3 million cap. PPU is capped at 3 million Post reads per monthly billing cycle. X doesn't say whether expanded posts count toward that cap.
The billing rules that shape the math
These come from the two docs pages and apply to every example below:
-
Reads are charged per resource returned. Ten posts in
dataare ten Post reads. With the change, three distinct users inincludes.usersare three User reads on top. - Daily deduplication. "All resources are deduplicated within a 24-hour UTC day window," and this "applies to all billable resources (Posts, users, etc.)". The same author on 40 posts in one UTC day is charged once that day and again the next day. X calls deduplication "a soft guarantee" and says edge cases such as outages may not be deduplicated.
- Failed requests aren't billed. "Only successful responses that return data are billed."
- Spending limits and auto-recharge are set in the Developer Console. When a spending limit is reached, requests are blocked until the next billing cycle.
Worked math: three common workloads
Every volume below is an example input, chosen to show how the change scales. None of them is a measured average. Replace them with your own counts (the script in the next section gets them from your saved responses).
Example 1: keyword listening with recent search
A monitor runs GET /2/tweets/search/recent for a brand name and a few competitor phrases, with expansions=author_id,referenced_tweets.id,attachments.media_keys.
Example inputs per month: 1,000 matching posts; 700 author objects after daily dedup (some authors post more than once a day); 250 referenced posts (the post being replied to, quoted or reposted); 200 media objects.
- Line: Posts in
data: 1,000 × $0.005; Before 22 Nov: $5.00; From 22 Nov: $5.00 - Line: Authors in
includes.users: 700 × $0.010; Before 22 Nov: $0.00; From 22 Nov: $7.00 - Line: Referenced posts in
includes.tweets: 250 × $0.005; Before 22 Nov: $0.00; From 22 Nov: $1.25 - Line: Media in
includes.media: 200 × $0.005; Before 22 Nov: $0.00; From 22 Nov: $1.00 - Line: Total; Before 22 Nov: $5.00; From 22 Nov: $14.25
The same query costs 2.85 times as much, and the authors alone cost more than the posts. At 10 times the volume (10,000 posts, 7,000 authors, 2,500 referenced posts, 2,000 media) the total goes from $50.00 to $142.50.
Example 2: a reply tool that fetches thread context
A reply tool may pull the whole conversation before a reply is written, so the reply makes sense: a search on conversation_id:<id> with expansions=author_id,in_reply_to_user_id.
Example inputs per month: 300 threads opened for triage; 12 posts per thread on average; 8 distinct users per thread.
- Line: Thread posts: 300 × 12 = 3,600 × $0.005; Before 22 Nov: $18.00; From 22 Nov: $18.00
- Line: Thread users: 300 × 8 = 2,400 × $0.010; Before 22 Nov: $0.00; From 22 Nov: $24.00
- Line: Total; Before 22 Nov: $18.00; From 22 Nov: $42.00
If your tool also sends replies through the API, writes are a separate line: X lists "Post: Create" at $0.015 per request and "Post: Create (with URL)" at $0.200 per request. A reply with a link costs about 13 times a reply without one.
Example 3: your own mentions on the Owned Reads rate
An app reads mentions of its own account through GET /2/users/{id}/mentions with expansions=author_id.
Example inputs per month: 2,000 mentions; 1,200 author objects after daily dedup.
- Line: Mentions as Owned Reads: 2,000 × $0.001; Before 22 Nov: $2.00; From 22 Nov (assuming the standard User rate): $2.00
- Line: Authors: 1,200 × $0.010; Before 22 Nov: $0.00; From 22 Nov (assuming the standard User rate): $12.00
- Line: Total; Before 22 Nov: $2.00; From 22 Nov (assuming the standard User rate): $14.00
This is the workload where the change hurts most in relative terms, because the posts are on a 1,000-for-$1 rate and the users aren't. If X applies the Owned Reads rate to these users, the new line is $1.20 instead of $12.00. Check your Developer Console in the first days after 22 Nov to see which rate you are charged.
Estimate your own change with Python (standard library only)
Guessing volumes is the weak part of the examples above. If you log raw API responses, you can count the objects directly. Save each response as JSON in a folder per UTC day (for example responses/2026-11-23/page1.json) and run this:
#!/usr/bin/env python3
"""Estimate X API pay-per-use cost for saved v2 responses, before and after
expansion objects are billed. Rates: X Developer Community post
"[Inform] X API PPU - Expansions Update" and docs.x.com pricing, read 16 Nov 2026.
Edit RATES if your Developer Console shows different numbers."""
import json
import sys
from pathlib import Path
RATES = { # USD per resource
"posts": 0.005, # data[] posts and includes.tweets
"users": 0.010,
"media": 0.005,
"polls": 0.005,
"places": 0.005,
}
INCLUDE_KEYS = {"tweets": "posts", "users": "users", "media": "media",
"polls": "polls", "places": "places"}
def object_ids(resp):
"""Yield (kind, id, from_expansion) for every billable object in a response."""
data = resp.get("data") or []
if isinstance(data, dict):
data = [data]
for post in data:
yield "posts", post["id"], False
for key, kind in INCLUDE_KEYS.items():
for obj in resp.get("includes", {}).get(key, []):
oid = obj.get("id") or obj.get("media_key")
yield kind, oid, True
def main(paths):
# One set per UTC day folder mimics X's daily dedup.
direct, expanded = {}, {}
for p in paths:
day = Path(p).parent.name # e.g. responses/2026-11-23/page1.json
resp = json.loads(Path(p).read_text())
for kind, oid, from_exp in object_ids(resp):
seen_direct = direct.setdefault(kind, set())
seen_exp = expanded.setdefault(kind, set())
key = (day, oid)
if from_exp:
if key not in seen_direct:
seen_exp.add(key)
else:
seen_direct.add(key)
seen_exp.discard(key)
before = sum(len(direct.get(k, ())) * r for k, r in RATES.items())
extra = sum(len(expanded.get(k, ())) * r for k, r in RATES.items())
print(f"{'object':<8}{'direct':>8}{'expanded':>10}{'new cost':>10}")
for k, r in RATES.items():
d, e = len(direct.get(k, ())), len(expanded.get(k, ()))
print(f"{k:<8}{d:>8}{e:>10}{e * r:>10.3f}")
print(f"before 22 Nov: ${before:.3f}")
print(f"from 22 Nov: ${before + extra:.3f} (+${extra:.3f})")
if __name__ == "__main__":
main(sys.argv[1:])
Run it with python3 x_expansion_cost.py responses/*/*.json. Here is real output from a fixture of four saved search pages over two UTC days (50 posts per page, 40 possible authors, some replies and photos):
object direct expanded new cost
posts 200 52 0.260
users 0 74 0.740
media 0 40 0.200
polls 0 0 0.000
places 0 0 0.000
before 22 Nov: $1.000
from 22 Nov: $2.200 (+$1.200)
The 200 posts cost $1.00 either way; the new $1.20 is all includes. The 74 user objects are counted per UTC day, so an author who posts on both days is charged twice and an author who posts ten times in one day is charged once.
Limits: the script applies standard rates everywhere, so it overstates the Owned Reads case in Example 3, and it can't model the edge cases X's "soft guarantee" on dedup leaves open. Treat the total as an estimate and compare it with the Developer Console after 22 Nov.
Ways to cut the bill
Roughly in the order we'd do them.
-
Audit every
expansions=parameter. Search your codebase forexpansions. Expansions are often copied from a docs example (X's own "Full post context" pattern asks forauthor_id,attachments.media_keys,referenced_tweets.id) and never trimmed. If your listening dashboard never renders images,attachments.media_keysis pure cost from 22 Nov. In Example 1 that is $1.00 of $14.25. -
Cache users across days instead of expanding on every call. Deduplication resets every midnight UTC, so a regular author is charged again every day you expand them. Drop the
author_idexpansion from the search, keeptweet.fields=author_idso each post still carries its author's ID, and callGET /2/users?ids=(up to 100 IDs per request, same $0.010 User rate) only for IDs not already in your cache. Example input: if Example 1's 700 daily author objects are 350 distinct accounts over the month, a 30-day cache cuts that line from $7.00 to $3.50. -
Filter before you enrich. Score posts on their text first, then fetch context only for the ones a person will look at. If only 50 of Example 1's 250 replies are worth answering, fetching their parent posts with
GET /2/tweets?ids=costs $0.25 instead of $1.25. Run the second pass in the same UTC day as the search so any post you fetch again is deduplicated. -
Tighten the query.
-is:retweet,lang:and excluding your own handle (operators listed in X's search operators docs) cut posts and every object those posts pull intoincludes. A repost is the worst case: you pay for the repost, the original inincludes.tweets, and possibly the original's author. - Stay inside one UTC day. If you poll several times a day, schedule the runs so they don't straddle 00:00 UTC. In November that is midnight in London, 1 AM in Berlin and 7 PM Eastern the evening before.
-
Use Owned Reads where they apply. For your own account's mentions, the mentions timeline at $0.001 per post is far cheaper than searching for
@yourhandleat $0.005, even if the expanded users end up at $0.010. -
Set a spending limit and watch usage. A spending limit in the Developer Console blocks requests when it's reached, which is better than finding a drained balance. X's docs also describe a Usage endpoint,
GET /2/usage/tweets, that returns daily Post consumption, so you can compare the week before 22 Nov with the week after.
Where Appie fits
Appie is our product. Its Twitter Marketing app tracks your handle, keywords, competitors and buyer pain phrases in a Growth project. You start each scan yourself, X is scanned at most once a day, and you can generate a reply draft for any relevant post from that scan. Appie never posts: you copy the draft and post it from your own X account. It is not a real-time alerting tool.
Per appie.run/pricing as of 16 Nov 2026, a Mention Scan costs 10 credits per Reddit or Twitter scan and a Response Draft costs 2 credits. The page says one dollar equals 100 credits. Example: one scan a day for 30 days is 300 credits; drafting 20 replies adds 40 credits, for 340. The Free plan has 500 credits once on signup and needs no credit card; Starter is $19/month for 2,000 credits and Standard is $49/month for 5,000.
Limits, so you can compare fairly: Appie's pages don't say how many posts a scan covers, so there's no per-post cost to set against the examples above. Appie doesn't give you raw X API access or per-object control over what is fetched. And these are Appie's prices as listed today; we're not claiming they can't change, or that changes on X's side never affect us.
If you keep your own script and only want help with the reply, Appie's free AI Reply Generator takes the post you're answering (pick "X (Twitter) Reply" as the source) and returns a draft you edit before sending. For the no-API route with saved searches, see How to monitor X (Twitter) mentions and reply without living in the app.
FAQ
What are X API expansions?
A request parameter that pulls related objects (the post's author, the post it replies to or quotes, attached media, polls and places) into the includes section of the same response, so you don't need a second request. X's Expansions page lists them per object type.
When does X start charging for expansions?
22 November 2026, per X's developer forum post of 23 Oct 2026. The post gives a date but no time or time zone. Because X's billing day runs on UTC, plan for 00:00 UTC on 22 Nov.
How much does an expanded object cost?
Per X's post, read 16 Nov 2026: $0.005 per post, $0.010 per user, $0.005 per media object, $0.005 per poll and $0.005 per place. The Post and User rates match X's docs pricing page. Media, Poll and Place weren't on the docs pricing page when we checked, so the forum post is the only X source for those three.
Does deduplication apply to expanded objects?
X's pricing page says deduplication within a 24-hour UTC day "applies to all billable resources (Posts, users, etc.)". The forum post doesn't address expansions and dedup specifically, so confirm in your Developer Console.
Do user.fields or tweet.fields cost extra?
X's post describes billing per data object returned, and fields add data to an object rather than adding objects. But X doesn't state this outright for fields, so test with a small request and check usage.
Wrap-up
The expansion change doesn't touch X's rates. It changes which objects count, and in all three examples above the biggest new line is users at $0.010 each. Before 22 Nov, grep for expansions, remove what you don't render, move author lookups behind a cache, and set a spending limit. Then run the estimator on a day of saved responses and compare it with the Developer Console in the first week after the change.
RG, Founder, Appie.run
Top comments (0)