X(twitter) User Profile & Tweets Scraper
Pricing
from $3.99 / 1,000 results
X(twitter) User Profile & Tweets Scraper
Scrapes tweets and profile data from Twitter X, capturing usernames, bios, tweet text, media, timestamps, metrics, follower counts, and profile URLs. Ideal for trend tracking, research, influencer insights, and large-scale Twitter X data extraction
Pricing
from $3.99 / 1,000 results
Rating
1.0
(1)
Developer
Scrapio
Maintained by CommunityActor stats
1
Bookmarked
60
Total users
29
Monthly active users
6 days ago
Last modified
Categories
Share
X (Twitter) Scraper — Profiles, Posts and Follower Lists as JSON
This X (Twitter) scraper returns three things from any public profile: the account itself, its recent posts, and — once you supply your own x.com session cookies — the actual follower and following rosters, not just the counters X shows on a profile page. Every row lands as typed JSON tagged by rowType: profile, tweet, follower, following. Unlike scraping frameworks that return raw HTML, this Actor returns ready-to-use fields — no parsing, no regex, no HTML walking. The guide below documents every field the Actor writes, the real X-imposed limits behind them, and how teams run it for audience mapping, monitoring and AI pipelines.
🧭 What Does This X (Twitter) Scraper Do?
It resolves an X profile from a URL, @handle or numeric user ID, reads that account's own timeline, and — with your session cookies — pages through the account's follower and following lists using X's own cursor. No X account is needed for the profile and post data; it runs on a keyless guest session. The follower and following rosters are gated by X itself to logged-in clients, so those two lists only run once you add your own authToken and ct0 cookies.
- Resolves
https://x.com/name,@name, a bare handle, or a numeric user ID to one account - Reads up to 100 recent posts per profile, sorted newest, oldest, or most-liked
- Recovers the pinned post and flags it, without over-counting the post cap
- Pages the follower roster and the following roster independently, each with its own cap (0–5000)
- Screens roster accounts by minimum follower count, blue-verification, and protected/locked status while paging
- Reports what happened per profile: pages fetched, accounts screened out, whether a roster was truncated, and X's own rate-limit counters
- Attaches Apify Residential Proxy to every outbound request by default
⚡ Features & Capabilities
This Actor's capabilities split into three groups: what it reads from X, how its output compares to the base scraper it extends, and where it stops.
Core features
- Profile resolution across four input shapes (
startUrls) — profile URL,@handle, bare handle, numeric user ID - Post/timeline scraping with
sortOrder(newest,oldest,popular) applied before themaxTweetscutoff, andwithRepliesto filter the profile's own replies out of the timeline - Follower and following rosters emitted as their own dataset rows (
rowType: "follower"/"following"), each carryingrosterRank,followerToFollowingRatio,accountAgeDays, and the account's own bio/location/website/verification fields - Roster quality screens —
minFollowerCount,onlyVerifiedFollowers,excludeProtectedAccounts— applied while paging, so a screened run still fills the cap with accounts that passed - Per-run accounting on the profile row —
postsCollected,followersCollected,followersScreenedOut,followersPagesFetched,followersTruncated,rosterSkippedReason,rateLimitRemaining,rateLimitHits— so a thin result is explained, not silent - Live GraphQL query-ID discovery for the follower/following operations, harvested from X's own web bundle at run time, because those IDs rotate and a hardcoded one answers HTTP 404
How this Actor compares to the base scraper it extends
This Actor is built on top of Twitter (X.com) Tweets & Profiles Scraper — its transport, timeline walker and post-row builder are imported verbatim (src/base_main.py is that actor's own src/main.py), so every post field is produced by that actor's own code, unchanged. This Actor only adds the roster layer on top.
| Feature | This Actor | Base Twitter (X.com) Tweets & Profiles Scraper |
|---|---|---|
| Post and profile fields | ✅ Identical — same builder code | ✅ Same fields |
| Follower / following rosters | ✅ Cursor-paged, capped 0–5,000 per list | ❌ Not returned |
| Roster quality screens | ✅ Min-follower floor, verified-only, exclude-protected | — |
sortOrder on posts | ✅ Applied before the cap | Declared in that actor's schema but not read by its own code |
| Requires an X login | Only for the two roster switches | No |
| Per-run rate-limit reporting | ✅ rateLimitRemaining / rateLimitHits on the profile row | Not exposed |
If your use case is feeding structured audience data to an LLM or a CRM, the roster rows are the decision-maker — a follower/following list assembled by hand from the public UI does not scale past a few dozen accounts.
When another tool might suit you better
If all you need is a profile's own posts and bio — no audience data at all — the plain base scraper is the simpler tool: one less input section, and no need to ever touch x.com session cookies. This Actor is also not the right tool for keyword or hashtag search (targets that look like a search phrase are skipped with a warning) or for reading a poll attached to a single post — X's poll data lives on a post, not a profile, and isn't part of this Actor's output at all.
This Actor within the Scrapio X (Twitter) data stack
This Actor covers profiles, posts, and follower/following rosters. For poll results on individual X posts — options, vote counts, and whether voting is still open — use Twitter X Tweets Scraper Scraper With Poll Results, also published under the Scrapio account.
Why do developers and data teams scrape X (Twitter)?
🏢 Growth and influencer marketing teams
A growth team feeds startUrls a shortlist of creator or competitor accounts and reads back totalFollowers, totalFollowing, followerToFollowingRatio and the follower roster itself — the actual accounts, not just the count — with onlyVerifiedFollowers or minFollowerCount to strip empty accounts before anyone reviews the list. The output lands as one dataset per run, ready to filter in a spreadsheet or push into a CRM for outreach targeting.
📊 AI training data and RAG indexing
description (bio) and text (post body) are the high-information text fields here — bios are short, dense identity statements, and post text is the platform's native content unit. For RAG enrichment, indexing description alongside professionalCategory and verifiedType gives an agent enough context to answer "who is this account" without a follow-up lookup. For training data, the structured fields — totalFollowers, totalFollowing, accountAgeDays, verified — return as typed primitives (booleans, integers, ISO timestamps) with no string-to-number cleanup needed.
📱 Competitive and market intelligence
Point the Actor at a competitor's account with getFollowers/getFollowing on and rosterSortBy: "followersDesc" to see who follows them, ranked. Run it on a schedule and diff totalFollowers, postsCollected and the roster composition between runs to catch a competitor's audience or posting cadence shifting.
🔬 Research and academic use
Public-account bios, follow relationships and post metadata (likes, retweets, views) support social-network and platform-behavior research at the scale a manual review can't reach. This Actor reads only publicly accessible profiles and posts — it does not access private accounts or content behind a login wall other than what X itself shows to a follower/following list viewer.
🎥 Product and SaaS development
Audience-analytics dashboards, influencer-discovery tools and lead-enrichment products can run this Actor on a schedule and store the profile and roster rows as the backing dataset, using sourceUserId to key each roster row back to the profile it came from.
🍚 Input Parameters
Every parameter below is read directly from .actor/actor.json, in schema order.
| Parameter | Required | Type | Default | Description |
|---|---|---|---|---|
startUrls | Yes | array of strings | ["https://x.com/apify"] | Target X profiles. Profile URL, @handle, bare handle, or numeric user ID — all four forms resolve to the same account. Keyword searches are not supported. |
getFollowers | No | boolean | true | Collect the follower roster. Needs authToken + ct0. |
getFollowing | No | boolean | true | Collect the following roster. Needs authToken + ct0. |
maxFollowers | No | integer (0–5000) | 50 | Follower cap per profile — stops after this many accounts that pass the screens below. 0 turns the follower roster off. |
maxFollowing | No | integer (0–5000) | 50 | Following cap per profile, same rule. |
minFollowerCount | No | integer (0–100,000,000) | 0 | Drops roster accounts below this follower count. 0 keeps everyone. |
onlyVerifiedFollowers | No | boolean | false | Keep only blue-verified accounts in the rosters. |
excludeProtectedAccounts | No | boolean | false | Drop protected (locked) accounts from the rosters. |
rosterSortBy | No | enum | "listOrder" | Roster row order: listOrder (X's own order), followersDesc, followersAsc, followingDesc, postsDesc. |
authToken | No | string (secret) | — | Your x.com auth_token cookie. Required for the follower and following rosters only. |
ct0 | No | string (secret) | — | Your x.com ct0 cookie, from the same session as authToken. Sent as a cookie and as the x-csrf-token header. |
maxTweets | No | integer (0–100) | 10 | Maximum posts per profile. 0 skips posts and returns the profile row plus rosters only. |
sortOrder | No | enum | "newest" | Post order: newest, oldest, popular (most-liked). Applied before the maxTweets cutoff. |
withReplies | No | boolean | true | Keep the profile's own replies in the post rows. |
includeUserInfo | No | boolean | true | Attach the nested user object and flat author columns to every post and roster row. |
proxyConfiguration | No | object | {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]} | Apify Proxy, attached to every outbound request. |
Example input
Supported URL types and input formats
- Profile URL —
https://x.com/apifyorhttps://twitter.com/apify - Handle, with or without
@—@apifyorapify - Numeric user ID —
3510729917 - Not supported — a keyword, hashtag, or single-post URL (
.../status/...). Any of these is skipped with a log warning rather than producing an empty or wrong row.
📦 Output Format
Every run writes newline-delimited JSON rows to the Actor's dataset, one row per profile, per post, and per roster account, all sharing the same rowType tag and the shared account columns (handle, profileUrl, avatar, description, location, website, joinDate, verifiedType, protected, totalFollowers, totalFollowing, totalTweets, totalMediaCount, totalLikes, bannerUrl, professionalCategory). The dataset exposes four preset views on the Apify platform: All rows, Follower / following roster, Posts, and Profile rows — what each run actually collected. Results can be exported from the Console or the API as JSON, CSV, Excel, XML, or RSS.
Output for a profile row
Output for a post (tweet) row
Output for a follower / following roster row
A following row carries the exact same shape, with rowType: "following".
Schema stability and export options
Field names are stable across runs and do not change when X updates its own front end — this Actor reads X's internal GraphQL API directly rather than parsing rendered HTML, so a visual redesign on x.com does not affect the output shape. Where X drops a field for a given account (a private location, no bio, no verified type), the key is present with a null value rather than omitted or guessed. Results can be downloaded from the Apify Console or fetched through the Apify API/apify-client as JSON, CSV, Excel, XML or RSS, and pushed to any downstream system via the Apify integrations (webhooks, Zapier, Make, or direct API polling).
💡 This X (Twitter) Scraper's Strategy Guide
🎯 Strategy 1: Real-time audience enrichment
Trigger a run from your app whenever a lead or contact record includes an X handle. Feed that handle into startUrls with getFollowers/getFollowing off and maxTweets at a small value like 5, then read back totalFollowers, verified, professionalCategory and the most recent text values from the tweet rows, and write them onto the lead record. Because the profile route needs no login, this path never touches your authToken/ct0 cookies.
🎯 Strategy 2: Scheduled follower monitoring
Set up an Apify schedule to re-run the same startUrls list weekly with rosterSortBy: "followersDesc". Diff each run's follower rows against the previous run's on userId to see who is new or gone, and diff the profile row's totalFollowers to catch the headline number moving. Alert on the accounts that appeared or disappeared, not on the raw count.
🎯 Strategy 3: Bulk audience dataset build
Pass a long startUrls list of target accounts in one run, with maxFollowers/maxFollowing set to the size roster you need and the two roster screens tuned to your quality bar. Export the resulting dataset — profile rows and roster rows together, joined on sourceUserId — to CSV or straight into a database via the Apify API for downstream analysis.
Strategy comparison at a glance
| Strategy | Best for | Run pattern | Output format |
|---|---|---|---|
| Real-time enrichment | CRM/lead enrichment on demand | Triggered single-target run | JSON row appended to your record |
| Scheduled monitoring | Tracking a competitor's or your own audience over time | Apify schedule, same targets, diffed on userId/totalFollowers | JSON dataset per run, diffed externally |
| Bulk dataset build | Research or training datasets | One run, many targets, roster caps tuned upfront | Dataset export to CSV or database |
🌴 Related X (Twitter) Scrapers & Tools
| Scraper | What it extracts |
|---|---|
| Twitter X Tweets Scraper Scraper With Poll Results (Scrapio) | Public X posts and the poll on each one — options, vote counts, open/closed status |
| Reddit Subreddit Members Scraper With User Profiles (Scrapio) | Active participants in a subreddit with a Reddit profile card — post/comment karma, account age |
| TikTok Data Scraper: Comments, Replies & AI Sentiment (Scrapio) | TikTok profiles, videos, followers and comments, with commenter-audience columns |
| LinkedIn Profile Posts Scraper With Engagement Analytics (Scrapio) | LinkedIn profile posts with derived engagement rate, cadence and rank |
How to integrate this X (Twitter) Scraper with your stack
This Actor works with any language or tool that can make an HTTP request — it runs on the Apify platform, and you drive it with the Apify API or an official client library.
Python
Node.js
Async and scheduled pipelines
For large target lists, start the run with the Apify API's async endpoint and poll run.status, or use an Apify webhook to get notified on ACTOR.RUN.SUCCEEDED instead of holding a connection open. For recurring audience monitoring, an Apify schedule re-runs the same input on a cron-style interval without any code on your side.
🎯 Who Needs This X (Twitter) Scraper? (Use Cases & Industries)
🏢 Growth and influencer marketing teams
Build a shortlist of creator accounts, pull each one's follower roster with onlyVerifiedFollowers on, and hand the resulting handle list to outreach — totalFollowers and professionalCategory on each roster row tell you which accounts are worth prioritizing before anyone opens a browser tab.
📊 Growth and product analysts
Track totalFollowers, totalTweets and postsCollected for your own account and a set of competitors on a recurring schedule, and chart the trend externally — the Actor's job is the per-run snapshot, not the trend line.
📱 Competitive intelligence teams
Run the Actor against a competitor's account with the following roster on to see which accounts they follow — often other brands, partners or influencers they're courting — a signal not visible from the profile page alone.
🔬 Researchers
Public bios, follow relationships and post metadata support social-network and platform-behavior studies at a scale manual browsing can't reach; this Actor only reads what X shows to any logged-in viewer of a profile's follower/following list, never anything behind a private wall.
🎥 Product and SaaS builders
Audience-analytics and lead-enrichment products can run this Actor as a backend job, storing the profile and roster rows as the dataset behind a dashboard, keyed on sourceUserId.
⚖️ Is it legal to scrape X (Twitter)?
Scraping publicly accessible data is generally lawful in the United States: in hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), the Ninth Circuit held that scraping data a website makes publicly available does not violate the Computer Fraud and Abuse Act. That precedent concerns public-data access, not X's own Terms of Service — X's terms restrict automated data collection, and violating them is a contract/civil-law risk between you and X, not a criminal one.
This Actor also returns personal data — names, handles, bios, locations and follow relationships tied to identifiable people — so data protection law can apply depending on who you are and whose data you store. If you or your users are in the EU/EEA or California, GDPR and CCPA-style obligations around lawful basis, storage, and data-subject rights can attach to what you do with that data after collection; this Actor does not determine your lawful basis for you.
This Actor returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.
❓ Frequently asked questions
Does this X Scraper work without an X account?
Yes, for profiles and posts. Profile resolution and the post timeline run on a keyless guest session — no login needed. The follower and following rosters are the exception: X serves those two lists only to a logged-in client, so they need your own authToken and ct0 cookies. Without them the run still succeeds and still returns the profile row and posts; the profile row reports rosterSkippedReason: "auth_required".
How does this Actor handle X's anti-scraping measures?
It uses Chrome TLS impersonation (curl_cffi) rather than a browser, discovers X's GraphQL query IDs live from X's own JS bundle each run (a hardcoded ID rotates and goes stale), self-heals when X adds a required feature flag mid-run, and backs off once on an HTTP 429 before retrying. Apify Residential Proxy is attached to every request by default because X answers datacenter IP ranges inconsistently.
Can I run this Actor at scale without getting blocked?
There is no uptime or success-rate guarantee — this depends on X's own rate-limit bucket, which the Actor reports back via rateLimitRemaining and rateLimitHits on the profile row rather than hiding it. When the bucket runs out mid-roster, the run stops that roster, marks it followersTruncated: true (or the following equivalent), and moves on — it does not fail the whole run.
How fresh is the data this Actor returns?
Live. Every run fetches directly from X's own GraphQL API at request time; nothing is cached or served from a prior run.
Is scraping a follower list a Terms of Service violation?
Possibly, depending on your use — see "Is it legal to scrape X (Twitter)?" above. Scraping public data is not itself illegal under U.S. case law, but automated collection can conflict with X's own Terms of Service, which is a civil matter between you and X, not a law-enforcement one.
Which fields work best for AI training and RAG indexing?
For RAG, index description (the account bio) and text (post body) — they're the dense, natural-language fields. For training data, totalFollowers, totalFollowing, accountAgeDays, verified and followerToFollowingRatio return as typed booleans, integers and pre-computed ratios, so no string parsing or unit normalization is needed before use.
Does the roster comply with GDPR or CCPA?
This Actor returns only what X already publishes to any logged-in viewer of a follower or following list — it adds no data beyond that. Because the rows are personal data, the lawful basis for storing and using them sits with you, not with the Actor; consult counsel if you plan to use roster data for a commercial purpose involving EU or California residents.
Does this Actor work with Claude, ChatGPT, and other AI agent tools?
Yes, as an HTTP endpoint — any agent framework that can call the Apify API can start a run and read back the dataset. Every row is typed JSON, so an agent can consume profile, tweet and roster rows directly into its context window without a parsing step.
What happens if a target account is protected, suspended, or doesn't exist?
If a handle doesn't resolve to a real account, the target is skipped with a logged reason and produces no row at all — never a blank or guessed one. Accounts that appear inside a roster but are suspended or deactivated arrive from X as empty stubs; they're skipped from the roster and counted in unavailableAccountsSkipped on the profile row rather than pushed as incomplete rows.
How does this Actor compare to other X (Twitter) scrapers?
Against the base Twitter (X.com) Tweets & Profiles Scraper it's built on, this Actor adds the follower/following rosters, roster quality screens, and per-run rate-limit reporting — the base returns profile and post data only. Against a hypothetical tool built on X's own official API, the tradeoff runs the other way: this Actor needs no developer application or paid API tier, but it depends on your own logged-in session cookies for the roster feature, and on X's GraphQL surface staying reachable the way it's implemented today.
ℹ️ Disclaimer
This X (Twitter) Scraper extracts only publicly available data from X (Twitter) — the same profile, post, and follower/following information visible to any logged-in viewer of a public account. This tool is intended for lawful use cases only. Users are responsible for complying with X's terms of service and applicable data protection laws in their jurisdiction.
