# Twitter Retweet Checker (`maximedupre/twitter-retweet-checker`) Actor

Check whether Twitter/X users retweeted public posts. Paste tweet URLs or IDs plus usernames, then export true/false retweet checks for campaigns, giveaways, audits, and API workflows.

- **URL**: https://apify.com/maximedupre/twitter-retweet-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.32 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### 🔁 Twitter retweet checker for public X posts

Twitter Retweet Checker verifies whether specific [Twitter/X](https://x.com/) users retweeted specific public posts. Paste one or more tweet URLs or tweet IDs, add one or more usernames, and export a clean true/false retweet check for each completed tweet/user pair.

Use this Actor when you already know the post and the accounts you want to verify. It is useful for campaign checks, giveaway eligibility, creator reporting, social-proof audits, community ops, and API workflows where opening X manually for every username would be slow and hard to track.

For a small first run, keep the prefilled Apify tweet and username, leave **Retweet check limit** at `100`, and start the Actor. Once the output shape looks right, paste your own public post IDs, tweet URLs, and usernames.

### ✅ What this Actor does

- Checks whether Twitter/X usernames retweeted public posts.
- Accepts `x.com` URLs, `twitter.com` URLs, and raw numeric tweet IDs.
- Accepts usernames with or without `@`.
- Runs a matrix of submitted tweets and usernames, then saves one result per completed check.
- Exports `tweetId`, canonical `tweetUrl`, original inputs, normalized username, `hasRetweeted`, `checkedAt`, and `retweeterProfileUrl` when the user is found.
- Skips invalid tweet IDs, invalid usernames, and temporarily unavailable source checks without adding placeholder rows.
- Works through Apify runs, datasets, exports, API calls, schedules, webhooks, and integrations.

This Actor is focused on retweet verification for known public posts. It does not search Twitter/X, scrape replies, export every retweeter, check likes, inspect private accounts, or fetch protected/deleted/login-only posts.

### 📊 Data you can export

Each output row represents one completed retweet check for one tweet/user pair.

Core fields include:

- `tweetId` - numeric Twitter/X post ID.
- `tweetUrl` - canonical `https://x.com/i/status/{tweetId}` URL.
- `inputTweetUrl` - the tweet URL or ID you submitted.
- `username` - normalized username without `@`.
- `inputUsername` - the username value you submitted.
- `hasRetweeted` - `true` when the username is found in the post's retweeter list, otherwise `false`.
- `checkedAt` - UTC timestamp for the check.
- `retweeterProfileUrl` - profile URL when `hasRetweeted` is `true`, otherwise `null`.

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call the results through the Apify API, schedule repeated checks, or connect the Actor to webhooks and integrations.

### 🚀 How to run

1. Add one or more public Twitter/X tweet URLs or numeric tweet IDs in **Tweet URLs or IDs**.
2. Add one or more usernames in **Usernames**.
3. Keep **Retweet check limit** at `100` for a controlled first run.
4. Run the Actor.
5. Open the dataset and filter `hasRetweeted` to find confirmed retweets.

The Actor checks every valid tweet/user pair until it reaches the limit. For example, 2 tweet IDs and 10 usernames create up to 20 retweet checks.

### 🧾 Input example

```json
{
	"tweetUrls": ["https://x.com/apify/status/2021770553154285890"],
	"usernames": ["apify", "@example_user"],
	"maxChecks": 100
}
````

### 📄 Output example

```json
{
	"tweetId": "2021770553154285890",
	"tweetUrl": "https://x.com/i/status/2021770553154285890",
	"inputTweetUrl": "https://x.com/apify/status/2021770553154285890",
	"username": "apify",
	"inputUsername": "apify",
	"hasRetweeted": true,
	"checkedAt": "2026-06-02T15:03:16.604Z",
	"retweeterProfileUrl": "https://x.com/apify"
}
```

### 💸 Pricing

This Actor uses pay-per-event pricing. You are charged for each completed retweet check that is saved as a result.

Invalid tweet IDs, invalid usernames, and source checks that cannot be completed are skipped instead of being saved as result rows. Keep **Retweet check limit** small for your first run, then increase it when the output fits your workflow.

### ⚠️ Limits and caveats

Twitter/X can hide, remove, restrict, rate-limit, or change access to public post data. If a check cannot be completed after the Actor's source attempts, that pair is skipped and reported in the run logs.

The Actor only checks public retweet information for public posts. It does not bypass privacy controls, does not check protected accounts, and does not verify private or login-only interactions.

Negative results mean the username was not found in the retweeter data available to the Actor at run time. If a post has changed recently or a retweet is very new, rerun the check later.

### ❓ FAQ

#### 🔎 Can I check more than one username?

Yes. Add multiple usernames in **Usernames**. The Actor checks each valid username against each valid tweet until it reaches **Retweet check limit**.

#### 🔢 Can I use raw tweet IDs instead of URLs?

Yes. You can paste raw numeric tweet IDs, full `x.com` URLs, or full `twitter.com` URLs.

#### 🔐 Do I need to provide Twitter cookies or an API key?

No. The public input form does not ask for Twitter/X cookies, login details, or an API key.

#### 📤 Can I export the results through the API?

Yes. Results are saved in a normal Apify dataset, so you can export them from the run page, pull them through the Apify API, schedule runs, or connect webhooks and integrations.

#### 🧵 Does this export the full retweeter list?

No. This Actor answers whether submitted usernames retweeted submitted posts. Use a broader Twitter/X scraper if you need full reply, repost, or timeline collection.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~twitter-retweet-checker/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X posts and export post data.
- [Twitter Media Scraper ↗](https://apify.com/maximedupre/twitter-media-scraper) - Extract image, video, and GIF media URLs from public X posts.
- [Twitter Screenshot Generator ↗](https://apify.com/maximedupre/twitter-screenshot-generator) - Save clean screenshots of public X posts.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public profile stats across X and other social platforms.
- [Reddit Scraper ↗](https://apify.com/maximedupre/reddit-scraper) - Search Reddit posts and comments around a topic, brand, or campaign.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `tweetUrls` (type: `array`):

Enter one public X/Twitter post URL or numeric tweet ID per line, such as https://x.com/apify/status/2021770553154285890.

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

Enter one Twitter/X username per line. Both apify and @apify are accepted.

## `maxChecks` (type: `integer`):

Maximum number of tweet/user pairs to check. Keep the default for a small first run, or set 0 for no extra limit.

## Actor input object example

```json
{
  "tweetUrls": [
    "https://x.com/apify/status/2021770553154285890"
  ],
  "usernames": [
    "fra_dha",
    "Harry78652900",
    "xixi_gout",
    "apify",
    "Vanda161864444",
    "BruceImmo",
    "AsimAsis",
    "Volum3Vamp1re",
    "u33505987433194",
    "Doom64188245681",
    "wright_tim54132",
    "PortugaAlbert",
    "bjadams156",
    "TFPineapples",
    "sisiwatoto",
    "cdsmithoz8",
    "JacobTillery15",
    "Mastermark45",
    "barrak872396",
    "Barbados76",
    "angelogrisafi7",
    "StevenAlixe",
    "NolanHughie",
    "BrunoAl73780329",
    "pierre_cavalli"
  ],
  "maxChecks": 100
}
```

# Actor output Schema

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

Open the dataset to view exported retweet check results.

# 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 = {
    "tweetUrls": [
        "https://x.com/apify/status/2021770553154285890"
    ],
    "usernames": [
        "fra_dha",
        "Harry78652900",
        "xixi_gout",
        "apify",
        "Vanda161864444",
        "BruceImmo",
        "AsimAsis",
        "Volum3Vamp1re",
        "u33505987433194",
        "Doom64188245681",
        "wright_tim54132",
        "PortugaAlbert",
        "bjadams156",
        "TFPineapples",
        "sisiwatoto",
        "cdsmithoz8",
        "JacobTillery15",
        "Mastermark45",
        "barrak872396",
        "Barbados76",
        "angelogrisafi7",
        "StevenAlixe",
        "NolanHughie",
        "BrunoAl73780329",
        "pierre_cavalli"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/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 = {
    "tweetUrls": ["https://x.com/apify/status/2021770553154285890"],
    "usernames": [
        "fra_dha",
        "Harry78652900",
        "xixi_gout",
        "apify",
        "Vanda161864444",
        "BruceImmo",
        "AsimAsis",
        "Volum3Vamp1re",
        "u33505987433194",
        "Doom64188245681",
        "wright_tim54132",
        "PortugaAlbert",
        "bjadams156",
        "TFPineapples",
        "sisiwatoto",
        "cdsmithoz8",
        "JacobTillery15",
        "Mastermark45",
        "barrak872396",
        "Barbados76",
        "angelogrisafi7",
        "StevenAlixe",
        "NolanHughie",
        "BrunoAl73780329",
        "pierre_cavalli",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/twitter-retweet-checker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "tweetUrls": [
    "https://x.com/apify/status/2021770553154285890"
  ],
  "usernames": [
    "fra_dha",
    "Harry78652900",
    "xixi_gout",
    "apify",
    "Vanda161864444",
    "BruceImmo",
    "AsimAsis",
    "Volum3Vamp1re",
    "u33505987433194",
    "Doom64188245681",
    "wright_tim54132",
    "PortugaAlbert",
    "bjadams156",
    "TFPineapples",
    "sisiwatoto",
    "cdsmithoz8",
    "JacobTillery15",
    "Mastermark45",
    "barrak872396",
    "Barbados76",
    "angelogrisafi7",
    "StevenAlixe",
    "NolanHughie",
    "BrunoAl73780329",
    "pierre_cavalli"
  ]
}' |
apify call maximedupre/twitter-retweet-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/twitter-retweet-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Retweet Checker",
        "description": "Check whether Twitter/X users retweeted public posts. Paste tweet URLs or IDs plus usernames, then export true/false retweet checks for campaigns, giveaways, audits, and API workflows.",
        "version": "0.1",
        "x-build-id": "9RjE29qFPCkhOWrDR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~twitter-retweet-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-twitter-retweet-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~twitter-retweet-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-twitter-retweet-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~twitter-retweet-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-twitter-retweet-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "tweetUrls",
                    "usernames"
                ],
                "properties": {
                    "tweetUrls": {
                        "title": "Tweet URLs or IDs",
                        "minItems": 1,
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Enter one public X/Twitter post URL or numeric tweet ID per line, such as https://x.com/apify/status/2021770553154285890.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "minItems": 1,
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Enter one Twitter/X username per line. Both apify and @apify are accepted.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxChecks": {
                        "title": "Retweet check limit",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of tweet/user pairs to check. Keep the default for a small first run, or set 0 for no extra limit.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```