X (Twitter) Followers & Following Scraper

What is X (Twitter) Followers & Following Scraper?

This Apify Actor is built for marketers, researchers, and AI agents that need structured Twitter/X account data from usernames or profile, followers, or following URLs. It accepts one or many accounts, and each output record represents one Twitter/X user entry: a direct profile, a follower, or a following account. The returned fields include username, display name, bio, follower count, following count, tweet count, verification flags, location, website, creation date, profile image URL, banner URL, pinned tweet ID, source account, scrape timestamp, and source URL. The outcome is a dataset of clean, record-level Twitter/X user data that you can analyze, filter, or pass into downstream workflows.

Best fit and connected workflows

This Actor fits workflows that start with Twitter/X handles or public Twitter/X URLs and end with structured account data.

Good routing patterns include:

• Profile enrichment from a list of usernames
• Follower list collection for a target account
• Following list collection for a target account
• Bulk multi-account runs with a shared output schema
• AI-agent workflows through Apify MCP when a tool needs profile metadata and social graph data in one place

It is especially useful when one run needs to combine profile records with follower or following records under the same schema and source tracking.

Practical scenario

A marketer named Lina wants to review the public Twitter/X presence of a shortlist of conference speakers. She starts with usernames for three speakers, selects profiles, and keeps the default caps for follower and following collection. The returned records include each speaker's username, display name, follower count, verified status, bio, website, and scraped timestamp. Lina uses the follower counts and bios to decide which profiles to review first, then opens the linked websites for contact research.

Input fields

Field	Type	Purpose
usernames	array of strings	Twitter/X handles without @.
startUrls	array of objects	Full Twitter/X profile, followers, or following URLs. This overrides usernames.
mode	string	Selects profiles, followers, following, or all.
maxFollowersPerUser	integer	Caps followers collected per account. Default: 200.
maxFollowingPerUser	integer	Caps following accounts collected per account. Default: 200.
maxResults	integer	Caps total records across all inputs and modes. Default: 1000.
minFollowers	integer	Keep only follower/following rows whose own follower count is at least this value. Skipped rows are not charged. Default: 0.
verifiedOnly	boolean	Keep only verified follower/following rows. Skipped rows are not charged. Default: false.
proxyConfiguration	object	Proxy settings. Residential proxies are the provided default.

Focused JSON example

{
  "usernames": ["elonmusk", "sama", "naval"],
  "mode": "all",
  "maxFollowersPerUser": 50,
  "maxFollowingPerUser": 25,
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Output fields

Field	Type	Purpose
record_type	string	Record category: profile, follower, or following.
user_id	string	Numeric Twitter/X user ID, suitable for deduplication.
username	string	Twitter/X handle without @.
display_name	string	Display name shown on the profile.
bio	string or null	Profile bio text.
follower_count	number or null	Follower total.
following_count	number or null	Following total.
tweet_count	number or null	Total published posts.
verified	boolean or null	Legacy verified status.
is_blue_verified	boolean or null	X Premium verification flag.
verified_type	string or null	Badge type such as blue, business, or government.
location	string or null	Self-reported profile location.
website	string or null	Linked website URL.
created_at	string or null	ISO 8601 account creation date.
profile_image_url	string or null	Profile image URL.
banner_url	string or null	Profile banner URL.
pinned_tweet_id	string or null	Pinned tweet ID.
source_username	string or null	Source account targeted in the run.
scraped_at	string	ISO 8601 collection timestamp.
source_url	string	Requested Twitter/X URL for traceability.

Illustrative JSON record

{
  "record_type": "profile",
  "user_id": "44196397",
  "username": "elonmusk",
  "display_name": "Elon Musk",
  "bio": "CEO of Tesla and SpaceX",
  "follower_count": 185000000,
  "following_count": 639,
  "tweet_count": 42000,
  "verified": false,
  "is_blue_verified": true,
  "verified_type": "blue",
  "location": "Austin, TX",
  "website": "https://x.com",
  "created_at": "2009-06-02T20:12:29.000Z",
  "profile_image_url": "https://pbs.twimg.com/profile_images/1234/photo.jpg",
  "banner_url": "https://pbs.twimg.com/profile_banners/44196397/1690000000",
  "pinned_tweet_id": "1234567890123456789",
  "source_username": "elonmusk",
  "scraped_at": "2026-03-31T12:00:00.000Z",
  "source_url": "https://x.com/elonmusk/followers"
}

How it works

You provide handles or URLs; no Twitter/X login, cookies or API key are needed from you. The Actor resolves each profile, then collects follower and following lists through managed data routes with a browser fallback. Optional minFollowers and verifiedOnly filters drop follower/following rows before they are saved. The output is stored in a dataset, with additional execution information available in key-value store records for OUTPUT and RUN_SUMMARY. The dataset schema defines one shared record shape for profiles, followers, and following entries, and the record_type field identifies which kind of record each row represents.

Pricing

This Actor uses Pay per event plus Apify platform usage. Each saved user row (profile, follower or following) is one dataset-item event, and each run has a small apify-actor-start event. Rows removed by minFollowers or verifiedOnly are never saved and never charged. See the Pricing tab for current prices.

Event-count example: a run that saves one profile row plus N follower rows is charged N + 1 dataset-item events plus one start event.

Use with AI agents (MCP)

This Actor is available as an Apify Actor that can be used through Apify MCP. It is useful when an agent needs a tool that accepts Twitter/X usernames or URLs and returns structured user records with provenance fields.

Exact Actor identity: khadinakbar/twitter-profile-followers-scraper

A realistic prompt for an agent:

Collect the public profile data and follower list for these Twitter/X accounts, return the username, display name, bio, follower count, verified status, and source URL for each record, and keep the results grouped by source account.

Output interpretation:

• record_type tells the agent whether the row is a profile, follower, or following record.
• source_username links follower and following rows back to the target account.
• source_url shows the exact URL requested.
• scraped_at provides a freshness marker for each row.
• user_id is the stable key for deduplication when usernames change.

Provenance and scope:

• Records come from the requested Twitter/X profile, followers, or following source.
• The schema includes both profile metadata and network records in one structure.
• maxFollowersPerUser, maxFollowingPerUser, and maxResults help shape the amount of data returned.

Pagination and cost guidance:

• Followers and following collection are controlled by per-user caps and the total result cap.
• Each returned dataset row corresponds to one billed user-record event.
• The live Pricing tab reflects the current event cost and Apify usage details.

Apify API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/twitter-profile-followers-scraper').call({
  usernames: ['hubspot', 'salesforce'],
  mode: 'all',
  maxFollowersPerUser: 100,
  maxFollowingPerUser: 50,
  maxResults: 500,
});

const datasetId = run.defaultDatasetId;
const { items } = await client.dataset(datasetId).listItems();

console.log('Run ID:', run.id);
console.log('Items:', items.length);
console.log(items);

Best results and outcome guidance

Start with usernames when you already have handles, and use startUrls when you have full Twitter/X links. Choose profiles for account metadata, followers for audience collection, following for network mapping, and all when you want all three record types in one run. Use maxFollowersPerUser, maxFollowingPerUser, and maxResults together to shape the size of the dataset. If you are working with multiple source accounts, keep an eye on source_username so you can group the output by target account after the run.

Continue the workflow

You need	Use
When you want profiles plus followers and/or following in one run, with follower filters	This Actor
When you only need the accounts a user follows	X (Twitter) Following Scraper
When you want to discover members of an X Community	X Community Members Scraper
After you find accounts, for posts from them	X (Twitter) Tweet Scraper

Builder's note

I designed one shared record schema for profiles, followers and following rows, with record_type and source_username on every row, so a single dataset can be grouped by target account without joins.

FAQ

When should I use usernames instead of startUrls?

Use usernames when you have bare handles such as elonmusk or sama. Use startUrls when you have a full profile, followers, or following URL.

Which mode should I choose for profile enrichment?

Use profiles when you only need metadata such as bio, follower count, verification status, location, and website.

Which mode fits audience research?

Use followers when you want the audience of a target account, and following when you want the accounts that target follows.

What does all return?

all returns profile records, follower records, and following records in one run, all with the same output schema.

How do I trace a row back to the source account?

Use source_username and source_url. Together they identify the account that was targeted and the exact URL that produced the record.

Is this Actor usable through Apify MCP?

Yes. It is an Apify Actor that can be called through Apify MCP with the exact identity khadinakbar/twitter-profile-followers-scraper.

Responsible use

Use this Actor for public Twitter/X data collection, review output in line with your own data handling rules, and keep result caps aligned with the amount of data you need. When working with account-level or network-level data, preserve user_id, source_username, and source_url so records remain traceable. Review the live Pricing tab before large runs so event counts and Apify usage are clear for the planned workload.