Twitter Scraper - X Tweets, Profiles, Followers & Search avatar

Twitter Scraper - X Tweets, Profiles, Followers & Search

Pricing

from $0.25 / 1,000 result rows

Go to Apify Store
Twitter Scraper - X Tweets, Profiles, Followers & Search

Twitter Scraper - X Tweets, Profiles, Followers & Search

Twitter scraper, X scraper and tweet scraper with no login and no cookies. Scrape tweets from Twitter search by keyword, hashtag, user or date, the tweets of any Twitter profile, and Twitter followers and following lists. Export JSON, CSV or Excel. From $0.30 per 1,000 rows.

Pricing

from $0.25 / 1,000 result rows

Rating

4.9

(10)

Developer

JEB

JEB

Maintained by Community

Actor stats

30

Bookmarked

2.5K

Total users

291

Monthly active users

3 hours ago

Last modified

Features

Limited permissions

Share

Scweet — Twitter Scraper and X Scraper

Extract tweets, replies, lists and follower lists from Twitter and X into JSON, CSV, XLSX and 4 more formats. No API key, no cookies, no account setup — just configure your job and Scweet handles the rest.

Run on Apify | Open-Source Library


What Scweet Does

  • Two modes, one form — Tweets reads search terms, profile timelines, the replies of a tweet and the tweets of a list, all in one run. Followers & following reads the followers, the following or the verified followers of profiles.
  • Paste what you have — a handle, a profile URL, a tweet URL, a list URL, a search URL or the followers URL of a profile. Scweet reads each one as what it is.
  • Search that goes deep — every operator of the X search works: keywords, hashtags, users, engagement, date range, language, location, and more.
  • Sensitive tweets included — search results and replies include the tweets that X hides behind its filter for sensitive content. Add filter:safe to a search term to leave them out.
  • Your input from another Twitter scraper works — the field names of other Twitter scrapers on Apify run here as they are, so you can switch without a change.
  • Deduplicated billing — you only pay for unique rows. A tweet appears once in a run, and a profile appears once in each list, as if each list were its own run.
  • Production-grade reliability — automatic retries, adaptive rate limiting, and built-in resilience keep runs stable at scale.

Use cases

Brand monitoring, lead generation, market research, academic datasets, OSINT, content strategy.

Pricing

PlanPer 1,000 rowsRun-start fee, for each GB of memory
Free$0.30$0.006
Starter$0.30$0.006
Scale$0.28$0.006
Business$0.25$0.006

You pay only for unique, deduplicated rows. A tweet and a profile cost the same. A run uses 1 GB of memory by default and can use up to 2 GB; the run-start fee applies once for each GB, so a run at 2 GB pays $0.012.

Free trial: 3,000 tweets, up to 1,000 in a run, one run at a time. Every free run tells you how many tweets remain.


Quick Start

  1. Open Scweet on Apify.
  2. Paste one of the inputs below, or fill the form.
  3. Run the Actor.
  4. Export your dataset (JSON, JSONL, CSV, XLSX, HTML, XML or RSS).
{
"scrape": "tweets",
"search_terms": ["bitcoin lang:en -filter:replies min_faves:100", "#AI from:OpenAI"],
"since": "2026-01-01",
"until": "2026-02-01",
"search_sort": "Latest",
"max_items": 1000
}

Profiles, a tweet with its replies, and a list, in one run

{
"scrape": "tweets",
"urls": [
"NASA",
"https://x.com/SpaceX",
"https://x.com/NASA/status/2120910178711466211",
"https://x.com/i/lists/1039292499909476352"
],
"max_items": 800
}

The run shares the 800 results equally across the four inputs first: the timeline of each profile, the tweet and its replies, and the latest tweets of the list. When an input has fewer results than its share, the other inputs fill the rest.

Followers & following

{
"scrape": "followers",
"urls": ["NASA", "https://x.com/SpaceX/following"],
"relationships": ["followers", "verified_followers"],
"max_items": 1500
}

NASA gives two lists: its followers and its verified followers. The SpaceX URL names its own list, the profiles that SpaceX follows. Each row is one profile.

The form opens with an example. Replace it with your own input before you run.


Use Scweet from your code, n8n, Make, Zapier or an AI agent

Every input of this page works the same way outside the form. In each example, replace <YOUR_API_TOKEN> with your token from Apify Console > Settings > API & Integrations, and keep the rest as it is.

The API: one call, the rows come back

curl -X POST "https://api.apify.com/v2/acts/altimis~scweet/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
-H "Content-Type: application/json" \
-d '{"scrape": "tweets", "search_terms": ["#AI lang:en"], "search_sort": "Latest", "max_items": 100}'

The call waits for the run and returns the rows as JSON. It waits 5 minutes at most, so for a large job, start the run with a client below and read the rows when it finishes.

Python

# pip install apify-client
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("altimis/scweet").call(run_input={
"scrape": "tweets",
"search_terms": ["from:NASA"],
"search_sort": "Latest",
"max_items": 100,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
print(row["tweet"]["created_at"], row["tweet"]["text"])

JavaScript

// npm install apify-client
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('altimis/scweet').call({
scrape: 'tweets',
search_terms: ['from:NASA'],
search_sort: 'Latest',
max_items: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((row) => console.log(row.tweet.created_at, row.tweet.text));

An AI agent: Claude, Cursor or any MCP client

Connect your client to the Apify MCP server with Scweet as a tool:

https://mcp.apify.com?tools=altimis/scweet

In Claude Code, run claude mcp add apify "https://mcp.apify.com?tools=altimis/scweet" -t http. The agent receives the tool altimis--scweet, which takes the same input as the form. Then ask, for example: "Get the 100 latest tweets with #AI in English and summarize what people say."

n8n, Make and Zapier

Apify has an official integration in each of them. Select the Actor altimis/scweet and paste an input from this page.

ToolThe step that runs ScweetThe step that reads the rows
n8n, node ApifyRun an Actor and get datasetthe same step
MakeRun an Actor, with Run synchronouslyGet Dataset Items
ZapierRun ActorFetch dataset items

The guides of Apify: n8n, Make, Zapier.


Monitor a term on a schedule

A monitor runs the same search again and again, and each run reads only the time since the run before. Give since as a date and time, and leave until empty: the run then reads from since to the moment it starts.

{
"scrape": "tweets",
"search_terms": ["\"your brand\" -filter:retweets"],
"search_sort": "Latest",
"since": "2026-11-19T08:00:00Z",
"max_items": 1000
}

Move since forward at each run:

  • In your code: set since to the time of the run before, for example in Python (datetime.now(timezone.utc) - timedelta(hours=1)).strftime("%Y-%m-%dT%H:%M:%SZ") for an hourly monitor.
  • In n8n: start the workflow with a Schedule Trigger, and give since the expression {{ $now.minus({ hours: 1 }).toISO() }}.
  • In Make or Zapier: start the scenario or the Zap with a schedule, and compute since with a date formula: the current time minus the interval.

A schedule in the Apify Console sends the same input each time, so it cannot move since. Use one of the three ways above for a monitor.

Each run pays the run-start fee once, also a run that finds no new tweet. For a quiet term, a run every few hours costs less than a run every few minutes and gives the same rows.


Input Reference

What to scrape

scrapeWhat you getWhat you give
tweets (default)tweetssearch terms, profiles, tweets, lists
followersone row for each profile in the listsprofiles

The Followers & following mode ignores search terms, tweets and lists, and the log says so.

Fields

FieldTypeDescription
scrapestringtweets (default) or followers
search_termsarraySearch terms. One search on each line, as you type it on X. Operator reference
urlsarrayX links or @handles. A handle, or the link of a profile, a tweet, a list, a search page, or the followers or following page of a profile
max_itemsintegerMaximum results for the whole run, at least 100 (default: 1000). Each input first gets an equal share
relationshipsarrayWhich lists, for Followers & following: followers (default), following, verified_followers. The form shows them as Followers, Following and Verified Followers
search_sortstringTop (default), Latest, or Latest + Top
since, untilstringDates for the search terms, as text: 2026-11-01 or 2026-11-01T08:00:00Z
langstringLanguage of the tweets, for example en, fr, ar
tweet_typestringall, originals_only, replies_only, retweets_only, exclude_replies, exclude_retweets
min_likes, min_retweets, min_repliesintegerEngagement
has_images, has_videosbooleanMedia

Through the API you can also send:

  • profiles, tweet_ids and list_ids as separate lists. Put a bare numeric ID in tweet_ids or list_ids, because a number alone does not say what it is.
  • per_input_limit, a hard maximum for each search term, profile, tweet or list. With it, an input with few results does not give its share to the others.
  • every field of the earlier form, listed below. A filter that the form does not show also works as an operator in a search term: write from:NASA, -word, "exact phrase" or filter:verified. The operator reference lists them all.

How the filters combine with a search term

Each filter of the form adds its operator to every search term, unless the term already holds that operator. For example, the term #AI min_replies:10 with min_likes 5 searches #AI min_replies:10 min_faves:5. Dates inside a term win over since and until. A search URL keeps the tab that it names (f=live for Latest, f=top for Top).

The input of another actor, and the earlier form

  • Other Twitter scrapers on Apify: searchTerms, startUrls, twitterHandles, tweetIDs, conversationIds, listIds, user_names, getFollowers, getFollowing, relation, maxItems, maxItemsPerTarget, maxFollowers, sort, queryType, start, end, tweetLanguage, onlyImage, onlyVideo, minimumFavorites and more work as they are. A field that only changes the output of another actor is ignored, and the log names it.
  • The earlier form of Scweet: source_mode, search_query, profile_urls, relationship, per_profile_limit and the builder fields (all_words, any_words, exact_phrases, exclude_words, from_users, to_users, mentioning_users, hashtags_any, hashtags_exclude, verified_only, blue_verified_only, has_links, has_mentions, has_hashtags, place, geocode, near, within) keep working, so a saved task runs as it is.
  • An unknown field is ignored, and the log names it.

Defaults and limits

  • max_items is the total for the whole run. Each input first gets an equal share of it, then the inputs with more results fill the rest.
  • Minimum run size: if max_items < 100, the run collects up to 100.
  • If both since and until are missing, lookback defaults to 4 years (Top) or 180 days (Latest).
  • Location filters depend on Twitter and X metadata and can be approximate.
  • Free trial: 3,000 tweets in total, up to 1,000 in a run, one run at a time. The last run receives what remains, and every free run states how many remain.
  • The same trial applies to every mode: tweets and follower lists count toward the one total.

Output

Results are stored in the Apify dataset and deduplicated, so you never pay for the same row twice. A tweet appears once in a run, even when two inputs find it. A profile appears once in each list: a profile that follows NASA and that NASA follows is a row of each list. Export as JSON, JSONL, CSV, XLSX, HTML, XML or RSS, with no row limit.

The shape of a row follows the mode. The Output tab of a run shows the Results in two views: Tweets for the search, the timelines, the replies and the lists, Profiles for the follower lists. A run fills one view. The Tweets view opens first, so the status message of a Followers & following run tells you to select the Profiles view. The column Input of each view names the input that found the row. In the Profiles view, the column List says whether the row is a follower, a following or a verified follower. The table of the console shows every row; to keep one list, export the dataset and filter the column, or filter source_root in your code.

How a run ended

A program that calls the actor does not read the log. So every run also writes how it ended in two places a program reads:

  • The status message of the run. One sentence, on the run object of the API (statusMessage) and at the top of the run in the Console. For a free run it holds the state of the trial: "Free trial: 1,200 of 3,000 used, 1,800 remain." When the input has a problem, the sentence names it.
  • The record OUTPUT in the key-value store of the run. The API serves it at /v2/key-value-stores/<storeId>/records/OUTPUT.
{
"outcome": "delivered",
"message": "Done! 1,000/1,000 tweets collected. Free trial: 1,200 of 3,000 used, 1,800 remain.",
"delivered": 1000,
"requested": 1000,
"free_trial": {"used": 1200, "total": 3000, "remaining": 1800},
"subscribe": "https://apify.com/pricing"
}

outcome is one of these words, so a program can branch on it:

outcomeMeaning
deliveredthe run met its target
delivered_partialthe run ended with fewer rows than the target; message says why
no_resultsnothing matched; message says what to change
trial_completethe free trial is spent; subscribe to continue
one_run_at_a_timea free plan runs one job at a time, and one was in progress
low_result_cooldowna free plan repeated a query that returns almost nothing; wait
quota_spenta paid plan met its daily limit
no_capacitythe service was at its capacity for a moment; retry in a few minutes
invalid_inputthe input holds no source or a bad value; message names the problem
errorthe run did not finish; retry

A run that stops before it starts to read X charges nothing: invalid_input, trial_complete, one_run_at_a_time, low_result_cooldown, quota_spent and no_capacity. A run that starts to read X pays the run-start fee once, also when X returns nothing.

When a run reads several inputs, the log names each input that gave no result. For the replies of a tweet, the log says how many replies X showed, because X hides some replies from every reader.

Fields of a tweet

FieldDescription
idTweet ID
textTweet text
handleAuthor handle
tweet_urlDirect link to tweet
favorite_count, retweet_count, reply_count, quote_count, bookmark_count, view_countEngagement metrics
created_atTweet creation time
collected_at_utcCollection timestamp (UTC)
langLanguage
conversation_idThread/conversation ID
in_reply_to_status_id, in_reply_to_user_id, in_reply_to_screen_nameReply references
quoted_status_idQuoted tweet ID
is_quote, is_replyConvenience flags
source_rootsearch, profile_url, tweet_replies (a tweet and its replies) or list_tweets
source_valueThe input that found the row: the effective query, the profile URL, the tweet URL or the list URL
search_sortFor a search: Top or Latest, the sort that found the row
requested_searchThe same value as source_value
userNested author object (handle, name, followers, bio, etc.)
tweetNested tweet details (media, entities, edit history, etc.)

Fields of a profile or a user

The Followers & following mode returns this shape instead. Each row is one profile, so a follower list also gives you the details of every profile in it.

FieldDescription
user_idNumeric ID of the profile
handleHandle, without the @
nameDisplay name
descriptionBio
followers_count, following_countCounts of the graph
tweets_count, media_tweets_countPosts, and posts that carry media
favourites_countLikes the profile gave
created_atDate the profile joined X
joined_atThe same value as created_at. The Profiles view reads this name
location, websiteAs the profile states them
verified, blue_verified, identity_verifiedMarks of verification
protected, possibly_sensitiveFlags of the profile
professional_typeFor example Creator, when X sets it
profile_image_url, profile_banner_urlImages
profile_urlLink to the profile
source_rootfollowers, following, or verified_followers
source_valueThe profile you asked for
requested_profileThe same value as source_value
collected_at_utcWhen the run read the row

Example (top-level fields)

{
"id": "1996300676012376299",
"handle": "FTB_Team",
"text": "We dug through the first month of StoneBlock 4...",
"favorite_count": 71,
"retweet_count": 5,
"reply_count": 10,
"view_count": "9695",
"tweet_url": "https://x.com/FTB_Team/status/1996300676012376299",
"created_at": "Wed Dec 03 19:29:05 +0000 2025",
"collected_at_utc": "2026-04-07T15:58:33.539740+00:00",
"lang": "en",
"source_root": "search",
"source_value": "(sample OR query) lang:en",
"search_sort": "Latest",
"requested_search": "(sample OR query) lang:en",
"is_quote": false,
"is_reply": false,
"user": { "handle": "FTB_Team", "name": "Feed The Beast", "followers_count": 43367, "..." : "..." },
"tweet": { "media": ["..."], "entities": { "..." : "..." }, "..." : "..." }
}

Tips

  • Choose the sort by the breadth of your query, not the size of your job. search_sort: "Latest" reads tweets in order of time, so it collects the most for a query with recent activity, at every order size. Top reads a ranked selection, so it repeats tweets once you ask for more than the ranking holds. The trade is that Latest depends on the window: it returns nothing when the period holds no post, where Top almost always returns something. So use Latest by default, and switch to Top only when a narrow query returns nothing over a range you cannot widen.
  • Use wider time ranges. The wider the since/until window, the more tweets X will surface. Scweet automatically splits wide ranges into parallel sub-intervals, so a large window does not slow down the run.
  • Start broad, then narrow. If you get fewer tweets than expected, try removing restrictive filters (min_likes, tweet_type, lang) one at a time to see which one is limiting results.
  • For large volumes from a single profile, use a search term instead of the profile. A profile URL is best for recent activity. For thousands of tweets from one profile, use the search term from:handle with a wide since/until range and search_sort: "Latest" for more complete results.
  • Date filters are handled internally. Scweet converts since and until to precise Unix-timestamp operators under the hood. You can keep using human-readable dates (e.g. "since": "2025-01-01").
  • Each input gets its share. With several inputs in one run, each one first gets an equal share of max_items, then the inputs with more results fill the rest. Through the API, per_input_limit sets a hard maximum for each input instead.
  • Follower lists are slower than tweets. X allows fewer requests for a social graph than for a timeline, so a large follower job takes longer than a search of the same size. Ask for what you need.
  • Combine the filters of the form with a search term. Write any operator in the term (e.g. filter:media, -filter:replies) and add the fields of the form, like min_likes or lang, on top. Scweet merges them into a single query.
  • X hides some replies from every reader. A tweet can report more replies than X shows. The log of the run states both numbers.

How It Works

Scweet uses X's internal GraphQL API — the same endpoints the X website uses. No official Twitter API key or developer account is needed.

You choose a source and a target. Scweet handles everything else — authentication, proxies, pacing, retries, and deduplication. If something fails mid-run, work is automatically retried so you get complete results without manual intervention.

Each source has its own pacing, because X allows a different number of requests for a search, for a timeline, and for a social graph. Scweet respects each one, so a large job stays stable instead of stopping halfway.


FAQ

Do I need a Twitter API key? No. Scweet uses X's internal GraphQL API — no developer account or API key required.

Do I need to provide cookies, a login or proxies? No. You provide nothing but your query. Everything else is handled for you.

Can I scrape protected profiles? No. Only publicly visible content is accessible.

What export formats are supported? Seven: JSON, JSONL, CSV, XLSX, HTML, XML and RSS. Download any of them from the dataset tab of a run, or fetch one from the API by adding format=:

https://api.apify.com/v2/datasets/<datasetId>/items?format=csv&token=<yourToken>

An export holds every row, whatever its size. Use JSONL to read a large result line by line instead of loading it whole.

Is there a free tier? Yes. A free plan receives a trial of 3,000 tweets, up to 1,000 in a run, one run at a time, at the same $0.30 for each 1,000 as a paid plan. The same trial covers tweets, profile timelines and follower lists. After the trial, subscribe to any Apify plan to continue.

Can I get the followers of a profile? Yes. Set scrape to followers and choose relationships: followers, following, verified_followers, or several of them in one run, for one or several profiles. Each row is one profile, and its field source_root (the column List) and source_value (the column Input) say which list of which profile it comes from.

Can I get the follower count and the bio of a profile? Yes. Every row of the Followers & following mode carries them: the counts of followers and posts, the bio, the location, the joined date, and the marks of verification.

Can I scrape the replies of a tweet? Yes. Paste the URL of the tweet in urls, or its ID in tweet_ids. The run returns the tweet and its replies. X hides some replies from every reader, and the log states how many replies X showed.

Can I scrape a list? Yes. Paste the URL of the list, for example https://x.com/i/lists/1039292499909476352. The run returns the latest tweets of the list.

Does Scweet return sensitive tweets? Yes. Search results and replies include the tweets that X hides behind its filter for sensitive content. Add filter:safe to a search term to leave them out.

I use another Twitter scraper on Apify. Must I change my input? No. Paste the same input. Scweet reads the common field names of other Twitter scrapers, and the log names each field that it ignores.

Is there an open-source version? Yes. Scweet is our MIT library, and this Actor is the hosted service built on it. The library needs you to supply your own X accounts, refresh their cookies, manage proxies, and follow every change X makes to its API. This Actor does that work for you. Use the library if you want to run the infrastructure yourself. Use this Actor if you want the data.


Support

For help with query tuning, limits, or workflow design, contact us on the Actor page or open an issue in the open-source repository.

Responsible usage: Use this Actor lawfully and ethically. Comply with applicable platform terms and local regulations. Scweet applies adaptive rate limiting — repeatedly running queries that return zero results will trigger progressively longer cooldowns.

Privacy: Run metadata (user ID, timestamps, input payload, counters) may be stored for rate limiting, support, and stability. This data is used internally and is not shared with third parties.