X Followers & Following Scraper — At Scale

Export available followers or following profiles from public X (Twitter) accounts at scale. Filter results by verification, account privacy, follower count, and total posts. Enter a username, @handle, X profile URL, or numeric user ID—no X login, cookies, API key, or proxy setup required.

Use the results in JSON, CSV, Excel, XML, or RSS, or connect the Actor to the Apify API, schedules, webhooks, and other integrations.

What this Actor does

• Scrapes followers or accounts followed by a public X profile.
• Accepts one or multiple source profiles in the same run.
• Optionally filters saved profiles by verification, privacy, audience size, and posting volume.
• Follows X pagination cursors automatically.
• Retries temporary connection, server, access, and rate-limit failures.
• Returns clean profile records with bios, locations, websites, audience metrics, verification, and account status.
• Saves each completed page immediately, so earlier results remain available if a later page fails.
• Requires no X credentials or proxy setup from the user.

Common use cases

• Analyze a competitor's public audience.
• Build creator, researcher, lead, or prospect lists.
• Export accounts followed by an influencer, company, or publication.
• Compare the audiences of several public profiles.
• Enrich social graph data with profile and audience information.

How to scrape X followers or following

1. Add one or more X usernames, profile URLs, or numeric user IDs.
2. Select Followers or Followings.
3. Set how many matching profiles to save for each source account.
4. Optionally select result filters and how many profiles to check for matches.
5. Run the Actor and download the Dataset or send it through the Apify API or an integration.

To collect both followers and following, run the Actor twice with a different relationshipType each time.

Input

Provide at least one value in screenNames, userIds, or both.

Field	Description	Default
screenNames	Usernames, @handles, full x.com or twitter.com profile URLs, or numeric user IDs.	None
userIds	Optional numeric X user IDs. You can use this field by itself or together with usernames and URLs.	Empty
relationshipType	followers returns accounts following the source profile. followings returns accounts followed by it.	followers
maxItemsPerUser	Maximum matching profiles saved per source account. Keep 100 for a quick test, or set 0 to paginate through all profiles available from X. When filters are enabled, maxProfilesScannedPerUser still applies.	100
verification	Keeps all accounts, any verified account, Blue verified accounts, Business or Government accounts, or accounts without a verification badge.	any
visibility	Keeps all accounts, public accounts only, or protected accounts only.	any
minFollowers	Minimum follower count required for a result. Set 0 to disable.	0
maxFollowers	Maximum follower count allowed for a result. Leave empty for no maximum.	Empty
minTweets	Minimum lifetime post count required for a result. Set 0 to disable.	0
maxProfilesScannedPerUser	Profiles checked per source account while filters are enabled. Set 0 to check until X ends the list.	20000
includeRawUser	Adds the complete original X user object as raw_user.	false

Each run accepts up to 25 distinct input identifiers across screenNames and userIds combined. Equivalent username forms such as nasa, @nasa, and https://x.com/nasa count once; a username and ID for the same account count separately at input time, but are merged after lookup. Sources are processed sequentially. All enabled filters work together, so a saved profile must satisfy every selected condition. The scan limit is applied separately to each source account and is ignored when no result filter is enabled.

Example input

{
  "screenNames": [
    "@elonmusk",
    "https://x.com/OpenAI",
    "44196397"
  ],
  "relationshipType": "followers",
  "maxItemsPerUser": 100,
  "includeRawUser": false,
  "verification": "any_verified",
  "visibility": "public",
  "minFollowers": 1000,
  "maxFollowers": 100000,
  "minTweets": 100,
  "maxProfilesScannedPerUser": 20000
}

Output

Each successful Dataset item represents one follower or following profile. Source fields identify the account whose relationship list produced the result.

The default output includes:

• Source account ID, screen name, profile URL, and requested identifier.
• Relationship type: followers or followings.
• User ID, screen name, name, bio, location, and account creation date.
• Followers, following, posts, media posts, likes, and listed counts.
• Legacy verification, Blue verification, Business or Government badge type, protected-account, default-profile, and geo status.
• Expanded website and bio links, profile image, banner, pinned post IDs, and country restrictions.

{
  "status": "success",
  "source_user_id": "44196397",
  "source_screen_name": "elonmusk",
  "source_profile_url": "https://x.com/elonmusk",
  "requested_identifier": "elonmusk",
  "relationship_type": "followers",
  "user_id": "1278722158970068993",
  "screen_name": "example",
  "profile_url": "https://x.com/example",
  "name": "Example User",
  "description": "Example bio",
  "location": "San Francisco",
  "created_at": "2020-07-02T12:00:00Z",
  "followers_count": 1250,
  "friends_count": 340,
  "listed_count": 18,
  "favourites_count": 4260,
  "tweets_count": 815,
  "media_count": 120,
  "pinned_tweet_ids": [
    "1900000000000000000"
  ],
  "verified": false,
  "is_blue_verified": true,
  "verified_type": "",
  "protected": false,
  "default_profile": false,
  "geo_enabled": false,
  "advertiser_account_type": "none",
  "business_profile_state": "none",
  "withheld_in_countries": [],
  "website_url": "https://example.com",
  "bio_urls": [
    "https://example.com/about"
  ],
  "profile_image_url": "https://pbs.twimg.com/profile_images/example.jpg",
  "profile_banner_url": "https://pbs.twimg.com/profile_banners/example",
  "default_profile_image": false
}

Leave includeRawUser disabled for compact, spreadsheet-friendly results. Enable it only when you need the complete original response from X.

Normalized created_at values use ISO 8601 UTC, for example 2020-07-02T12:00:00Z. The optional raw_user object keeps X's original time representation unchanged.

Pagination and reliability

The Actor follows X cursors automatically and stores results page by page. Under normal conditions, each source profile keeps a stable request route throughout pagination. Apify Proxy routing is handled automatically.

Each page is attempted up to five times. Transient connection failures, X server errors, access restrictions, and rate limits are handled automatically. When the request route needs to change, the Actor retries the same cursor, while previously stored pages remain available.

maxItemsPerUser controls how many matching profiles are saved per source account. When filters are enabled, maxProfilesScannedPerUser controls how many relationship profiles are checked while looking for those matches. Its default of 20,000 is about 100 full pages; set it to 0 to check until X returns its terminal cursor. Without filters, the scan limit is ignored. Results remain in the order returned by X.

How much does it cost?

This Actor uses pay-per-event pricing. A successful profile written to the Dataset is charged as one relationship-result event. Error and not-found records are not charged.

Apify plan	Price per successful profile	Example: 1,000 profiles
Free	$0.00015	$0.15
Bronze	$0.00010	$0.10
Silver	$0.00009	$0.09
Gold, Platinum, or Diamond	$0.00008	$0.08

A small Actor-start event also applies: $0.00005 per GB of allocated memory, with a minimum of one event. The Actor respects the maximum charge limit configured for the run and stops before making additional requests after that limit is reached.

Large exports take longer and cost more. Keep the default limit of 100 while testing a new target, then increase it or set it to 0 after confirming the expected result volume.

Missing, unavailable, and partial results

Malformed usernames, profile URLs, and user IDs produce uncharged invalid_input records. Valid inputs in the same run are still processed. If no usable account was provided, the run ends without sending an X request and leaves an invalid_input record explaining why.

When X explicitly reports that an account does not exist or is unavailable, the Actor writes an uncharged not_found record and continues with the remaining source profiles:

{
  "status": "not_found",
  "requested_identifier": "missing-user",
  "relationship_type": "followers",
  "error": "X user @missing-user was not found or is unavailable."
}

Temporary request failures that remain after all retry attempts produce an uncharged error record. If at least one source succeeds, other source-level errors do not discard its results. If every requested source fails because of a technical error, the run finishes with a failed status while its error records and any previously stored pages remain available.

Run through the Apify API

Start the Actor from your application with the Apify API:

curl -X POST \
  "https://api.apify.com/v2/acts/arjun_code~x-twitter-followers-followings-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "screenNames": ["OpenAI"],
    "relationshipType": "followers",
    "maxItemsPerUser": 100
  }'

You can also run the Actor on a schedule, trigger it from a webhook, or connect its Dataset to automation and data-processing tools available through Apify integrations.

FAQ

Do I need an X account or API key?

No. You do not need to submit an X login, cookies, bearer token, or X API key.

Can one run collect both followers and following?

One run collects one relationship type. Run it once with followers and once with followings when you need both datasets.

What does maxItemsPerUser: 0 mean?

It removes the saved-result limit. Without filters, pagination continues until X returns its terminal cursor. With filters, the Actor can still stop at maxProfilesScannedPerUser; set both values to 0 to continue until X ends the list. Protected, suspended, restricted, or changing accounts can still return fewer records.

What is the difference between results saved and profiles checked?

maxItemsPerUser limits how many matching profiles are written to the Dataset. maxProfilesScannedPerUser limits how many followers or following profiles are inspected while filters are enabled. For example, the Actor can check up to 20,000 profiles to save the first 100 that match every filter.

Can the Dataset contain duplicate profiles?

Usually X cursor pages do not repeat users. During a long export, however, the relationship list can change while it is being read. If X returns the same profile on different pages, the Actor preserves those rows as returned.

Why can the result count differ from the number shown on X?

X relationship counts change continuously and can include accounts that are protected, suspended, restricted, withheld, or otherwise unavailable through the relationship endpoint.

What happens if a later page fails?

The Actor stores results after every completed page. Earlier pages remain in the Dataset, and the failed source receives an error record after retry attempts are exhausted.

Ready-to-run examples

• Export X (Twitter) Followers — No Login
• Export X (Twitter) Following — No Login
• Export Followers from Multiple X Accounts

Continue your X research workflow

Goal	Actor
Discover public accounts by keyword, profession, niche, or location	X (Twitter) People Search Scraper
Expand from a known profile through X's native Similar to recommendations	X (Twitter) Similar Accounts Finder — No Login
Export followers or accounts followed by one or more profiles	X Followers & Following Scraper — At Scale
Inspect account origin, signup source, and username-change history	X Twitter Account Origin Intelligence
Monitor profile, username, verification, and follower changes over time	X (Twitter) Profile & Username Change Monitor

A practical workflow is to discover accounts by keyword, expand selected profiles through X recommendations, export their audiences, inspect account-origin signals, and monitor shortlisted profiles over time.

Privacy and limitations

The Actor works with relationship data exposed by X for public profiles. It does not require an X login, cookies, API key, or proxy configuration, and no internal authentication data is written to the Dataset.

Protected, suspended, restricted, or withheld accounts may return limited or no relationship data. This unofficial Actor is not affiliated with or endorsed by X. Use the data lawfully and follow X, Apify, and applicable privacy requirements.

Support

If a run fails or the output changes, open an issue on the Actor page and include the Apify run ID, input, and expected behavior. Do not include passwords, cookies, tokens, or other secrets.