# X (Twitter) Retweeter Scraper — Enriched Profiles (`korado_labs/x-twitter-retweeter-scraper`) Actor

Get everyone who retweeted any public X/Twitter post as enriched profiles: bio, follower/following/tweet counts, verification, account age, ratio, avatar & banner. Tweet URL or ID. Export data, run via API, schedule runs, or integrate with other tools.

- **URL**: https://apify.com/korado\_labs/x-twitter-retweeter-scraper.md
- **Developed by:** [Korado Labs](https://apify.com/korado_labs) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.60 / 1,000 retweeter profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## X (Twitter) Retweeter Scraper — Enriched Profiles

Get **everyone who retweeted any public X/Twitter post**, returned as fully
enriched profiles — not just handles. Paste a tweet URL (or ID), add your X
`auth_token` cookie, and the actor pages through the entire retweeter list and
returns one rich record per person: handle, display name, expanded bio,
follower / following / tweet / media counts, verification status, account age,
follower-to-following ratio, full-resolution avatar & banner, pinned tweet,
location, website and more.

Perfect for **influencer discovery, audience research, amplifier analysis,
competitive intelligence, and community outreach.**

### Why this scraper

| | This actor | Typical retweeter scrapers |
|---|---|---|
| Fields per retweeter | 25+ enriched fields | handle + a few raw counts |
| Bio | t.co links **expanded** to real URLs | raw `t.co` shortlinks |
| Computed signals | account age, follower/following ratio | — |
| Verification | Blue **and** legacy, split out | single flag or missing |
| Images | **full-resolution** avatar + banner | 48px `_normal` thumbnail |
| Input | tweet **URL or ID** | ID only |
| Reliability | self-healing GraphQL query discovery + proxy rotation + retries | breaks when X rotates its internal API |
| Billing | **only per retweeter delivered**, deduped, nothing on failure | often per-run or per-start fees |

### Two engines — pick one

Retweeter lists are **login-only on X** in 2026 (guest/anonymous access was
removed). This actor gets them one of two ways:

1. **Pool engine (recommended, cookieless).** Provide a **GetXAPI key** and
   the actor reads retweeters through their pool-based service — *no cookies,
   no X account needed on your side.* Get a key in <5 min at
   [getxapi.com](https://getxapi.com) (email sign-up, **free credits, no
   card**). Provider cost is $0.001 per page of up to ~100 retweeters.
2. **Cookie engine (self-hosted).** Provide your own X **`auth_token`** cookie
   and the actor drives X's internal API directly, with no third party.

Supply **one** of `apiKey` or `authToken`. If both are set, the pool engine wins.

### Input

| Field | Required | Description |
|---|---|---|
| `tweetUrl` | – | Tweet URL (`https://x.com/user/status/123…`) or just the numeric ID. |
| `apiKey` | one of | GetXAPI key (recommended, cookieless). |
| `authToken` | one of | Your X `auth_token` cookie (self-hosted engine). |
| `maxResults` | – | Cap the number of retweeters (default 100). |
| `csrfToken` | – | Optional `ct0` cookie for the cookie engine; auto-derived if omitted. |
| `includeRaw` | – | Also attach the raw user object under `raw`. |
| `proxy` | – | Proxy config; residential recommended. |

#### Getting a GetXAPI key (recommended)

1. Go to [getxapi.com](https://getxapi.com) → **Signup** (email + password, no
   credit card, free credits included).
2. Verify your email, then in the dashboard hit **Create Key** and copy it into
   the **API key** field. Done — no cookies.

#### Getting your `auth_token` (self-hosted engine)

1. Log in to **x.com** in your browser (use a **secondary / burner account** —
   this grants read access as that account).
2. Open **DevTools → Application → Cookies → `https://x.com`**.
3. Copy the value of the **`auth_token`** cookie into the *Auth token* field.
   The `ct0` (CSRF) cookie is derived automatically.

### Output

One item per unique retweeter:

```json
{
  "userId": "44196397",
  "username": "elonmusk",
  "url": "https://x.com/elonmusk",
  "name": "Elon Musk",
  "bio": "http://Terafab.AI",
  "location": null,
  "website": null,
  "followersCount": 241409683,
  "followingCount": 1392,
  "tweetsCount": 107261,
  "mediaCount": 4705,
  "isVerified": true,
  "isBlueVerified": true,
  "isLegacyVerified": false,
  "isProtected": false,
  "professionalType": "Creator",
  "createdAt": "2009-06-02T20:12:29+00:00",
  "accountAgeDays": 6286,
  "followerFollowingRatio": 173426.496,
  "profileImageUrl": "https://pbs.twimg.com/profile_images/2053244804520427520/m8mdWZCG.jpg",
  "bannerImageUrl": "https://pbs.twimg.com/profile_banners/44196397/1774145451",
  "pinnedTweetId": "2090079231783120975",
  "tweetId": "1585341984679469056",
  "retweeterRank": 1
}
```

### Pricing

**Pay-per-result: $0.012 per retweeter profile delivered.** You are charged once
per **unique** profile actually returned — never for retweeters you didn't
receive, and **nothing at all on a failed or blocked run**. No per-run or
per-start fee.

Example: scraping 500 retweeters of a viral post → **500 × $0.012 = $6.00**.

### Notes & limits

- Retweeters come back **newest-first**, paginated automatically up to
  `maxResults`.
- Protected/suspended accounts among the retweeters are skipped automatically.
- **Pool engine:** you fund your own TwitterAPI.io balance (~$0.00015/retweeter);
  it's separate from Apify charges. **Cookie engine:** use a burner X account —
  scraping activity is attributed to it.

# Actor input Schema

## `tweetUrl` (type: `string`):

The tweet whose retweeters you want. Paste a full URL (https://x.com/user/status/123...) or just the numeric tweet ID.

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

Stop after collecting this many retweeters. X returns them newest-first.

## `apiKey` (type: `string`):

Recommended engine — no cookies needed. Get a free key at getxapi.com (email sign-up, free credits, no card). Retweeter lists are login-only on X; this pool-based provider reads them for you at $0.001 per page of up to 100 retweeters. Leave the auth\_token field empty when using this.

## `authToken` (type: `string`):

Alternative to the API key: your own X 'auth\_token' cookie, driving X's internal API directly (no third party). Log in to x.com, open DevTools → Application → Cookies → https://x.com, copy the 'auth\_token' value. Use a secondary/burner account — it authorizes read access as that account.

## `csrfToken` (type: `string`):

Optional. The 'ct0' cookie value from the same x.com session. Leave empty and the actor derives it automatically from your auth\_token.

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

Also attach X's full raw user object to each record under 'raw'. Off by default for compact output.

## `proxy` (type: `object`):

Proxy used to reach X. Residential proxies are recommended for stability.

## Actor input object example

```json
{
  "tweetUrl": "1585341984679469056",
  "maxResults": 100,
  "includeRaw": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One enriched profile per user who retweeted the source tweet, in X's returned order.

# 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 = {
    "tweetUrl": "https://x.com/elonmusk/status/1585341984679469056",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("korado_labs/x-twitter-retweeter-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 = {
    "tweetUrl": "https://x.com/elonmusk/status/1585341984679469056",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("korado_labs/x-twitter-retweeter-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 '{
  "tweetUrl": "https://x.com/elonmusk/status/1585341984679469056",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call korado_labs/x-twitter-retweeter-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,korado_labs/x-twitter-retweeter-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/ISBABoN2XY3tVL7vv/builds/6PrkPKbTzY4a1jeQm/openapi.json