# X Follower Scraper | $0.15/1K Profiles | Pay-Per-Result (`xquik/x-follower-scraper`) Actor

Scrape X (Twitter) followers, following, list members, subscribers, and community members for $0.15 per 1,000 delivered profiles on every Apify plan. Filter before billing. Compare audiences. Apify bills platform usage separately. No X login. Built by Xquik. Not affiliated with X Corp.

- **URL**: https://apify.com/xquik/x-follower-scraper.md
- **Developed by:** [Xquik](https://apify.com/xquik) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 399 total users, 69 monthly users, 100.0% runs succeeded, 12 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.00015 / followers

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Scrape X (Twitter) followers, following, verified followers, List members, List
subscribers, and Community members for **$0.15 per 1,000 delivered profiles on
every Apify plan**. Apify bills platform usage separately. No X login, start
fee, or query fee.

>

### Incomplete extraction

Interrupted extraction writes a free `partial` diagnostic. Available results
remain intact. Read `availableResults`, `failedTargets`, `retryable`, and
`nextAction` before retrying. A successful Actor exit confirms delivery, not
complete extraction.

Xquik is an independent third-party service. Not affiliated with X Corp.

> "Twitter" and "X" are trademarks of X Corp.

### What does X Follower Scraper do?

X Follower Scraper returns available public profile data for followers,
following, Lists, and Communities. Each row includes its source target and
relation.

#### Core behavior

- Filters and duplicate removal run before billing.
- One run accepts handles, numeric IDs, URLs, and short paths.
- Merge mode records shared profiles, sources, relations, and `overlapCount`.
- Automatic cursors request up to 300 profiles per page.
- Older cursors keep their 200-profile limit and restart when expired.
- Page logs include `fetchDurationMs`, `processingDurationMs`, `pushDurationMs`,
  `statusDurationMs`, and `fullPageDurationMs` without repeating targets.
- Checkpoints preserve accepted rows, timing, and failure counts after restarts.

### Task examples

Choose from 50 public tasks. Each has a bounded input and a matching dataset
view. Every task opens with a real audience or filter. Edit it before running.

- [Discover AI builders in OpenAI followers](https://apify.com/xquik/x-follower-scraper/examples/discover-ai-builders-in-openai-followers)
- [Build an X audience dataset for AI agents](https://apify.com/xquik/x-follower-scraper/examples/build-agent-ready-x-audience-dataset)
- [Collect X audience data for RAG](https://apify.com/xquik/x-follower-scraper/examples/collect-x-audience-data-for-rag)
- [Find AI SEO practitioners on X](https://apify.com/xquik/x-follower-scraper/examples/find-ai-seo-practitioners-on-x)
- [Compare AI brand follower overlap](https://apify.com/xquik/x-follower-scraper/examples/compare-ai-brand-follower-overlap)
- [Export Twitter followers to CSV](https://apify.com/xquik/x-follower-scraper/examples/export-twitter-followers-to-csv)
- [Analyze competitor follower overlap](https://apify.com/xquik/x-follower-scraper/examples/analyze-competitor-follower-overlap)
- [Find micro-influencers in X followers](https://apify.com/xquik/x-follower-scraper/examples/find-micro-influencers-in-followers)
- [Export curated Twitter list members](https://apify.com/xquik/x-follower-scraper/examples/export-curated-twitter-list-members)
- [Analyze public X Community members](https://apify.com/xquik/x-follower-scraper/examples/analyze-public-x-community-members)
- [Collect Community members for AI agents](https://apify.com/xquik/x-follower-scraper/examples/collect-community-members-for-ai-agents)
- [Create repeatable X follower snapshots](https://apify.com/xquik/x-follower-scraper/examples/create-repeatable-follower-snapshots)

#### What data can X Follower Scraper extract?

| Field             | Description                                             |
| ----------------- | ------------------------------------------------------- |
| `id`              | Numeric X user ID                                       |
| `username`        | Handle (without `@`)                                    |
| `name`            | Display name                                            |
| `description`     | Bio text                                                |
| `followers`       | Follower count                                          |
| `following`       | Following count                                         |
| `statusesCount`   | Total tweets posted                                     |
| `mediaCount`      | Total media uploaded                                    |
| `favouritesCount` | Total likes given                                       |
| `verified`        | Combined public Blue or legacy verified flag            |
| `verifiedType`    | `blue`, `business`, `government`, or `none`             |
| `location`        | Self-reported location                                  |
| `url`             | Website URL from profile                                |
| `profilePicture`  | Avatar URL (full-size)                                  |
| `coverPicture`    | Banner URL                                              |
| `createdAt`       | Account creation timestamp string from X                |
| `sourceTarget`    | Handle / ID you scraped this profile from               |
| `sourceRelation`  | Relation: `followers`, `following`, `list_members`, ... |
| `sourceUrl`       | Exact URL the profile was discovered on                 |
| `sourceTargets`   | All targets that matched this profile in merge mode     |
| `sourceRelations` | All relations that matched this profile in merge mode   |
| `sourceUrls`      | All source URLs that matched this profile in merge mode |
| `overlapCount`    | Number of matching relation-target pairs in merge mode  |
| `resultType`      | Row type in full and raw output modes                   |
| `raw`             | Safe source profile before Actor-specific formatting    |

Rows follow the public profile contract. It covers identity, counts,
verification, availability, affiliates, professional data, and biographies.
Source attribution, entities, and pinned tweet IDs remain available. See OpenAPI
for the exact fields.

Set `outputMode: "raw"` or `includeRaw: true` to include a `raw` copy of the
safe source profile. Compact mode remains the default.

`verifiedOnly` accepts public Blue and legacy verified profiles. Conflicting
source flags never let a false value hide a true verification state.

Viewer-relative state belongs to Xquik's fetch account, not your dataset.
Follow, block, mute, DM, notification, and similar viewer flags are always
removed, including from raw output.

### How much does it cost to scrape X followers?

Every Apify plan costs `$0.00015` per delivered profile (`$0.15` per 1,000).
Apify bills your platform usage separately. Xquik applies one charge per
delivered data row. Diagnostics are free in the `diagnostics` output. No
separate Xquik subscription applies. No start fee applies. Each run writes a
`run-report` record with `estimatedChargeUsd` calculated from the live
pay-per-event price Apify exposes to the Actor. Every outcome writes
`run-report`, including no-input and invalid-input exits. Its `version` field
reports the exact published Actor source version.

`failedTargets` counts targets that stopped after a read failure. Accepted
profiles remain billable data rows. These runs use
`completionReason: "partial_failure"`. Fast server-side pagination follows the
same reporting contract.

The default Apify timeout is `0`. Runs have no time limit. The Actor follows
every live cursor until the cap or source ends. A caller can still set a finite
timeout. Then `completionReason: "deadline_reached"` means that limit is near.
The Actor reserves the final 15 seconds for checkpoints, rows, reports, and a
clean exit. Valid profiles remain delivered and bill once. Unfinished pagination
remains resumable.

Independent targets run concurrently. Each target keeps ordered cursor
pagination. Dataset writes keep caps, deduplication, attribution, and billing
atomic.

- Starts, targets, and relation selection add no separate query charge.
- Filters (`minFollowers`, `verifiedOnly`, `bioContains`, `locationContains`,
  `minFollowing`, `maxFollowing`, `minStatuses`, `maxStatuses`,
  `minAccountAgeDays`, `verifiedType`, `usernameContains`, `hasWebsite`,
  `hasLocation`) run before a profile enters your dataset.
- With `dedupeAcrossTargets: true`, repeats are removed before writing.
- Rows rejected by the dataset are not billed.
- No-input, invalid-input, and zero-output runs write 1 actionable record to the
  free `diagnostics` output.

Set `maxTotalChargeUsd` in the Apify API, or Max cost per run in Console, to
hard-cap spend. Apify exposes that limit to the Actor as
`ACTOR_MAX_TOTAL_CHARGE_USD`, and the Actor stops before accepting rows beyond
it. Leave `maxItems` empty to let the run return as many profiles as the spend
cap allows. Set `maxItems` only when you want a smaller result cap than the
budget would allow.

### How do I use X Follower Scraper to scrape follower data?

#### 1. Paste profile or list URLs

Paste profile, List, or Community URLs. The scraper routes each URL to its
relation:

```json
{
  "startUrls": [
    { "url": "https://x.com/nasa/followers" },
    { "url": "https://x.com/spacex/verified_followers" },
    { "url": "https://x.com/elonmusk/following" },
    { "url": "https://x.com/i/lists/1748648376080666720/members" },
    { "url": "https://x.com/i/communities/1493446837214187523/members" }
  ],
  "maxItems": 5000
}
```

#### 2. Bulk handles

Shorthand for many `/<handle>/followers` targets. Usernames accept `@` or no
prefix:

```json
{
  "twitterHandles": ["elonmusk", "nasa", "openai"],
  "relation": "followers",
  "maxItems": 1000
}
```

Set `relation` to `followers`, `following`, or `verified_followers` to switch
what is scraped for every handle.

Aliases accepted for the same input include `username`, `usernames`, and
`user_names`.

#### 3. Multi-relation runs

```json
{
  "usernames": ["nasa"],
  "relations": ["followers", "following"],
  "maxItems": 1000
}
```

You can also use booleans such as `getFollowers`, `getFollowing`,
`getVerifiedFollowers`, `getListMembers`, `getListFollowers`, and
`getCommunityMembers`.

#### 4. Scrape by numeric user, list, or community IDs

```json
{
  "userIds": ["44196397"],
  "listIds": ["1748648376080666720"],
  "communityIds": ["1493446837214187523"],
  "relation": "followers",
  "maxItemsPerTarget": 500,
  "maxItems": 1500
}
```

Aliases accepted for numeric user IDs include `twitterUserIds` and `user_ids`.

`relation` applies to numeric user IDs. List IDs default to members. Community
IDs always use members. `maxItemsPerTarget` prevents the first large target from
consuming the global limit.

#### 5. Filter before you pay

Apply filters so only matching profiles enter your dataset:

```json
{
  "twitterHandles": ["openai"],
  "relation": "followers",
  "minFollowers": 1000,
  "verifiedOnly": true,
  "verifiedType": "business",
  "minStatuses": 100,
  "usernameContains": "ai",
  "bioContains": "founder, CEO",
  "locationContains": "San Francisco",
  "maxItems": 500
}
```

The Actor may inspect more profiles than it writes. You only pay for rows that
pass every filter and enter your dataset.

Separate `bioContains` alternatives with commas or new lines. A profile passes
when its bio contains any supplied term. Matching stays case-insensitive.

#### 6. Find audience overlap

Use merge mode to compare competitors, lists, communities, or relation types:

```json
{
  "twitterHandles": ["openai", "anthropicai", "GoogleDeepMind"],
  "relation": "followers",
  "dedupeMode": "merge",
  "maxItemsPerTarget": 5000,
  "maxItems": 15000
}
```

The output contains one row per unique profile. Shared profiles include
`sourceTargets`, `sourceRelations`, `sourceUrls`, `sourceTargetKeys`, and
`overlapCount`, so you can sort by overlap or export directly to CSV. Keep
`maxItems` high enough to let every target contribute rows; use
`maxItemsPerTarget` to control depth per account.

#### Accepted URL shapes

| URL                                         | Relation                                |
| ------------------------------------------- | --------------------------------------- |
| `https://x.com/<handle>/followers`          | `followers`                             |
| `https://x.com/<handle>/verified_followers` | `verified_followers`                    |
| `https://x.com/<handle>/following`          | `following`                             |
| `https://x.com/<handle>`                    | default `relation` (followers if unset) |
| `https://x.com/i/lists/<id>/members`        | `list_members`                          |
| `https://x.com/i/lists/<id>/followers`      | `list_followers`                        |
| `https://x.com/i/lists/<id>`                | `list_members`                          |
| `https://x.com/i/communities/<id>/members`  | `community_members`                     |
| `https://x.com/i/communities/<id>`          | `community_members`                     |
| `<handle>/followers`                        | `followers`                             |
| `<handle>/following`                        | `following`                             |
| `<handle>/verified_followers`               | `verified_followers`                    |
| `lists/<id>/members`                        | `list_members`                          |
| `lists/<id>/followers`                      | `list_followers`                        |
| `communities/<id>/members`                  | `community_members`                     |

`twitter.com` and `mobile.twitter.com` are also accepted everywhere.

### Input

See the **Input** tab for the complete list of options. All fields are optional
except at least one of: `startUrls`, `twitterHandles`, `userIds`, `listIds`, or
`communityIds`, or their documented aliases.

Examples:

- Add a competitor handle to `twitterHandles` with `relation: "followers"`.
- Paste `https://x.com/<handle>/verified_followers` into Start URLs for verified
  profiles.
- Paste a list URL into Start URLs to audit its members.
- Add 2+ handles. Set `dedupeMode: "first"` to keep only the first matching
  profile row, or use `dedupeMode: "merge"` to keep one row with all matching
  source targets.

#### Console & API input UX

The Console exposes these controls:

- The Start URLs field accepts URL strings or `{ "url": "..." }` objects. Its
  JSON editor preserves both API formats.
- Relation, Output Mode, and Dedupe Mode are validated selects.
- Relations is a validated multi-select for multi-relation runs.
- Result limits accept whole numbers of 1 or more.
- Numeric profile filters accept whole numbers of 0 or more.

Use canonical fields in new integrations. Compatibility aliases remain available
in JSON, API, SDK, automation, and task inputs. This includes `outputVariant`
and `includeRaw` as Output Mode aliases. It also includes `dedupeAcrossTargets`
as a Dedupe Mode alias. The visual form hides aliases that duplicate a canonical
control. Existing JSON and saved task inputs keep their current behavior.

#### Always use the latest build

Store runs use the Actor's `latest` build configuration. API clients should omit
the build override or pass `build=latest`. Update Tasks and integrations that
pin an older build. Pinned builds never move automatically.

### Output

Each profile is a JSON object. Compact mode returns normalized public fields,
schema version fields, and source metadata when available:

Dataset and run-report schemas describe every returned field. Primitive fields
also include examples for agents and generated integrations.

Sample values are illustrative. Responses reflect source data at run time.

```json
{
  "schemaVersion": 1,
  "_schema_version": 1,
  "id": "44196397",
  "username": "elonmusk",
  "name": "Elon Musk",
  "description": "...",
  "followers": 180000000,
  "following": 500,
  "statusesCount": 42000,
  "mediaCount": 3200,
  "favouritesCount": 120000,
  "verified": true,
  "verifiedType": "blue",
  "location": "...",
  "url": "https://.../",
  "profilePicture": "https://.../",
  "coverPicture": "https://.../",
  "createdAt": "Tue Jun 02 20:12:29 +0000 2009",
  "sourceTarget": "nasa",
  "sourceRelation": "followers",
  "sourceUrl": "https://x.com/nasa/followers"
}
```

Merge dedupe mode adds overlap fields:

```json
{
  "schemaVersion": 1,
  "_schema_version": 1,
  "id": "44196397",
  "username": "elonmusk",
  "sourceTargets": ["nasa", "spacex"],
  "sourceRelations": ["followers"],
  "sourceUrls": [
    "https://x.com/nasa/followers",
    "https://x.com/spacex/followers"
  ],
  "sourceTargetKeys": ["followers:nasa", "followers:spacex"],
  "overlapCount": 2
}
```

Export as JSON, CSV, Excel, or HTML from the Apify dataset.

### Run options

- Set Apify max total charge to cap run cost. Leave `maxItems` empty for maximum
  rows within that budget, or set `maxItems` and `maxItemsPerTarget` when you
  want fewer profiles.
- Combine `minFollowers`, `verifiedOnly`, `verifiedType`, `minStatuses`,
  `usernameContains`, `bioContains`, `locationContains`, `hasWebsite`, and
  `hasLocation` to narrow the billed dataset.
- Set `dedupeMode: "first"` when scraping multiple competitor handles to get
  only unique profiles across all targets.
- Set `dedupeMode: "merge"` to get one row per profile with every matching
  source target attached.
- Set `outputMode: "full"` to get optional profile fields such as pinned tweet
  IDs, entities, and profile metadata when available.
- Set `outputMode: "raw"` or `includeRaw: true` to include a sanitized `raw`
  object alongside normalized fields.
- Schedule repeat Actor runs and store each dataset to compare profile IDs.
  Xquik monitors emit supported tweet and profile events, not follower-list
  changes.

### Use cases

- Export competitor followers for lead research.
- Compare audiences across your account, competitors, and public figures.
- Filter follower count and verification to find matching profiles.
- Export members of relevant X Communities.
- Build public social-network datasets for research.
- Segment follower bases by bio keyword, location, or profile type.

### Data responsibility

The Actor requests public X profile fields. Results can contain personal data,
including self-reported locations. Confirm a lawful purpose and follow
applicable privacy rules. Ask qualified counsel when uncertain.

### Related actors

- [X Tweet Scraper](https://apify.com/xquik/x-tweet-scraper): scrape tweets,
  engagement metrics, author profiles, and media with structured search filters
  and pay-per-result pricing

### Need more than scraping?

Xquik also provides 47 dashboard tools, 129 REST operations, signed webhooks,
and an MCP server.

- [API documentation](https://docs.xquik.com/introduction): REST API guides
- [Followers API](https://docs.xquik.com/api-reference/x/followers): fetch an
  account's available followers
- [Following API](https://docs.xquik.com/api-reference/x/following): get who a
  user follows
- [List Members API](https://docs.xquik.com/api-reference/x/list-members):
  export members from a public X list
- [MCP server](https://docs.xquik.com/mcp/overview): discover and run supported
  JSON or text operations
- [Webhooks](https://docs.xquik.com/webhooks/overview): receive supported Tweet
  and profile events

### FAQ

**Do I need an X API key?** No. This scraper uses its own infrastructure. No
login or credentials required.

**What limits a run?** Your requested item limit and Apify spend limit stop the
run. Apify account and platform limits still apply.

**How fast is it?** Runtime depends on target size, filters, and upstream
availability. Deep filtered runs checkpoint Console progress every 5 pages. This
reduces non-data traffic between page fetches.

**Why is my run returning fewer rows than `maxItems`?** Filters such as
`minFollowers`, `verifiedOnly`, and `bioContains` apply before writes. Relax
filters to return more results.

**How many followers can I scrape from a single account?** X paginates large
accounts in batches. Raise Apify's run time limit to fetch more pages.
`maxItemsPerTarget` only caps each target.

**Does the Actor retry temporary failures?** Yes. It makes up to 3 attempts per
page for timeouts, 429, and 5xx responses. It honors `Retry-After` when present.
Otherwise, it uses exponential backoff. Hard failures preserve partial results.

**What happens near the Apify run time limit?** The Actor adds no shorter run
deadline. It uses Apify's configured limit and keeps the final 15 seconds for
finalization. It flushes profiles, checkpoints pagination, writes the report,
and exits. Rows not accepted by the dataset are not billed.

**Can I resume where I left off?** Resume cursor input is not exposed yet.
Re-running the same target starts from its first available page.

**Can I use the Apify API to run this?** Yes. See the
[API tab](https://apify.com/xquik/x-follower-scraper/api) for Python,
JavaScript, and cURL examples.

**Can I schedule recurring scrapes?** Yes. Use Apify's built-in
[scheduling](https://docs.apify.com/platform/schedules) to run this Actor on a
cron. Compare stored datasets to find follower changes.

**Where do I report issues?** Use the Issues tab on this Actor's page.

**Where are the API docs?** Read the
[API documentation](https://docs.xquik.com/introduction).

# Actor input Schema

## `startUrls` (type: `array`):

Add profile relation, List, or Community URLs as strings or {"url":"..."} objects. Supported paths include /followers, /verified\_followers, /following, /lists/ID/members, /lists/ID/followers, and /communities/ID/members.

## `urls` (type: `array`):

Alias for Start URLs. Accepts a JSON array of URL strings, {"url":"..."} objects, and short paths like handle/followers, lists/ID/members, and communities/ID/members.

## `targets` (type: `array`):

Alias for Start URLs. Accepts a JSON array of URL strings or {"url":"..."} objects.

## `profileUrls` (type: `array`):

Alias for Start URLs for profile targets. Accepts a JSON array of URL strings or {"url":"..."} objects.

## `accountUrls` (type: `array`):

Alias for Start URLs for account targets. Accepts a JSON array of URL strings or {"url":"..."} objects.

## `twitterHandles` (type: `array`):

X usernames to scrape (with or without @). Use together with the Relation field below to decide what to pull. Example: elonmusk, @nasa

## `username` (type: `string`):

Single X handle alias.

## `usernames` (type: `array`):

Alias for X Handles.

## `user_names` (type: `array`):

Alias for X Handles.

## `userIds` (type: `array`):

Numeric X user IDs. Use when you already know the IDs; this skips handle resolution. Use with the Relation field.

## `twitterUserIds` (type: `array`):

Alias for Numeric User IDs.

## `user_ids` (type: `array`):

Alias for Numeric User IDs.

## `listIds` (type: `array`):

Numeric X list IDs. They default to List Members. Choose List Followers to scrape subscribers.

## `communityIds` (type: `array`):

Numeric X community IDs. They always scrape Community Members.

## `relation` (type: `string`):

Choose one relation for handles, user IDs, or list IDs. List IDs default to List Members. Community IDs always use Community Members. Start URLs override this choice.

## `relations` (type: `array`):

Choose several relations for the same handles, user IDs, or list IDs. Community IDs always use Community Members.

## `getFollowers` (type: `boolean`):

Turn on to scrape followers.

## `getFollowing` (type: `boolean`):

Turn on to scrape accounts the target follows.

## `getVerifiedFollowers` (type: `boolean`):

Turn on to scrape verified followers.

## `getListMembers` (type: `boolean`):

Turn on to scrape list members.

## `getListFollowers` (type: `boolean`):

Turn on to scrape list subscribers.

## `getCommunityMembers` (type: `boolean`):

Turn on to scrape community members.

## `maxItems` (type: `integer`):

Optional result cap across the entire run. Leave empty to use your Apify max total charge as the result limit when set. Without a spend cap, Xquik uses its built-in default. The Apify pricing box shows the current per-result price before the run starts.

## `maxResults` (type: `integer`):

API alias for Max Items.

## `max_results` (type: `integer`):

API alias for Max Items.

## `maxItemsPerTarget` (type: `integer`):

Optional cap per target. Leave empty to let Max Items apply across all targets.

## `outputMode` (type: `string`):

Compact returns core fields. Full adds optional profile fields. Raw adds a safe source snapshot.

## `outputVariant` (type: `string`):

API alias for Output Mode.

## `includeRaw` (type: `boolean`):

When true, selects raw output mode.

## `scrapeAllResults` (type: `boolean`):

Ignore Max Items Per Target and let Max Items control the total run size.

## `includeUnavailableFields` (type: `boolean`):

Deprecated compatibility input. Safe availability fields are already included when X provides them.

## `includeUnavailableUsers` (type: `boolean`):

Deprecated compatibility input. Unavailable profiles do not produce profile rows.

## `includeTargetMetadata` (type: `boolean`):

Attach sourceTarget, sourceRelation, and sourceUrl on every row. Critical when scraping multiple targets in one run.

## `dedupeAcrossTargets` (type: `boolean`):

Return a user from multiple targets once. The first target wins. Use this for follower-overlap analysis.

## `dedupeMode` (type: `string`):

None keeps one row per target. First keeps the first target. Merge combines sources and adds overlap fields.

## `overlapMode` (type: `boolean`):

Shortcut for merge dedupe mode. Use when comparing competitor audiences, lists, or communities.

## `minFollowers` (type: `integer`):

Only include users with at least this many followers.

## `maxFollowers` (type: `integer`):

Only include users with at most this many followers. Set a cap to exclude large accounts.

## `minFollowing` (type: `integer`):

Only include users who follow at least this many accounts.

## `maxFollowing` (type: `integer`):

Only include users who follow at most this many accounts.

## `minStatuses` (type: `integer`):

Only include users with at least this many posted tweets.

## `maxStatuses` (type: `integer`):

Only include users with at most this many posted tweets.

## `minAccountAgeDays` (type: `integer`):

Only include users whose account is at least this many days old. Good anti-bot signal.

## `verifiedOnly` (type: `boolean`):

Only include profiles with a public Blue or legacy verified state.

## `verifiedType` (type: `string`):

Only include users with this verification type when X provides it. Example: blue, business, government.

## `hasWebsite` (type: `boolean`):

Only include users whose public profile website is present in the relation data.

## `hasLocation` (type: `boolean`):

Only include users who list a location in their profile.

## `bioContains` (type: `string`):

Only include users whose bio contains any supplied term (case-insensitive). Separate alternatives with commas or new lines. Example: founder, CEO, engineer.

## `locationContains` (type: `string`):

Only include users whose location contains this text (case-insensitive). Example: New York, London, Tokyo.

## `usernameContains` (type: `string`):

Only include users whose username contains this text (case-insensitive).

## Actor input object example

```json
{
  "twitterHandles": [
    "elonmusk",
    "@nasa"
  ],
  "username": "nasa",
  "usernames": [
    "elonmusk",
    "@nasa"
  ],
  "user_names": [
    "elonmusk",
    "@nasa"
  ],
  "userIds": [
    "44196397"
  ],
  "twitterUserIds": [
    "44196397"
  ],
  "user_ids": [
    "44196397"
  ],
  "listIds": [
    "1748648376080666720"
  ],
  "communityIds": [
    "1493446837214187523"
  ],
  "relation": "followers",
  "getFollowers": false,
  "getFollowing": false,
  "getVerifiedFollowers": false,
  "getListMembers": false,
  "getListFollowers": false,
  "getCommunityMembers": false,
  "maxItems": 100000,
  "outputMode": "full",
  "includeRaw": false,
  "scrapeAllResults": false,
  "includeUnavailableFields": false,
  "includeUnavailableUsers": false,
  "includeTargetMetadata": true,
  "dedupeAcrossTargets": false,
  "dedupeMode": "merge",
  "overlapMode": false,
  "minFollowers": 1000,
  "verifiedOnly": false,
  "verifiedType": "business",
  "hasWebsite": false,
  "hasLocation": false,
  "bioContains": "founder",
  "locationContains": "New York",
  "usernameContains": "ai"
}
```

# Actor output Schema

## `users` (type: `string`):

Normalized profiles with public verification, source metadata, and overlap metadata.

## `diagnostics` (type: `string`):

Free actionable diagnostics for empty, partial, invalid, aborted, or recovered runs. Real results remain in the dataset.

## `runReport` (type: `string`):

Run summary with configuration, target results, duration, outcome, completion reason, and anomalies. pagination\_safety\_limit means valid profiles were retained. The bounded live-cursor empty-page safety limit then stopped pagination.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "twitterHandles": [
        "OpenAI"
    ],
    "outputMode": "full"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xquik/x-follower-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "twitterHandles": ["OpenAI"],
    "outputMode": "full",
}

# Run the Actor and wait for it to finish
run = client.actor("xquik/x-follower-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "twitterHandles": [
    "OpenAI"
  ],
  "outputMode": "full"
}' |
apify call xquik/x-follower-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xquik/x-follower-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/AaT0BcKU5GQh97wdt/builds/N0fTgBSB6A6r9Rbic/openapi.json