X (Twitter) Following Scraper - Accounts a User Follows

What is X (Twitter) Following Scraper?

X (Twitter) Following Scraper exports the public accounts an X (Twitter) user follows, with no login or cookies. It accepts X usernames or full profile URLs, and each input handle produces one batch of following records. Each record represents one followed account and includes fields such as username, display name, bio, follower count, following count, verified status, blue verification status, location, website, account creation time, profile image URL, user ID, source username, and scrape timestamp. The outcome is structured dataset items ready for review, enrichment, export, or downstream automation.

Best fit and connected workflows

This Actor fits workflows centered on public X following graphs, including audience mapping, brand and creator research, lead discovery, and agent pipelines that need structured profile metadata.

It is useful when you want to:

• turn one or more X profiles into a list of followed accounts,
• collect profile-level fields for enrichment or filtering,
• cap the number of rows per person or across multiple inputs,
• run the Actor through Apify MCP as a focused workflow component.

Which X (Twitter) Actor should I use?

This Actor is part of a family of public X (Twitter) Actors that share the same no-login approach and similar row fields. Pick the one that matches your job:

• Use X (Twitter) Replies Scraper instead when you only need replies to specific posts, with like/language filters and a resume cursor.
• Use X (Twitter) Quote Tweets Scraper instead when you need the quote tweets of a post, with the original post on every row.
• Use X Tweet Engagement Scraper instead when you want replies, quote tweets and retweeters of the same posts together in one run.
• Use X (Twitter) Retweeters Scraper instead when you only need the accounts that retweeted a post.
• Use X (Twitter) Profile Scraper instead when you need bio, follower counts and verification for a list of accounts.
• This Actor is the right pick when you need the accounts a user follows.
• Use Twitter/X Scraper — Profiles & Followers instead when you need the followers of an account.

Practical scenario

A market researcher starts with the public profile natgeo and wants a compact view of the accounts it follows. They provide the username and a per-user cap, then receive records with fields like username, display_name, bio, follower_count, location, and source_username. The researcher can then sort by follower count, scan bios for topical relevance, and pass selected rows into a CRM, spreadsheet, or another Apify Actor for enrichment.

Input fields

Field	Type	Purpose	Example
usernames	array of strings	One or more X handles. Accepts bare handles or profile URLs. Each handle becomes one batch of following records.	["natgeo", "apify"]
startUrls	array of objects	Full X profile URLs. The username is parsed from the path.	[{ "url": "https://x.com/natgeo" }]
maxFollowingPerUser	integer	Maximum following accounts to return per input handle. Pagination stops at this value.	200
maxResults	integer	Global cap across all input handles.	1000
proxyConfiguration	object	Proxy settings. The default Apify Residential proxy suits most runs.	{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }

Focused JSON example

{
  "usernames": ["natgeo", "apify"],
  "maxFollowingPerUser": 50,
  "maxResults": 100
}

Output fields

The dataset view exposes following-account records with these fields.

Field	Type	Meaning
username	string	X handle of the followed account
display_name	string	Display name on the profile
bio	string	Profile bio
follower_count	number	Public follower count
following_count	number	Public following count
tweet_count	number	Public post count
verified	boolean	Verified status
is_blue_verified	boolean	Blue verification status
location	string	Profile location
website	string	Website listed on the profile
created_at	string	Profile creation timestamp
profile_image_url	string	Profile image URL
user_id	string	Numeric X user ID
source_username	string	Input account whose following list produced the row
scraped_at	string	ISO timestamp for the scrape

Sample JSON record

{
  "user_id": "117662694",
  "username": "NatGeoPhotos",
  "display_name": "Nat Geo Photography",
  "bio": "All things photography from National Geographic.",
  "follower_count": 4626761,
  "following_count": 124,
  "tweet_count": 15554,
  "verified": false,
  "is_blue_verified": true,
  "location": "Global",
  "website": "http://nationalgeographic.com",
  "created_at": "Fri Feb 26 06:20:29 +0000 2010",
  "profile_image_url": "https://pbs.twimg.com/profile_images/798176802325794816/25mLqDKA.jpg",
  "source_username": "natgeo",
  "scraped_at": "2026-10-12T07:18:31.034Z"
}

How it works

You give the Actor X handles or profile URLs. For each one it resolves the account, pages through its public following list until maxFollowingPerUser (or the global maxResults) is reached, and saves one row per followed account. Duplicate accounts within a handle are skipped. Each run writes OUTPUT and RUN_SUMMARY to the default key-value store with an outcome (COMPLETE, PARTIAL, VALID_EMPTY or UPSTREAM_FAILED) and counts.

Pricing

Pay per event, plus Apify platform usage. You pay the following-found event once for each followed account saved to the dataset, plus the small apify-actor-start event. maxFollowingPerUser and maxResults cap the number of following-found events. See the Pricing tab for current event prices.

Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. It is a structured tool for retrieving public X following lists and returning dataset rows that agents can read, filter, and pass into later steps.

Exact Actor identity: khadinakbar/x-following-scraper

Pull the public following list for natgeo, return the first 25 accounts, and include profile fields that help me group the rows by topic and verification status.

The output is provenance-friendly because each row includes source_username and scraped_at. Agents can use those fields to trace which input produced each record and when it was collected. Pagination is controlled by maxFollowingPerUser, while maxResults adds a global cap that is useful in multi-step agent pipelines. Because the Actor is pay-per-event, agents can keep scope tight by setting practical limits before launching a run.

Apify API example

const { ApifyClient } = require('apify-client');

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

async function main() {
  const run = await client.actor('khadinakbar/x-following-scraper').call({
    usernames: ['natgeo'],
    maxFollowingPerUser: 25,
  });

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

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

Best results and outcome guidance

Use clear handles or profile URLs as input, then set maxFollowingPerUser and maxResults to match the scope of the task. For agent pipelines, a smaller first pass helps identify which followed accounts are relevant before you expand the crawl. When you need stable proxy handling, keep the default proxy configuration from the Actor input.

For multi-handle jobs, think in batches: one handle equals one following list, and maxResults governs the total row count across all handles. If you are building an AI workflow, the combination of username, display_name, bio, follower_count, following_count, verified, is_blue_verified, location, and website is usually enough to support clustering, screening, and enrichment.

Then use X (Twitter) Profile Scraper to enrich the followed accounts you shortlist with pinned tweets, account age and follower ratio.

Builder's note

I built this for audience mapping: who an account chooses to follow says a lot about its interests and network. I found that keeping source_username on every row is what makes multi-handle runs easy to pivot later.

FAQ

Can I use this Actor with a plain X username?

Yes. The usernames input accepts bare handles such as natgeo.

Can I use profile URLs instead of handles?

Yes. The startUrls input accepts full x.com profile URLs and parses the username from the path.

What kind of record does one row represent?

One row represents one public account that the input user follows.

Can I cap the amount of data returned?

Yes. Use maxFollowingPerUser for each input handle and maxResults for a global cap across all handles.

Do I need an X account or cookies?

No. The Actor reads public following lists only.

Is this Actor usable through Apify MCP?

Yes. It is an Apify Actor designed for MCP-based automation and agent workflows.

What fields are available for downstream filtering?

The dataset view includes username, display_name, bio, follower_count, following_count, verified, is_blue_verified, location, website, created_at, profile_image_url, user_id, source_username, and scraped_at.

Responsible use

X and Twitter are trademarks of X Corp. This independent Actor is not affiliated with, associated with, or endorsed by X Corp.

Use public profile data in ways that fit your legal, contractual, and organizational obligations.