# X (Twitter) Reply Checker — Comment Verifier (`arjun_code/x-twitter-reply-checker`) Actor

Check whether specific X/Twitter accounts replied directly to a Tweet. Get a clear yes/no result for each account, plus the matching reply and public profile when found. Ideal for giveaways, campaigns, community verification, and support—no login, cookies, API key, or proxy setup.

- **URL**: https://apify.com/arjun_code/x-twitter-reply-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 $2.10 / 1,000 completed reply 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

Check whether specific X/Twitter accounts publicly replied directly to one Tweet. Paste a Tweet URL or ID, add up to 100 usernames, profile URLs, or user IDs, and receive a clear yes/no result for every unique account.

Use it to verify giveaway entries, campaign participation, community engagement, customer-support responses, and creator programs without manually searching a conversation. A positive result includes the matching reply and available public profile details. No X login, cookies, API key, or proxy configuration is required.

### What this Reply Checker does

- Check up to 100 accounts against one public Tweet.
- Accept usernames, `@handles`, profile URLs, numeric user IDs, or mixed formats.
- Return `replied: true`, `false`, or `null`, so an incomplete check is never presented as a negative result.
- Verify that a match belongs to the requested conversation and directly replies to the source Tweet.
- Include the matching reply text, time, URL, engagement metrics, and public author details.
- 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/Twitter Tweet URL or numeric Tweet ID.
2. Add up to 100 X accounts, one per line.
3. Click **Start**.
4. Open the Dataset **Overview** and check the `replied` column.

### Input

| Field | Required | Description |
| --- | --- | --- |
| `tweet` | Yes | One public `x.com` or `twitter.com` Tweet URL, or its numeric Tweet ID. Only direct replies to this Tweet count. |
| `accounts` | Yes | Up to 100 usernames, `@handles`, profile URLs, or numeric user IDs, one per line. Equivalent username formats are checked only once. |

```json
{
  "tweet": "https://x.com/callyculate/status/1933472068571705360",
  "accounts": [
    "ainunrozi",
    "@OpenAI",
    "https://x.com/apify"
  ]
}
```

### Understand the result

Each Dataset row represents one requested account.

| Value | Meaning |
| --- | --- |
| `replied: true` | A public direct reply from the account was found. `reply` and `user` contain the evidence. |
| `replied: false` | No public direct reply from the account was found in X search at check time. |
| `replied: null` | The check could not be completed. Read `status` and `message`; this is not reported as a false result. |

Only direct replies count. A reply elsewhere in the conversation, quote Tweet, mention, or repost does not produce `replied: true`.

### Example result

```json
{
  "status": "success",
  "replied": true,
  "message": "A public direct reply from this account was found.",
  "checked_at": "2026-10-14T08:31:20.432Z",
  "tweet_requested": "https://x.com/callyculate/status/1933472068571705360",
  "tweet_id": "1933472068571705360",
  "tweet_url": "https://x.com/callyculate/status/1933472068571705360",
  "account_requested": "ainunrozi",
  "account_input_type": "username",
  "normalized_username": "ainunrozi",
  "reply": {
    "tweet_id": "1933563436652507617",
    "tweet_url": "https://x.com/ainunrozi/status/1933563436652507617",
    "text": "trus dikasih jabatan, buset dah daya hancurnya",
    "created_at": "2025-06-13T16:33:41Z",
    "language": "in",
    "conversation_id": "1933472068571705360",
    "parent_tweet_id": "1933472068571705360",
    "is_direct_reply": true,
    "metrics": {
      "replies": 0,
      "retweets": 0,
      "quotes": 0,
      "likes": 19,
      "views": 3241
    }
  },
  "user": {
    "user_id": "183585238",
    "username": "ainunrozi",
    "name": "Ponakan Malaikat Izrail",
    "profile_url": "https://x.com/ainunrozi",
    "description": "dm 📩 || fast resp: ainunrozymphony@gmail.com ||",
    "location": "Alaska",
    "created_at": "2010-08-27T11:05:36Z",
    "followers_count": 799763,
    "following_count": 954,
    "tweets_count": 293242,
    "verified": false,
    "blue_verified": true,
    "protected": false,
    "profile_image_url": "https://pbs.twimg.com/profile_images/1368096560521748486/xg06W3LF_normal.jpg"
  }
}
```

For a conclusive negative result, `replied` is `false` and both `reply` and `user` are `null`.

### Automate reply verification

Save a recurring account list as an **Apify Task**, attach a schedule, or trigger the Actor from your application. Dataset rows can feed spreadsheets, CRMs, dashboards, campaign systems, or webhook workflows.

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

Connect AI clients through the Apify MCP Server:

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

### Pricing

The Actor uses pay-per-event pricing with platform usage included. A `reply-check-result` event is charged only for a completed `replied: true` or `replied: false` result. Invalid input, unavailable Tweets, unavailable user IDs, and failed checks are not charged as completed checks.

| Apify plan | Per completed check | Per 1,000 completed checks |
| --- | ---: | ---: |
| Free | $0.0030 | $3.00 |
| Bronze | $0.0027 | $2.70 |
| Silver | $0.0024 | $2.40 |
| Gold | $0.0021 | $2.10 |
| Platinum | $0.0021 | $2.10 |
| Diamond | $0.0021 | $2.10 |

An `apify-actor-start` event costs $0.0002 per run. On the Free tier, checking 100 accounts costs approximately **$0.3002** when all checks complete. Invalid input, unavailable Tweets, unavailable user IDs, and failed checks do not create a completed-check charge. Use **Maximum cost per run** in Apify Run options when you need a fixed spending limit. The Actor's **Pricing** tab is the source of truth if prices change later.

### Availability and limits

- One Tweet and up to 100 unique accounts can be checked per run.
- Results reflect replies publicly visible through X search at check time.
- Deleted, protected, restricted, withheld, or unindexed replies may not appear.
- A negative result means no public direct reply was found; it does not prove that an unavailable or deleted reply never existed.
- Numeric user IDs are resolved to their current username before checking.

### Related X / Twitter Actors

| Actor | Best for |
| --- | --- |
| [X Replies Scraper](https://apify.com/arjun_code/x-twitter-replies-scraper) | Exporting visible replies and conversation context. |
| [X Tweet Engagers](https://apify.com/arjun_code/x-twitter-tweet-engagers) | Combining retweeters, quote authors, and reply authors across Tweets. |
| [X Retweet Checker](https://apify.com/arjun_code/x-twitter-retweet-checker) | Checking whether known accounts retweeted one Tweet. |

### Frequently asked questions

#### Does a reply to another comment count?

No. This Actor verifies direct replies to the source Tweet. Replies deeper in the thread do not count.

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

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

#### Why can `replied` be `null`?

`null` prevents an unavailable Tweet, invalid user ID, or interrupted request from becoming a misleading negative result.

#### 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`):

Paste one public X/Twitter Tweet URL or numeric Tweet ID. Only direct replies to this Tweet count. Example: https://x.com/callyculate/status/1933472068571705360

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

Enter one account per line as a username, @handle, full X/Twitter profile URL, or numeric user ID. Each unique account receives its own result.

## Actor input object example

```json
{
  "tweet": "https://x.com/callyculate/status/1933472068571705360",
  "accounts": [
    "ainunrozi",
    "OpenAI"
  ]
}
```

# 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/callyculate/status/1933472068571705360",
    "accounts": [
        "ainunrozi",
        "OpenAI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-reply-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/callyculate/status/1933472068571705360",
    "accounts": [
        "ainunrozi",
        "OpenAI",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-reply-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/callyculate/status/1933472068571705360",
  "accounts": [
    "ainunrozi",
    "OpenAI"
  ]
}' |
apify call arjun_code/x-twitter-reply-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-reply-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/e1v7n9grgfboKgv0Y/builds/qhSiuV2Nw0PWbYnFd/openapi.json