Twitter (X) scraper API

Social & communities · v1.0.0 · x_user_tweets

$0.00025 / tweet

$0.25 / 1K · pay per delivered tweet

A Twitter scraper API for X profiles: send usernames or profile URLs and get each profile’s latest public tweets as rows, with the full text and its links expanded, exact like, reply, repost and quote counts, the date and the language, and photos and MP4 videos. No X API key and no login, billed per tweet delivered.

By Aldo Morese, founder of QuanticData · Published Oct 30, 2026

Get my free API key See the request

$0.00025 per delivered tweet · $2 free every month · Failed runs never billed

What it does

What a Twitter scraper does

Most tweet data is wanted for a short list of accounts: the brands you compete with, the people your market listens to, your own profile. Give the collector the handles and it returns what each profile posted most recently, about twenty items per profile, ready to store or to compare with yesterday. Replies and reposts are flagged, and you can turn either off to keep only what the account wrote itself.

On 30 October 2026 we read NASA’s profile: of its 20 latest items, 8 were tweets NASA wrote, 5 were replies and 7 were reposts. The most liked item on the timeline was a repost at 14,675 likes, which is the original tweet’s count, while NASA’s own best was a video post at 8,017. That is why a repost row carries the original’s text and numbers and is flagged with is_retweet: whose content performed is a different question from what an account shared.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`usernames`	string[]	yes	X handles, with or without @, or profile URLs, one per line, up to 20.
`include_replies`	boolean	no	Deliver the profile's replies to other tweets too (default true).
`include_retweets`	boolean	no	Deliver the profile's reposts too (default true).
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many tweets to deliver at most (1–200). You pay only for delivered tweets.

Outputs — 28 fields, one row per tweet

What one tweet looks like

Every delivered tweet carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`username`	string	Profile handle.
`author_name`	string · nullable	Profile display name.
`author_followers`	integer · nullable	Profile follower count.
`author_verified`	boolean	Verified badge on the profile.
`tweet_id`	string	Tweet id.
`url`	string	Tweet URL.
`created_at`	string · nullable	Posted at (ISO 8601).
`text`	string	Full text, t.co links expanded (the original's text for a repost).
`lang`	string · nullable	Language code X assigned.
`likes`	integer · nullable	Exact like count.
`replies`	integer · nullable	Exact reply count.
`retweets`	integer · nullable	Exact repost count.
`quotes`	integer · nullable	Exact quote count.
`is_retweet`	boolean	True for a repost; text and counts are the original tweet's.
`retweeted_user`	string · nullable	Handle of the reposted author.
`original_tweet_id`	string · nullable	Id of the reposted tweet.
`is_reply`	boolean	True for a reply.
`in_reply_to_user`	string · nullable	Handle replied to.
`in_reply_to_tweet_id`	string · nullable	Tweet id replied to.
`conversation_id`	string · nullable	Thread (conversation) id.
`is_quote`	boolean	True when the tweet quotes another.
`quoted_tweet_id`	string · nullable	Id of the quoted tweet.
`hashtags`	string[]	Hashtags used.
`mentions`	string[]	Handles mentioned.
`links`	string[]	Expanded link URLs.
`media`	object[]	Photos and videos: type, url, alt_text, video_url (best MP4), duration_seconds.
`possibly_sensitive`	boolean	X's sensitive-media flag.
`rank`	integer	1-based delivery order.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/x_user_tweets/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/x_user_tweets/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["NASA"],"max_results":20}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/x_user_tweets/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "usernames": ["NASA"],
        "max_results": 20
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/x_user_tweets/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"usernames":["NASA"],"max_results":20}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the x_user_tweets collector with usernames=["NASA"]

Example response

POST /v1/scraper/collectors/x_user_tweets/run

$ curl $QD/x_user_tweets/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"usernames": ["NASA"], "max_results": 20}'
{ "status": "done", "count": 20,
  "results": [
    {
      "username": "…",
      "text": "…",
      "likes": "…",
      "created_at": "…" } ],
  "cost": 0.005 }
# 20 tweets × $0.00025 · nothing delivered, nothing charged

Try it

X profile tweets, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Twitter (X) scraper API: from usernames, QuanticData reads the Twitter (X) page and returns one row per tweet with author_name, username and author_followers, at $0.00025 per delivered tweet. — You send X usernames; their latest public tweets come back as rows with username, text and exact likes — 28 fields on every row — and you are billed $0.00025 for each tweet actually delivered, nothing for a run that delivers none.

$0.00025 / tweet8,000 tweets on the free $2 every month

Semantic inputusernames, include_replies, include_retweets — no URL lists

Up to 200tweets per run, pagination handled for you

28 fieldsone row per tweet

Pricing

Twitter (X) Scraper API pricing

$0.00025 per delivered tweet. A run that delivers nothing costs nothing, and the $2 monthly allowance covers about 8,000 tweets before you spend anything.

$0.00025per delivered tweet$0.25 per 1,000 delivered tweets

8,000 tweetson the free allowance$2 every month, no card

Zero rowszero chargea run that delivers nothing is free

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the Twitter scraper

Three shapes of work this endpoint was designed around.

Brand and competitor tracking

Read the timelines of the accounts you follow every day and keep the history: what they posted, what got engagement, which links they pushed.

A watchlist for social listening

Analysts, founders or journalists in your market, read on a schedule: their latest takes as rows you can search and alert on, next to the threads the Reddit scraper API returns.

Datasets for AI and research

Text, language, hashtags, mentions and exact counts per tweet: the fields a classifier or a study needs, without a developer account on X.

Twitter (X) Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Access	A developer account, or the cookies of an account you risk	One API key, no X account involved
Counts	“12K” labels to parse	Exact likes, replies, reposts and quotes
Reposts	Mixed in with the account’s own tweets	Flagged, with the original tweet’s text and counts
Links	t.co short links	Expanded to the real address
Video	A player to dig out	MP4 address and duration as fields
Billing	Calls, whatever they return	Only delivered tweets

Twitter (X) scraper API: the POST to the x_user_tweets collector, 20 tweets delivered and the bill, 20 × $0.00025 = $0.005 in usage.cost_usd; zero tweets would cost $0. — The same call you would paste into a terminal: a Bearer key, the usernames in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many tweets arrived and usage.cost_usd is $0.005, which is 20 × $0.00025. A run that delivers nothing costs nothing.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Twitter scraper.

Something else? Ask us

Can I scrape Twitter without an API key?

Yes. You need a QuanticData key, not one from X: the collector reads each profile’s public timeline without logging in and without a developer account, and returns the tweets as JSON. X’s own API is sold per post read through a developer account.

Is Twitter scraping still possible in 2026?

For public profiles, yes. Send up to 20 usernames in one run and each returns its latest public tweets, about twenty per profile, with exact counts, media and expanded links.

Is scraping Twitter legal?

The collector reads only what X shows publicly to a visitor who is not signed in. How you may use the data depends on X’s Terms of Service and on the law where you work, so check both for your use case.

Can I get only the tweets an account wrote itself?

Yes. Set include_replies and include_retweets to false and the run delivers only the profile’s own posts. Both are on by default.

Is there a free Twitter scraper?

Every account gets $2 of credit every month with no card, which is about 8,000 delivered tweets on this endpoint at $0.00025 each. It renews monthly, and a run that delivers nothing is never billed.

How much does one run cost?

Multiply the rows you actually receive by $0.00025. A run capped at 200 tweets — the maximum for this collector — costs $0.05 if every row comes back, and less when the listing has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Twitter scraper now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key