# X (Twitter) Tweet Engagers & Audience Leads (`arjun_code/x-twitter-tweet-engagers`) Actor

Turn public X/Twitter Retweets, Quote Tweets, and replies into one deduplicated audience list. Compare repeat engagers across Tweets and export profiles, engagement evidence, follower counts, and verification—no login or API key required.

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

## Pricing

from $1.30 / 1,000 unique engager results

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

Turn public Retweets, Quote Tweets, and replies into one deduplicated X/Twitter audience list. Add up to 25 public Tweet URLs or IDs, choose the engagement types you need, and export matching users with profile details and evidence of how each person engaged.

Use this Actor to identify repeat engagers, campaign advocates, relevant creators, active community members, and public accounts worth reviewing or contacting. No X login, cookies, API key, or proxy setup is required.

### What this Actor does

- Collects public users who Retweeted, quoted, or replied to each input Tweet.
- Combines the same person across multiple Tweets and engagement types into one row.
- Shows the Tweet and action behind every match instead of returning an unexplained username list.
- Finds repeat engagers across several Tweets or people who used several engagement types.
- Filters saved users by follower count and X verification status.
- Optionally includes visible replies inside the wider conversation, not only direct replies.
- Exports structured results to JSON, CSV, Excel, XML, RSS, or the Apify API.

### Common use cases

- Build a public lead list from people who engaged with a launch, event, or campaign.
- Find repeat supporters and high-intent community members across several Tweets.
- Compare who amplified, discussed, or replied to your content.
- Review public Quote Tweet and Reply text for audience research.
- Discover creators and verified accounts already engaging in a topic.
- Send clean engagement data to a CRM, spreadsheet, dashboard, or AI workflow.

### How to use

1. Add up to 25 public Tweet URLs or numeric Tweet IDs.
2. Choose Retweets, Quote Tweets, Replies, or any combination.
3. Set **Users per engagement type, per Tweet**. Use `0` to follow every page currently exposed by X.
4. Optionally require repeat engagement, multiple action types, a minimum follower count, or a verification group.
5. Click **Start** and open the Dataset when the run finishes.

The same Tweet entered more than once is processed once. Valid Tweets continue even when another input is invalid or unavailable.

### Input reference

| Field | Purpose |
| --- | --- |
| `tweets` | Up to 25 public Tweet URLs or numeric IDs. |
| `collectRetweets` | Include public users who Retweeted each Tweet. |
| `collectQuoteTweets` | Include Quote Tweet authors plus their public Quote text and metrics. |
| `collectReplies` | Include public users who replied. |
| `includeThreadReplies` | Also include visible replies to other replies. Ignored when Replies are off. |
| `maxUsersPerTypePerTweet` | Collection limit for each selected type on each Tweet. `0` means all records currently exposed by X. |
| `engagerMatch` | Save any engager, users with at least two action types, or users matching every selected type. |
| `minimumTweetsEngaged` | Require activity on this many different input Tweets. |
| `minimumFollowers` | Keep accounts with at least this many followers. `0` disables the filter. |
| `verification` | Keep any, any verified, blue verified, official/legacy verified, or unverified accounts. |

Example input for finding repeat engagers across three Tweets:

```json
{
  "tweets": [
    "https://x.com/thsottiaux/status/2109892247580000595",
    "https://x.com/thsottiaux/status/2109812360596865224",
    "https://x.com/thsottiaux/status/2109132167112782291"
  ],
  "collectRetweets": true,
  "collectQuoteTweets": true,
  "collectReplies": true,
  "includeThreadReplies": false,
  "maxUsersPerTypePerTweet": 100,
  "engagerMatch": "any",
  "minimumTweetsEngaged": 1,
  "minimumFollowers": 0,
  "verification": "any"
}
```

### How audience matching works

Every successful Dataset row represents one unique public X user, even when that person took several actions or engaged with several input Tweets.

- **Any selected engagement** — the broadest audience.
- **At least 2 engagement types** — people who used two or more selected action types.
- **Every selected type across the input Tweets** — actions may occur on different Tweets.
- **Every selected type on the same Tweet** — every selected action must occur on at least one common Tweet.

For example, someone who Retweeted Tweet A and replied to Tweet B matches **across the input Tweets**, but not **on the same Tweet**.

### Output

The result is designed for both quick review and downstream processing:

- `user` contains the public profile, follower counts, verification, website, professional category, affiliation, and profile images when returned by X.
- `engagement_summary` explains the user's total actions, action types, and number of input Tweets engaged.
- `engagements_by_tweet` separates the user's activity for each source Tweet.
- `engagements` contains the individual Retweet, Quote Tweet, and Reply evidence. Quote Tweets and Replies include text, URL, time, and available metrics.

The following shortened row comes from a real public test run:

```json
{
  "status": "success",
  "user": {
    "user_id": "577207659",
    "username": "Injection4Xcode",
    "name": "Injection for Xcode",
    "profile_url": "https://x.com/Injection4Xcode",
    "location": "Italy (VT)",
    "created_at": "2012-05-11T13:14:17Z",
    "followers_count": 1991,
    "following_count": 209,
    "tweets_count": 12567,
    "verified": false,
    "blue_verified": false,
    "protected": false
  },
  "engagement_summary": {
    "selected_engagement_types": ["retweet", "quote", "reply"],
    "engagement_types": ["retweet"],
    "total_actions": 3,
    "retweets_by_user": 3,
    "quote_tweets_by_user": 0,
    "replies_by_user": 0,
    "tweets_engaged": 3,
    "matches_all_selected_types": false,
    "matches_all_selected_types_on_same_tweet": false
  },
  "source_tweet_ids": [
    "2109132167112782291",
    "2109812360596865224",
    "2109892247580000595"
  ],
  "engagements": [
    {
      "type": "retweet",
      "source_tweet_id": "2109892247580000595",
      "source_tweet_url": "https://x.com/thsottiaux/status/2109892247580000595"
    }
  ]
}
```

### Dataset views and status rows

The **Overview** view puts usernames, engagement types, repeat-engagement counts, followers, verification, affiliation, and profile links first. Use **All fields** for the complete nested record.

The **Status rows** view explains inputs that did not produce a normal user row:

- `invalid_input` — unsupported Tweet URL or ID;
- `not_found` — deleted, private, unavailable, or nonexistent Tweet;
- `no_results` — no visible engagers or no users matching the filters;
- `partial` — some results were saved, but one collection stream could not finish;
- `request_failed` — the public request could not be completed.

### Coverage and limits

X decides which public engagement records are visible and how far each timeline can be paginated. Therefore, `0 = all` means all records currently exposed by X's public web timelines; it does not guarantee that the Dataset will equal the engagement counter displayed on the Tweet.

Deleted content, protected accounts, withheld content, and engagement that X does not expose cannot be returned. Large Tweets, nested conversations, multiple input Tweets, and `0 = all` runs take longer than small capped runs.

### Pricing

This Actor uses pay-per-event pricing. A small `$0.00005` Actor start event is charged when a run begins. The `engager-result` event is charged once for each unique user successfully saved after deduplication and filtering. Status rows such as `invalid_input`, `not_found`, `no_results`, `partial`, and `request_failed` are not charged as results.

| Apify plan | Per unique engager | Per 1,000 unique engagers |
| --- | ---: | ---: |
| Free | `$0.00200` | `$2.00` |
| Bronze | `$0.00180` | `$1.80` |
| Silver | `$0.00150` | `$1.50` |
| Gold | `$0.00130` | `$1.30` |
| Platinum | `$0.00130` | `$1.30` |
| Diamond | `$0.00130` | `$1.30` |

The Actor's live **Pricing** tab is authoritative if prices change. Use **Maximum cost per run** to set a hard spending limit.

### API, schedules, and integrations

Run the Actor from the Apify Console, JavaScript client, Python client, REST API, Tasks, Schedules, Webhooks, or Apify MCP. Results can be sent to Google Sheets, Make, Zapier, Slack, a database, or your own application.

JavaScript example:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('arjun_code/x-twitter-tweet-engagers').call({
  tweets: ['https://x.com/thsottiaux/status/2109892247580000595'],
  collectRetweets: true,
  collectQuoteTweets: true,
  collectReplies: true,
  maxUsersPerTypePerTweet: 100,
  engagerMatch: 'any'
});

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

Example MCP request:

```text
Run arjun_code/x-twitter-tweet-engagers for these three Tweet URLs. Include Retweets, Quote Tweets, and Replies, then return users who engaged with at least two Tweets.
```

### FAQ

#### Does the Actor require my X account or API key?

No. Users do not provide an X login, cookies, API key, or proxy.

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

Tweet counters are aggregate numbers. X may hide, remove, protect, rank, or stop exposing some underlying accounts and posts through public timelines.

#### Is one row one action or one user?

One successful row is one unique user. The nested engagement fields preserve all collected actions for that user.

#### Can it collect Likes?

No. This Actor focuses on publicly enumerable Retweets, Quote Tweets, and Replies.

#### Can I analyze Tweets from accounts I do not own?

Yes, when the Tweet and its engagement are publicly available. You are responsible for using the data lawfully.

### Related Actors

- [X (Twitter) Retweeters & Quote Tweets Scraper](https://apify.com/arjun_code/x-twitter-retweeters-scraper) — use when you want one row per Retweeter or Quote Tweet author without cross-Tweet audience aggregation.
- [X (Twitter) Replies Scraper](https://apify.com/arjun_code/x-twitter-replies-scraper) — use for deeper Reply and conversation analysis.
- [X (Twitter) Post Performance & Growth Monitor](https://apify.com/arjun_code/x-twitter-post-performance-monitor) — track how a Tweet's engagement metrics change over time.

### Privacy, responsible use, and support

This Actor collects public X data. Do not use it for harassment, discrimination, unlawful surveillance, spam, or decisions that violate applicable law or X's terms. Review your legal basis, minimize retained personal data, and delete exports when they are no longer needed.

For help, open an Issue on the Actor page and include the Run ID, sanitized input, expected behavior, and relevant log excerpt. Never post credentials or private data in an Issue.

This independent Actor is not affiliated with, endorsed by, or sponsored by X Corp.

# Actor input Schema

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

Enter up to 25 Tweet URLs or numeric Tweet IDs, one per line. Repeated Tweets are processed once. Example: https://x.com/elonmusk/status/2108952286030356925

## `collectRetweets` (type: `boolean`):

Collect the public users who Retweeted each input Tweet.

## `collectQuoteTweets` (type: `boolean`):

Collect Quote Tweet authors and include their public Quote Tweet text, URL, time, and available metrics.

## `collectReplies` (type: `boolean`):

Collect the public users who replied to each input Tweet.

## `includeThreadReplies` (type: `boolean`):

Keep this off to collect only direct replies to the input Tweet. Turn it on to also collect visible replies to other replies. This setting is ignored when reply collection is off.

## `maxUsersPerTypePerTweet` (type: `integer`):

The limit applies separately to every selected type and every input Tweet. For example, 100 can collect up to 100 Retweet users, 100 Quote Tweet authors, and 100 Reply authors from each Tweet. Set 0 to collect all records currently exposed by X; large Tweets can take much longer.

## `engagerMatch` (type: `string`):

Choose how a user must have engaged. Matching across input Tweets allows different actions on different Tweets; matching on one Tweet requires all selected actions on the same Tweet. At least 2 engagement types requires two or more collection switches above to be enabled.

## `minimumTweetsEngaged` (type: `integer`):

Only save users who engaged with at least this many different input Tweets. Multiple actions on the same Tweet count as one Tweet. Use 1 for all engagers or 2+ to find repeat engagers across your content. This value cannot be greater than the number of valid unique Tweets entered above.

## `minimumFollowers` (type: `integer`):

Only save accounts with at least this many followers. Keep 0 to include accounts of every audience size.

## `verification` (type: `string`):

Choose which account verification group to save. Any verified includes blue, business, government, and legacy verified accounts. Official / legacy verified uses X's native verification type or verified flag.

## Actor input object example

```json
{
  "tweets": [
    "https://x.com/callyculate/status/1933472068571705360"
  ],
  "collectRetweets": true,
  "collectQuoteTweets": true,
  "collectReplies": true,
  "includeThreadReplies": false,
  "maxUsersPerTypePerTweet": 100,
  "engagerMatch": "any",
  "minimumTweetsEngaged": 1,
  "minimumFollowers": 0,
  "verification": "any"
}
```

# Actor output Schema

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

Unique public users grouped with evidence for the selected Tweet engagement types.

# 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/callyculate/status/1933472068571705360"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-tweet-engagers").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/callyculate/status/1933472068571705360"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-tweet-engagers").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/callyculate/status/1933472068571705360"
  ]
}' |
apify call arjun_code/x-twitter-tweet-engagers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/x-twitter-tweet-engagers"
        }
    }
}
```

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/5fNISNwr60lBYtrwV/builds/FgLLOJzzF4fkHrrv0/openapi.json