# X Twitter Replies Scraper - \[No Cookies] (`khadinakbar/x-twitter-replies-scraper`) Actor

Scrape public X/Twitter replies from tweet URLs or IDs with author profiles, metrics, media, language, and cursors. MCP optimized. $8.00/1K replies.

- **URL**: https://apify.com/khadinakbar/x-twitter-replies-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, AI
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 x/twitter reply scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## X Twitter Replies Scraper - No Cookies

X Twitter Replies Scraper - No Cookies is an Apify Actor for working with public replies on specific X/Twitter posts. It accepts tweet URLs or numeric tweet IDs, returns one dataset record per reply, and includes reply text, timestamps, language, conversation identifiers, author profile fields, engagement counts, media URLs, and provider metadata. The output is shaped for analytics, downstream enrichment, and AI-agent workflows through Apify, including Apify MCP.

### Best fit and connected workflows

This Actor fits workflows centered on a known tweet or set of tweets where the goal is to collect public reply data in a normalized table.

Common routes include:

- Reply monitoring for a brand, campaign, product launch, or announcement post
- Conversation analysis for public social listening and sentiment review
- Community and creator research around a specific post
- Support triage based on visible public responses
- AI-agent workflows that need structured reply records with author and engagement fields

If your workflow starts from a tweet URL or tweet ID and ends with reply-level data, this Actor gives you a focused path from input to dataset rows.

### Practical scenario

A community manager has a tweet URL from a product announcement and wants to review the public response before the next meeting. They enter the tweet URL, keep the default relevance ranking, and run the Actor.

The dataset returns fields such as `replyUrl`, `text`, `createdAt`, `authorUsername`, `authorName`, `authorFollowers`, `likeCount`, `retweetCount`, `replyCount`, `viewCount`, and `language`. The manager can then sort the replies, identify visible themes, and export the dataset for reporting or follow-up work.

### Input

The Actor accepts these input fields:

| Field | Type | Purpose | Notes |
|---|---:|---|---|
| `tweetUrls` | array | Tweet URLs or IDs to scrape | Required. Accepts full X/Twitter URLs or numeric tweet IDs. |
| `rankingMode` | string | Reply ordering | `Relevance`, `Recency`, or `Likes`. Defaults to `Relevance`. |
| `maxReplies` | integer | Total reply rows to save | Hard cap across all input tweets. Default `100`, max `5000`. |
| `maxPagesPerTweet` | integer | Pagination safety valve | Default `10`, max `100`. |
| `startCursor` | string | Continue from a previous run | Paste the cursor from `RUN_SUMMARY.nextCursors`. |
| `includeRaw` | boolean | Include raw provider payload | Useful for debugging field drift or custom parsing. |
| `dedupeReplies` | boolean | Skip duplicate replies | Default is enabled. |

Valid focused JSON example:

```json
{
  "tweetUrls": [
    "https://x.com/OpenAI/status/2065225362544726371"
  ],
  "rankingMode": "Relevance",
  "maxReplies": 100,
  "maxPagesPerTweet": 10,
  "startCursor": "",
  "includeRaw": false,
  "dedupeReplies": true
}
```

### Output

Each dataset item is one public reply record.

| Field | Type | Meaning |
|---|---:|---|
| `parentTweetId` | string | Tweet ID supplied as input. |
| `parentTweetUrl` | string | Canonical URL of the source tweet. |
| `rankingMode` | string | Ordering used for the run. |
| `position` | integer | 1-based row position after normalization and dedupe. |
| `replyId` | string | Reply status ID. |
| `replyUrl` | string | Canonical X/Twitter URL for the reply. |
| `text` | string | Full public reply text. |
| `createdAt` | string | Reply timestamp in ISO format. |
| `language` | string | Language code from X/Twitter. |
| `conversationId` | string | Conversation root ID. |
| `inReplyToTweetId` | string | Tweet ID this reply responds to. |
| `authorUsername` | string | Reply author's handle without `@`. |
| `authorName` | string | Reply author's display name. |
| `authorId` | string | Numeric author ID. |
| `authorUrl` | string | Canonical author profile URL. |
| `authorVerified` | boolean | Verification status when available. |
| `authorFollowers` | integer | Follower count. |
| `authorFollowing` | integer | Following count. |
| `authorBio` | string | Public bio text. |
| `authorProfileImageUrl` | string | Profile image URL. |
| `replyCount` | integer | Reply count on the reply post. |
| `retweetCount` | integer | Retweet count on the reply post. |
| `quoteCount` | integer | Quote count on the reply post. |
| `likeCount` | integer | Like count on the reply post. |
| `viewCount` | integer | View count on the reply post. |
| `bookmarkCount` | integer | Bookmark count on the reply post. |
| `hashtags` | array | Hashtags found in the reply. |
| `mentions` | array | Mentions found in the reply. |
| `urls` | array | URLs found in the reply. |
| `mediaUrls` | array | Media URLs found in the reply. |
| `source` | string | Posting client or app source when available. |
| `provider` | string | Provider used for the result. |
| `providerPage` | integer | Provider page number in the run. |
| `scrapedAt` | string | Time the record was emitted. |
| `raw` | object | Raw provider item when `includeRaw` is enabled. |

Illustrative dataset record:

```json
{
  "parentTweetId": "2065225362544726371",
  "parentTweetUrl": "https://x.com/OpenAI/status/2065225362544726371",
  "rankingMode": "Relevance",
  "position": 1,
  "replyId": "2065226000000000001",
  "replyUrl": "https://x.com/example/status/2065226000000000001",
  "text": "Great update, looking forward to trying this.",
  "createdAt": "2026-01-01T12:00:00.000Z",
  "language": "en",
  "conversationId": "2065225362544726371",
  "inReplyToTweetId": "2065225362544726371",
  "authorUsername": "example",
  "authorName": "Example User",
  "authorId": "123456789",
  "authorUrl": "https://x.com/example",
  "authorVerified": false,
  "authorFollowers": 1200,
  "authorFollowing": 340,
  "authorBio": "Public profile bio.",
  "authorProfileImageUrl": "https://pbs.twimg.com/profile_images/example.jpg",
  "replyCount": 0,
  "retweetCount": 0,
  "quoteCount": 0,
  "likeCount": 12,
  "viewCount": 340,
  "bookmarkCount": 1,
  "hashtags": [],
  "mentions": [],
  "urls": [],
  "mediaUrls": [],
  "source": "X for iPhone",
  "provider": "SociaVault",
  "providerPage": 1,
  "scrapedAt": "2026-01-01T12:00:05.000Z"
}
```

### How it works

This Actor uses provider-backed access for public X/Twitter replies and runs without cookies. The manifest indicates provider retries, cursor pagination, normalized dataset records, and telemetry written to `OUTPUT` and `RUN_SUMMARY`. The input schema supports multiple tweet URLs or IDs, ranking modes, pagination controls, a continuation cursor, raw payload output, and reply deduplication.

### Pricing

X Twitter Replies Scraper - No Cookies uses Pay per event plus Apify platform usage.

- One charge occurs when the Actor starts.
- Each saved public reply is billed as a separate event.

A simple example: if a run starts once and saves one hundred and twenty replies, the charge includes one start event plus one hundred and twenty reply events. For the current event details and platform usage information, see the live Pricing tab in Apify Console.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a structured reply-scraping tool. The exact Actor identity is `khadinakbar/x-twitter-replies-scraper`.

Use it when an agent needs:

- a tweet URL or tweet ID as the starting point,
- one record per public reply,
- author and engagement fields for reasoning or enrichment,
- dataset output that can be read back by downstream tools.

> Scrape public replies for this tweet URL, return the dataset rows, and summarize the reply authors, engagement counts, and any visible media URLs.

Output interpretation:

- `dataset` points to the reply records collection.
- `summary` and `runSummary` provide run-level status and cursor information.
- `provider` and `providerPage` show where each row came from.
- `scrapedAt` is the emission timestamp for the record.
- `raw` appears only when `includeRaw` is enabled.

Provenance and scope:

- Records come from public reply data exposed through the provider-backed X/Twitter reply endpoint.
- The dataset is normalized into one row per reply.
- `startCursor` continues a previous thread of pagination using the saved cursor value.

Pagination and cost guidance:

- `maxPagesPerTweet` helps set how deep the Actor can page within one conversation.
- `maxReplies` caps the total saved rows across all input tweets and acts as a billing and dataset cap.
- `dedupeReplies` keeps repeated reply rows out of the dataset unless you intentionally want overlap inspection.

### Apify API example

JavaScript example with `APIFY_TOKEN` and dataset readback:

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/x-twitter-replies-scraper').call({
  tweetUrls: ['https://x.com/OpenAI/status/2065225362544726371'],
  rankingMode: 'Relevance',
  maxReplies: 20,
  maxPagesPerTweet: 5,
  includeRaw: false,
  dedupeReplies: true,
});

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

### Best results and outcome guidance

For clearer datasets, start with a specific tweet URL or ID and keep the input set tightly scoped to the posts you want analyzed. Use `Relevance` for the default conversation ordering, `Recency` for newer replies first, and `Likes` when engagement ordering is the most useful view. Set `maxReplies` to match the number of rows you want saved, and raise `maxPagesPerTweet` only when you want deeper pagination within a single tweet conversation.

If you are continuing a prior run, reuse the saved cursor from `RUN_SUMMARY.nextCursors` for the same tweet and ranking mode. Keep `includeRaw` off for routine exports and enable it when you want provider payload visibility for parsing or debugging.

### Focused standalone workflow

X Twitter Replies Scraper - No Cookies is designed as a focused standalone workflow for the public input and structured output contract described above.

### Design note

I found that the output contract includes both `providerPage` and `scrapedAt` as required fields, which makes each record traceable to a specific page and emission time.

### FAQ

#### Can I use this Actor with a tweet URL or a numeric tweet ID?

Yes. The `tweetUrls` field accepts either full X/Twitter URLs or numeric tweet IDs.

#### Which reply ordering should I choose?

`Relevance` returns the default conversation ranking, `Recency` surfaces newer replies first, and `Likes` prioritizes liked replies.

#### How can I continue a run from a previous page?

Use `startCursor` with the exact cursor value saved in `RUN_SUMMARY.nextCursors`.

#### What appears in the dataset for each reply?

Each row includes reply identity, text, timestamps, author profile fields, engagement metrics, language, provider metadata, and optional raw provider data.

#### Is this Actor suitable for quote tweets or profile timelines?

This Actor is built for replies to specific tweets. Quote tweets, retweeters, keyword search, and profile timelines are outside this workflow.

### Responsible use

Use this Actor for public X/Twitter reply data only, and respect X/Twitter terms, applicable laws, and platform policies. Review and process public content responsibly, especially when handling user-generated text, profile data, or downstream AI analysis.

# Actor input Schema

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

Use this when you need public replies from specific X/Twitter posts. Enter full URLs like https://x.com/openai/status/1930000000000000000 or numeric tweet IDs. Defaults to one working public tweet example. This is not for keyword search or profile timelines.

## `rankingMode` (type: `string`):

Use this when choosing how X should order replies for each tweet. Relevance returns the default conversation ranking, Recency returns newer replies first, and Likes prioritizes liked replies. Defaults to Relevance. This does not scrape quote tweets or retweeters.

## `maxReplies` (type: `integer`):

Use this to cap the total reply rows saved across all input tweets. The actor stops before charging beyond this limit. Defaults to 100 and supports up to 5000. This is a hard billing and dataset cap, not a per-tweet target.

## `maxPagesPerTweet` (type: `integer`):

Use this as a pagination safety valve for each tweet conversation. Higher values collect deeper reply pages when the provider returns a next cursor. Defaults to 10 and supports up to 100. This does not override maxReplies.

## `startCursor` (type: `string`):

Use this when continuing one tweet from a previous RUN\_SUMMARY nextCursors value. Paste the cursor string exactly as returned by the actor. Leave blank for a fresh run. This is not a tweet URL or tweet ID field.

## `includeRaw` (type: `boolean`):

Use this for debugging provider field drift or building custom parsers. When enabled, each dataset row includes the raw SociaVault reply object. Defaults to false for smaller datasets. This is not needed for normal analytics exports.

## `dedupeReplies` (type: `boolean`):

Use this to skip duplicate reply tweets across pages and input tweets. The actor dedupes by reply ID first, then reply URL or text fallback. Defaults to true. Disable only when you need to inspect provider pagination overlap.

## Actor input object example

```json
{
  "tweetUrls": [
    "https://x.com/OpenAI/status/2065225362544726371"
  ],
  "rankingMode": "Relevance",
  "maxReplies": 1,
  "maxPagesPerTweet": 1,
  "includeRaw": false,
  "dedupeReplies": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# 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/OpenAI/status/2065225362544726371"
    ],
    "maxReplies": 1,
    "maxPagesPerTweet": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/x-twitter-replies-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 = {
    "tweetUrls": ["https://x.com/OpenAI/status/2065225362544726371"],
    "maxReplies": 1,
    "maxPagesPerTweet": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/x-twitter-replies-scraper").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/OpenAI/status/2065225362544726371"
  ],
  "maxReplies": 1,
  "maxPagesPerTweet": 1
}' |
apify call khadinakbar/x-twitter-replies-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HcEzBhLB9Aqdhbz5b/builds/yd8aeG5X2enXqmDHe/openapi.json