# X (Twitter) Retweeters & Quote Tweets Scraper (`arjun_code/x-twitter-retweeters-scraper`) Actor

Export public accounts that reposted or quoted any X (Twitter) post. Enter post URLs or IDs to collect usernames, bios, follower counts, verification, professional details, affiliations, and quote-tweet text. No login, cookies, API key, or proxy setup required. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/arjun\_code/x-twitter-retweeters-scraper.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Export public profiles for people who reposted or quoted one or more X (Twitter) posts. Enter post URLs or numeric IDs, choose retweeters, quote-tweet authors, or both, and download structured results as JSON, JSONL, CSV, Excel, XML, or RSS.

No X login, cookies, API key, or proxy configuration is required from the user.

### What this Actor collects

- Visible retweeters from X's native Retweeters timeline.
- Authors of visible quote tweets, including quote-post text, timestamps,
  language, engagement counts, views, entities, and available media metadata.
- Usernames, display names, bios, locations, profile links, avatars, and banners.
- Follower, following, post, media, and like counts.
- Verification, professional categories, account labels, affiliations, and profile flags.
- The original X user object when `includeRawUser` is enabled.

The Actor follows pagination automatically, removes duplicate users within each source post and engagement type, and stores every completed page immediately.

### Use cases

- Measure who amplified a campaign, announcement, or product launch.
- Find creators, customers, community members, and potential leads engaging with a post.
- Review the people and commentary behind quote-tweet activity.
- Enrich public account lists with audience, verification, professional, and affiliation data.
- Export engagement data into spreadsheets, CRMs, dashboards, or automated workflows.

### How to use it

1. Add up to 50 unique X post URLs or numeric post IDs.
2. Choose **Retweeters only**, **Quote-tweet authors only**, or **Retweeters and quote-tweet authors**.
3. Set the per-post result limits and click **Start**.

The default limits return up to 100 retweeters and 100 quote users per source post. Set a limit to `0` only when you want every cursor page currently exposed by X.

### Input

| Field | Description | Default |
| --- | --- | --- |
| `tweets` | Up to 50 unique numeric post IDs or full `x.com` / `twitter.com` status URLs. Duplicate post IDs are requested once; invalid values are reported without blocking valid posts. | Required |
| `resultType` | `retweeters`, `quote_users`, or `both`. | `retweeters` |
| `maxRetweetersPerTweet` | Maximum unique retweeters per source post. Use `0` for all exposed pages. | `100` |
| `maxQuoteUsersPerTweet` | Maximum unique quote users per source post. Use `0` for all exposed pages. | `100` |
| `includeRawUser` | Adds the complete native X user object as `raw_user`. | `false` |

#### Example input

```json
{
  "tweets": [
    "https://x.com/SpaceX/status/2099211149476569207"
  ],
  "resultType": "both",
  "maxRetweetersPerTweet": 2,
  "maxQuoteUsersPerTweet": 2,
  "includeRawUser": false
}
```

Posts are processed sequentially. Each run accepts up to 50 unique post IDs after equivalent URLs and duplicate IDs are normalized. Split larger batches across multiple runs. More posts and larger per-post limits increase runtime and cost.

### Output

Each successful Dataset item represents one visible engagement user:

- `engagement_type: "retweet"` — the user appeared in X's Retweeters timeline.
- `engagement_type: "quote"` — the user authored a visible post quoting the source post.

Quote results also contain the quote-post ID, URL, text, timestamp, language,
engagement counts, view count, entities, sensitivity flag, and available media
metadata. Core values are flat for straightforward filtering and CSV/Excel
exports; `quote_media` is an array because one quote post can contain multiple
media items.

All `quote_*_count` values describe engagement on the quote post itself, not on
the original source post. For example, `quote_retweet_count` is how many times
that quote post was retweeted.

```json
{
  "status": "success",
  "engagement_type": "quote",
  "tweet_id": "2099211149476569207",
  "tweet_url": "https://x.com/SpaceX/status/2099211149476569207",
  "quote_tweet_id": "2099235794024067188",
  "quote_tweet_url": "https://x.com/edwards345/status/2099235794024067188",
  "quote_text": "Today’s launch represents our 700th successful Falcon mission...",
  "quote_created_at": "Sun Sep 13 20:36:29 +0000 2026",
  "quote_language": "en",
  "quote_reply_count": 22,
  "quote_retweet_count": 101,
  "quote_like_count": 1270,
  "quote_quote_count": 7,
  "quote_bookmark_count": 30,
  "quote_view_count": 57477,
  "quote_possibly_sensitive": false,
  "quote_hashtags": [],
  "quote_mentions": ["SpaceX"],
  "quote_urls": [],
  "quote_media": [],
  "user_id": "29279483",
  "screen_name": "edwards345",
  "profile_url": "https://x.com/edwards345",
  "name": "Jon Edwards",
  "description": "SVP of Falcon and Dragon at SpaceX...",
  "location": "Redondo Beach, CA",
  "followers_count": 25499,
  "friends_count": 741,
  "tweets_count": 1264,
  "verified": false,
  "is_blue_verified": true,
  "affiliation_name": "SpaceX",
  "profile_image_url": "https://pbs.twimg.com/profile_images/...jpg"
}
```

The **Overview** Dataset view emphasizes identity, audience metrics, quote context, and clickable links. Use **Detailed** for the complete normalized schema and Apify's built-in **All fields** view for the raw Dataset record.

Diagnostic rows use one of these statuses:

- `invalid_input` — the submitted value is not a numeric post ID or supported X / Twitter status URL; other valid inputs continue normally.
- `not_found` — the source post was deleted, unavailable, or does not exist.
- `no_results` — the source post exists, but X returned no visible users for that engagement type.
- `partial` — earlier pages were stored before a later request failed.
- `request_failed` — the request failed before a user result was stored.
- `charge_limit_reached` — the run stopped at the user's maximum cost setting.

Diagnostic rows are not charged as user results.

### Pricing

This Actor uses pay-per-event pricing. A successfully stored retweeter produces
one `retweeter-result` event. A successfully stored quote-tweet author, including
the visible quote-post context, produces one `quote-user-result` event.

| Apify plan | Retweeter / result | Retweeters / 1,000 | Quote author / result | Quote authors / 1,000 |
| --- | ---: | ---: | ---: | ---: |
| Free | $0.00050 | $0.50 | $0.00100 | $1.00 |
| Bronze | $0.00040 | $0.40 | $0.00080 | $0.80 |
| Silver | $0.00030 | $0.30 | $0.00070 | $0.70 |
| Gold, Platinum, and Diamond | $0.00025 | $0.25 | $0.00060 | $0.60 |

An `apify-actor-start` event costs $0.00005 per run. On the Free tier, 100
retweeters cost approximately $0.05005, 100 quote-tweet authors cost
approximately $0.10005, and 100 of each cost approximately $0.15005, including
the single start event. No result event is charged for `no_results`, failure,
partial-status, or charge-limit status rows. Platform usage is included in the
configured event prices.

Use Apify's **Maximum cost per run** setting to control spending. Once that limit is reached, the Actor stores only the affordable result prefix and stops before requesting another page or processing another source post.

### Pagination and reliability

Every page is attempted up to five times. Temporary connection and X server errors refresh the request route; authentication and rate-limit responses switch to another healthy route and retry the same cursor.

Retweeter pagination uses X's non-ranked mode to avoid the duplicate second pass observed with ranked results. Quote search verifies each result against the requested source post so unrelated search entries are excluded. Pagination stops when X returns no exact matches, repeats a cursor, reaches the requested result limit, or reaches the run's maximum cost.

Results are deduplicated by user ID separately for each source post and engagement type. In `both` mode, someone who both reposted and quoted the source post can appear twice—once as `retweet` and once as `quote`.

Completed pages remain in the Dataset when a later page fails. A run with partial results finishes successfully and reports the affected engagement flow. If no user result is stored and a technical request fails, the run ends as failed instead of reporting a misleading success.

### Availability and result limits

X may expose fewer profiles than the repost or quote count displayed on the post. Deleted, protected, suspended, withheld, restricted, or otherwise unavailable accounts are not returned as successful rows.

When an engagement search returns no users, the Actor verifies the source post. This distinguishes an existing post with no visible engagement (`no_results`) from a missing or unavailable post (`not_found`).

Quote users come from X's native Top search timeline. The result is not guaranteed to contain every quote tweet X displays. One user is returned once per source post; if the same user authored multiple visible quote tweets, the first matching quote encountered is retained.

### Run with the Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/arjun_code~x-twitter-retweeters-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tweets": ["https://x.com/SpaceX/status/2099211149476569207"],
    "resultType": "both",
    "maxRetweetersPerTweet": 100,
    "maxQuoteUsersPerTweet": 100
  }'
```

You can also run the Actor from schedules, webhooks, Make, Zapier, or any client that can call the Apify API.

### FAQ

#### Why is the result count lower than the number shown on X?

X does not always expose every engager through its timelines. Deleted, private, suspended, withheld, and otherwise unavailable accounts can also reduce the visible count.

#### Are quote-tweet results exhaustive?

No. Quote users are collected from X's native Top search timeline. The Actor filters that timeline precisely and follows every cursor X returns, but it cannot return results X does not expose through search.

#### Can one person appear more than once?

Within one source post and engagement type, no. In `both` mode, the same person may appear once as a retweeter and once as a quote-tweet author because those are different actions.

#### Do I need my own X account or proxy?

No. Users do not provide X credentials, cookies, API keys, or proxy settings.

#### What happens when a request fails during pagination?

Already stored pages remain available. The Dataset receives a clear partial or failure status row. A complete technical failure causes the run itself to fail.

### Related X Actors

| Actor | Best for |
| --- | --- |
| [X Followers & Following Scraper](https://apify.com/arjun_code/x-twitter-followers-followings-scraper) | Exporting follower and following profiles |
| [X People Search Scraper](https://apify.com/arjun_code/x-twitter-people-search-scraper) | Finding public accounts by keyword |
| [X Media Downloader & Post Details](https://apify.com/arjun_code/x-twitter-media-downloader) | Post details, images, videos, and author data |
| [X Similar Accounts Finder](https://apify.com/arjun_code/x-twitter-similar-accounts-finder) | Discovering accounts related to a seed profile |
| [X Account Origin Intelligence](https://apify.com/arjun_code/x-twitter-account-origin-scraper) | Account-origin and profile intelligence |
| [X Profile & Username Change Monitor](https://apify.com/arjun_code/x-twitter-profile-username-history-monitor) | Monitoring public profile and username changes |

### Privacy, limitations, and support

The Actor processes information exposed by X for public posts and profiles. Internal cookies, proxy details, and authentication data are never written to the result Dataset.

This independent Actor is not affiliated with, endorsed by, or sponsored by X Corp. Use the data lawfully and follow X, Apify, and applicable privacy requirements.

If a run fails or X changes its response format, open an issue on the Actor page and include the Apify run ID, input, and expected behavior. Never include passwords, cookies, tokens, or other secrets.

# Actor input Schema

## `tweets` (type: `array`):

Enter up to 50 unique X posts per run, one per line. Each value may be a numeric post ID or a full x.com/twitter.com status URL. Duplicate post IDs are requested only once, invalid values are reported separately, and valid posts are processed sequentially.

## `resultType` (type: `string`):

Choose whether to collect users who reposted the post, authors of visible quote tweets, or both groups.

## `maxRetweetersPerTweet` (type: `integer`):

Maximum number of visible retweeter profiles returned for each post. Enter 0 to follow all cursor pages exposed by X.

## `maxQuoteUsersPerTweet` (type: `integer`):

Maximum number of unique authors returned from posts that quote the source post. Enter 0 to follow all cursor pages exposed by X.

## `includeRawUser` (type: `boolean`):

Adds the original native X user object as raw\_user. Leave disabled for smaller, flat records.

## Actor input object example

```json
{
  "tweets": [
    "https://x.com/SpaceX/status/2099220930589327483"
  ],
  "resultType": "retweeters",
  "maxRetweetersPerTweet": 100,
  "maxQuoteUsersPerTweet": 100,
  "includeRawUser": false
}
```

# Actor output Schema

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

Public account details for users returned by X's Retweeters timeline or quoted-post search.

# 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 = {
    "tweets": [
        "https://x.com/SpaceX/status/2099220930589327483"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-retweeters-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 = { "tweets": ["https://x.com/SpaceX/status/2099220930589327483"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-retweeters-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 '{
  "tweets": [
    "https://x.com/SpaceX/status/2099220930589327483"
  ]
}' |
apify call arjun_code/x-twitter-retweeters-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/x-twitter-retweeters-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/sgy3K7Ax1S7LCOLPY/builds/sUQQTLAJKoMpuKV9w/openapi.json