# X (Twitter) Retweet Checker — Bulk Account Check (`arjun_code/x-twitter-retweet-checker`) Actor

Bulk-check whether up to 1,000 X / Twitter accounts retweeted one public post. Get a clear result for every account plus profile details for matches—ideal for giveaways, campaigns, creator programs, and engagement audits. No login, cookies, API key, or proxy setup required.

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

## Pricing

from $0.25 / 1,000 completed retweet checks

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

## X (Twitter) Retweet Checker

Bulk-check whether up to 1,000 known X / Twitter accounts retweeted one public post. Paste a post URL or ID, add usernames, profile URLs, or user IDs, and receive one clear Dataset row for every unique account.

One shared retweeter scan checks the full account list, making the Actor practical for giveaway verification, campaign audits, creator programs, community research, and recurring engagement checks. Matches include available public profile data. No X login, cookies, API key, or proxy configuration is required.

### What can this X retweet checker do?

- Check up to 1,000 accounts against one public X post in a single run.
- Use one shared retweeter scan instead of starting a separate lookup for every account.
- Accept usernames, `@handles`, full profile URLs, numeric user IDs, or a mixture of formats.
- Return `retweeted: true`, `false`, or `null` instead of turning an incomplete scan into a false result.
- Include the matched user's bio, location, profile links, follower counts, verification status, and other available public profile fields.
- Export results as JSON, CSV, Excel, XML, RSS, or HTML.
- Run from Apify Console, API, Tasks, schedules, webhooks, Make, Zapier, or the Apify MCP Server.

### How to use

1. Paste one public X post URL or its numeric post ID.
2. Add the accounts you want to check, one per line.
3. Click **Start**.
4. Open the Dataset **Overview** and filter the `retweeted` column.

### Input

| Field | Required | Description |
| --- | --- | --- |
| `tweet` | Yes | One public `x.com` or `twitter.com` post URL, or a numeric post ID. |
| `accounts` | Yes | Up to 1,000 usernames, `@handles`, profile URLs, or numeric user IDs. Equivalent username formats are checked only once. |

```json
{
  "tweet": "https://x.com/aichan_nel/status/2109192284264595858",
  "accounts": [
    "gamesukimanIRS",
    "@elonmusk",
    "https://x.com/apify",
    "890011899705802753"
  ]
}
```

### Understand the result

Each Dataset row represents one requested account.

| Field value | Meaning |
| --- | --- |
| `retweeted: true` | The account was found in X's visible retweeter list. The `user` object contains its available public profile data. |
| `retweeted: false` | The available retweeter pages were checked completely and the account was not found. |
| `retweeted: null` | The check could not be completed, so the Actor does not report a misleading negative result. Read `status` and `message` for the reason. |

`check_complete` is `true` only when the result is conclusive. The `status` field distinguishes successful checks from invalid input, unavailable posts, partial scans, and request failures.

### Example result

```json
{
  "status": "success",
  "retweeted": true,
  "check_complete": true,
  "message": "The account appears in X's visible retweeter list.",
  "checked_at": "2026-10-11T14:42:35.090389Z",
  "tweet_requested": "https://x.com/aichan_nel/status/2109192284264595858",
  "tweet_id": "2109192284264595858",
  "tweet_url": "https://x.com/aichan_nel/status/2109192284264595858",
  "account_requested": "gamesukimanIRS",
  "account_input_type": "username",
  "normalized_account": "gamesukimanirs",
  "match_type": "username",
  "user": {
    "user_id": "890011899705802753",
    "username": "gamesukimanIRS",
    "name": "Айрис (Alqires) - IRS",
    "description": "Minecraftミリタリークラフター...",
    "location": "Tokyo, Twitter",
    "created_at": "2017-07-26T00:52:27Z",
    "profile_url": "https://x.com/gamesukimanIRS",
    "profile_image_url": "https://pbs.twimg.com/profile_images/1559402080225345537/T_n1NkHM_normal.jpg",
    "profile_banner_url": "https://pbs.twimg.com/profile_banners/890011899705802753/1690269445",
    "website_url": "http://www.gamesukimanirs.net",
    "followers_count": 1395,
    "following_count": 5889,
    "tweets_count": 249457,
    "media_count": 3098,
    "favourites_count": 864832,
    "verified": false,
    "is_blue_verified": false,
    "protected": false,
    "possibly_sensitive": false,
    "professional_type": "",
    "professional_categories": [],
    "affiliation_name": "",
    "account_label": null
  }
}
```

When `retweeted` is `false` or `null`, `user` is `null` because no matching retweeter profile was found.

### Export and automate retweet checks

Save a recurring account list as an **Apify Task** and attach a schedule to check campaign participation over time. Webhooks can notify another service after each run, while the Dataset can feed spreadsheets, dashboards, CRMs, or your own application.

Use the Actor through the Apify API:

```bash
curl -X POST \
  "https://api.apify.com/v2/actors/arjun_code~x-twitter-retweet-checker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tweet":"https://x.com/aichan_nel/status/2109192284264595858","accounts":["gamesukimanIRS","elonmusk"]}'
```

Connect it to AI clients through the Apify MCP Server:

```text
https://mcp.apify.com/?tools=arjun_code/x-twitter-retweet-checker
```

### Pricing

The Actor uses pay-per-event pricing with platform usage included. A `retweet-check-result` event is charged only when one requested account receives a conclusive `retweeted: true` or `retweeted: false` result. Invalid input, unavailable posts, incomplete scans, and request failures are not charged as completed checks.

| Apify plan | Per completed check | Per 1,000 completed checks |
| --- | ---: | ---: |
| Free | $0.00050 | $0.50 |
| Bronze | $0.00040 | $0.40 |
| Silver | $0.00030 | $0.30 |
| Gold | $0.00025 | $0.25 |
| Platinum | $0.00025 | $0.25 |
| Diamond | $0.00025 | $0.25 |

An `apify-actor-start` event costs $0.00150 per run. Use **Maximum cost per run** in Apify Run options when you need a spending limit. The **Pricing** tab is the source of truth if prices change later.

### Availability and limits

- One post can be checked per run.
- A run accepts up to 1,000 unique account references.
- Results reflect the public retweeter data visible from X at check time.
- Deleted, protected, restricted, or unavailable activity may not appear.
- A conclusive `false` means the account was not present in the available list; it does not prove the account never retweeted the post historically.

### Related X / Twitter Actors

| Actor | Best for |
| --- | --- |
| [X Retweeters & Quote Tweets Scraper](https://apify.com/arjun_code/x-twitter-retweeters-scraper) | Exporting the visible retweeter list or quote-post authors. |
| [X Media Downloader](https://apify.com/arjun_code/x-twitter-media-downloader) | Getting post details, images, videos, GIFs, and author data. |
| [X Replies Scraper](https://apify.com/arjun_code/x-twitter-replies-scraper) | Collecting visible replies and conversation context. |

### Frequently asked questions

#### Do I need X cookies or an API key?

No. The Actor manages the required access and proxy routing.

#### Can I check several posts in one run?

This Actor checks one post against many accounts. For multiple posts, create separate Tasks or call the Actor once per post through the API.

#### Why can `retweeted` be `null`?

`null` protects you from treating an interrupted or unavailable check as a confirmed negative. Use `status`, `check_complete`, and `message` to decide whether to retry.

#### Where can I report a problem?

Open an issue on the Actor page and include the Apify Run ID. Do not share cookies, tokens, or other credentials.

Use public data responsibly and follow applicable laws and platform terms. This independent Actor is not affiliated with, endorsed by, or sponsored by X Corp.

# Actor input Schema

## `tweet` (type: `string`):

For example: https://x.com/example/status/2109192284264595858 or 2109192284264595858.

## `accounts` (type: `array`):

Each value can be a username, @handle, full X / Twitter profile URL, or numeric user ID. Equivalent username formats are deduplicated.

## Actor input object example

```json
{
  "tweet": "https://x.com/aichan_nel/status/2109192284264595858",
  "accounts": [
    "gamesukimanIRS",
    "elonmusk"
  ]
}
```

# Actor output Schema

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

One result row per requested account in the default dataset.

# 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 = {
    "tweet": "https://x.com/aichan_nel/status/2109192284264595858",
    "accounts": [
        "gamesukimanIRS",
        "elonmusk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-retweet-checker").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 = {
    "tweet": "https://x.com/aichan_nel/status/2109192284264595858",
    "accounts": [
        "gamesukimanIRS",
        "elonmusk",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-retweet-checker").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 '{
  "tweet": "https://x.com/aichan_nel/status/2109192284264595858",
  "accounts": [
    "gamesukimanIRS",
    "elonmusk"
  ]
}' |
apify call arjun_code/x-twitter-retweet-checker --silent --output-dataset

```

## MCP server setup

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

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/ZFahbjQWtOFtapcgO/builds/lfkz5VDa3CorWMrN8/openapi.json