🐦 Twitter/X Profile & Followers Scraper — No Login

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 @. suited to direct usernames.
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.
authToken	string	Optional override for the Twitter auth cookie. Leave blank to use the configured environment variable.
csrfToken	string	Optional override for the Twitter CSRF cookie. Leave blank to use the configured environment variable.
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": "follower",
  "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

This Actor uses the Apify platform with Playwright-based infrastructure from the js-crawlee-playwright-chrome template. The live contract defines these accepted inputs: usernames, start URLs, scrape mode, result caps, optional cookie overrides, and proxy configuration. 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 pricing plus standard Apify platform usage.

The primary charged event is one returned Twitter/X user record. The live pricing tab shows the current event price and any platform usage that applies to a run. Apify also charges for actor start based on memory, with the actor-start event defined in the live contract. Review the live Pricing tab in the Apify Console for the current numbers before running a job.

For a simple event-count example: 1 thousand returned user records equals 1 thousand billed record events.

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

• Then use Twitter Trends Scraper | X Trends by Country to extend 🐦 Twitter/X Profile & Followers Scraper — No Login research with a complementary content contract.
• Then use VK Groups Scraper for Public Communities to extend 🐦 Twitter/X Profile & Followers Scraper — No Login with a neighboring social-media research source when the brief calls for Vk data.

Design note

I found that the dataset contract uses a single shared record schema for profiles, followers, and following rows, and record_type is the field that distinguishes them.

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.