# X (Twitter) Reply Scraper | $0.15/1K Replies | Pay-Per Result (`xquik/x-reply-scraper`) Actor

Scrape X (Twitter) replies, comments, conversations & profile reply timelines for $0.15 per 1,000 rows on paid Apify plans. Bulk URLs or IDs. Nested replies. Filters run before billing. No start fee. No query fee. No X login. Built by Xquik. Not affiliated with X Corp.

- **URL**: https://apify.com/xquik/x-reply-scraper.md
- **Developed by:** [Xquik](https://apify.com/xquik) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.00015 / replies

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 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

Scrape X (Twitter) replies for **$0.15 per 1,000 delivered rows on paid Apify
plans**. Paste post URLs, Tweet IDs, profile URLs, or usernames. Export direct
replies, nested conversations, authors, engagement, entities, and media URLs. No
X login, cookies, proxy, or API key is required. Apify's pricing box remains
authoritative before each run. Built by [Xquik](https://xquik.com).

Filters run before dataset writes. You pay only for delivered rows.

> Xquik is an independent third-party service. Not affiliated with X Corp.
> "Twitter" and "X" are trademarks of X Corp.

### What Does This Twitter Reply Scraper Do?

X Reply Scraper collects public replies and comment conversations. It handles
single posts, bulk URL lists, Tweet IDs, and user reply timelines.

Use it for sentiment analysis, customer feedback, community research, reply
ranking, lead discovery, moderation review, and conversation datasets.

#### Competitive Reply Scraper Features

- **Automatic completeness fallback** detects incomplete reply pages. It then
  uses conversation search.
- **4 collection strategies** support auto, direct replies, conversation search,
  and full thread context.
- **Direct and nested replies** preserve parent IDs, root IDs, and depth.
- **Bulk inputs** accept mixed post URLs, Tweet IDs, profiles, and usernames.
- **Profile reply timelines** collect public posts from With Replies tabs.
- **4 sort modes** preserve relevance or sort latest, oldest, or most liked.
- **25+ filters** cover text, author, language, engagement, media, and dates.
- **Filter before billing** removes unwanted rows before dataset writes.
- **3 detail levels** provide compact, full, or raw source snapshots.
- **CSV-friendly output** flattens author fields and media URL arrays.
- **Field naming controls** preserve source, camelCase, or snake\_case names.
- **Source attribution** links every result to its input target.
- **Continuation cursors** support controlled backfills and scheduled runs.
- **Spend-safe diagnostics** write exactly 1 actionable row for empty runs.
- **Agent-ready schemas** describe inputs, replies, reports, and cursors.
- **No credentials required** avoids X passwords, cookies, and session tokens.

### Quick Start

The initial form targets a verified public conversation. It returns up to 25
full, flat rows across at most 10 pages. Auto mode recovers from empty direct
reply results. All reply depths, deduplication, and source attribution stay on.

#### Scrape Replies From a Post URL

```json
{
  "startUrls": [{ "url": "https://x.com/OpenAI/status/2082577277246972300" }],
  "maxItems": 100
}
```

#### Scrape Replies From Tweet IDs

```json
{
  "tweetIds": ["2082577277246972300", "2083148725367783580"],
  "maxItemsPerTarget": 100,
  "maxItems": 200
}
```

#### Collect the Full Nested Conversation

```json
{
  "tweetIds": ["2082577277246972300"],
  "collectionStrategy": "conversationSearch",
  "scope": "all",
  "maxDepth": 5,
  "sort": "oldest",
  "maxItems": 500
}
```

#### Scrape a User's Reply Timeline

```json
{ "usernames": ["OpenAI", "apify"], "maxItemsPerTarget": 100, "maxItems": 200 }
```

#### Filter Replies Before Billing

```json
{
  "tweetIds": ["2082577277246972300"],
  "anyWords": ["API", "agent", "developer"],
  "excludeWords": ["airdrop", "giveaway"],
  "lang": "en",
  "minLikes": 2,
  "minViews": 100,
  "verifiedOnly": true,
  "maxItems": 200
}
```

#### Export Flat CSV-Friendly Rows

```json
{
  "tweetIds": ["2082577277246972300"],
  "outputMode": "full",
  "outputPreset": "flat",
  "fieldStyle": "camelCase",
  "maxItems": 100
}
```

Sample values are illustrative. Responses reflect source data at run time.

### AI Agent & MCP Readiness

Run this Actor through Apify MCP, API clients, x402, or Skyfire.

- Limited permissions protect unrelated Apify account data.
- Pay-per-event billing supports deterministic result-based costs.
- Standby mode stays disabled for agentic-payment compatibility.
- Typed schemas expose replies, run reports, and continuation cursors.
- Bounded defaults prevent accidental unbounded agent runs.
- Stable `camelCase` and `snake_case` modes simplify tool chaining.
- Diagnostic rows include a status, message, and recovery action.
- Run reports include exact outcomes, stop reasons, and charge estimates.

Use this bounded input for autonomous workflows:

```json
{
  "tweetIds": ["2082577277246972300"],
  "collectionStrategy": "auto",
  "scope": "all",
  "outputMode": "compact",
  "fieldStyle": "camelCase",
  "maxItems": 100
}
```

Agents should process outputs in this order:

1. Read `replies` from the default dataset.
2. Check `resultType` before using a row as reply data.
3. Follow `nextAction` when a diagnostic row appears.
4. Inspect `runReport.results.completionReason` after every run.
5. Reuse `continuationCursors` for intentionally page-limited runs.

Set `maxItems` on every autonomous call. Also set Apify's maximum run cost. The
smaller limit controls the billed result count.

This design satisfies Apify's technical eligibility requirements for agentic
payments. Apify controls final `allowsAgenticUsers` availability.

### Reply Targets & Input Aliases

Use the primary fields below.

| Input         | Purpose                                      |
| ------------- | -------------------------------------------- |
| `startUrls`   | Mixed X post and profile URLs                |
| `tweetIds`    | Numeric post IDs                             |
| `usernames`   | Public profile reply timelines               |
| `profileUrls` | Profile URL alias                            |
| `tweetUrls`   | Tweet URL alias                              |
| `postUrls`    | Post URL alias                               |
| `screenname`  | Single username alias                        |
| `startCursor` | Resume one target from a saved source cursor |

Compatibility aliases accept common competitor inputs:

- URL aliases: `urls`, `tweetUrls`, `postUrls`, `profileUrls`
- ID aliases: `conversationIds`, `postIds`, `ids`, `tweetId`, `id`
- Username aliases: `twitterHandles`, `screenname`
- Global limit aliases: `maxResults`, `max_results`, `resultsLimit`,
  `maxReplies`
- Per-target aliases: `maxRepliesPerTweet`, `maxCommentsPerPost`
- Search alias: `useSearch`
- Nested reply aliases: `includeNestedReplies`, `includeRepliesOfReplies`
- Original post alias: `includeOriginalTweet`
- Output aliases: `outputVariant`, `includeRaw`

Malformed or unsupported targets do not fail the Actor. The run returns an
actionable diagnostic when no valid targets remain.

### Coverage Strategies

#### Auto Complete

Use `collectionStrategy: "auto"` for most jobs. The Actor starts with the direct
reply route. If X reports incomplete coverage, it switches to `conversation_id`
search.

Filtered auto runs use conversation search immediately. This avoids incomplete
direct pages when filters hide source rows.

#### Direct Reply Endpoint

Use `collectionStrategy: "replies"` to force X's reply timeline. This keeps the
source ordering and supports cursors.

#### Conversation Search

Use `collectionStrategy: "conversationSearch"` for broad conversation coverage.
The Actor searches by `conversation_id:<Tweet ID>`.

#### Full Thread Context

Use `collectionStrategy: "thread"` to read the source conversation context. Set
`includeOriginalPost: true` to keep the root post as depth 0.

### Direct & Nested Reply Controls

Use `scope` to choose the result shape.

| Value    | Result                                       |
| -------- | -------------------------------------------- |
| `direct` | Keep depth 1 replies                         |
| `nested` | Keep replies to replies at depth 2+          |
| `all`    | Keep every available direct and nested reply |

Use `maxDepth` to bound nesting. Parent links may be absent when X omits a
conversation ancestor. The Actor preserves the best available depth.

### Sorting

Use `sort` with these values:

- `relevance` preserves X source order
- `latest` sorts newest first
- `oldest` sorts oldest first
- `likes` sorts highest like count first

The `sortBy` and `queryType` compatibility aliases remain supported.

### Reply Filters

All supported filters run before dataset writes.

#### Text & Entity Filters

| Input            | Behavior                          |
| ---------------- | --------------------------------- |
| `exactPhrase`    | Require one exact phrase          |
| `anyWords`       | Require at least 1 word or phrase |
| `excludeWords`   | Remove matching words or phrases  |
| `keywordInclude` | Alias merged with `anyWords`      |
| `keywordExclude` | Alias merged with `excludeWords`  |
| `hashtags`       | Require at least 1 hashtag        |
| `cashtags`       | Require at least 1 cashtag        |
| `mentioning`     | Require an @mention               |

#### Author & Language Filters

| Input                   | Behavior                               |
| ----------------------- | -------------------------------------- |
| `fromUser`              | Keep one reply author                  |
| `toUser`                | Keep replies addressed to one username |
| `lang`                  | Keep one X language code               |
| `verifiedOnly`          | Require any public verification signal |
| `blueVerifiedOnly`      | Require X Premium verification         |
| `excludeOriginalAuthor` | Remove source-author self-replies      |

#### Engagement Filters

Use `minLikes`, `minReplies`, `minRetweets`, `minQuotes`, `minViews`, and
`minBookmarks`. The `minFaves` alias maps to `minLikes`.

#### Media & Time Filters

- Set `hasMediaOnly: true` for replies with public media.
- Set `mediaType` to `any`, `image`, `video`, `gif`, or `link`.
- Set `since` for an inclusive start timestamp.
- Set `until` for an exclusive end timestamp.
- Use `sinceTime` and `untilTime` as compatibility aliases.

### Limits, Billing & Continuation

`maxItems` limits delivered rows across the run. `maxItemsPerTarget` limits each
post or profile. `maxPagesPerTarget` bounds source pagination.

The Actor removes duplicates before billing. Set `dedupeAcrossTargets: false` to
preserve duplicate rows from different targets.

After a page-limited run, read `next-cursors` from the default key-value store.
Pass one cursor through `startCursor` to continue that target.

### Output Fields

Every full reply row can include these core fields:

| Field               | Description                            |
| ------------------- | -------------------------------------- |
| `id`                | Reply ID                               |
| `text`              | Reply text                             |
| `fullText`          | Long-form reply text                   |
| `createdAt`         | Reply timestamp                        |
| `lang`              | X language code                        |
| `url`               | Direct reply URL                       |
| `conversationId`    | X conversation ID                      |
| `inReplyToId`       | Immediate parent ID                    |
| `inReplyToUserId`   | Parent author ID                       |
| `inReplyToUsername` | Parent username                        |
| `likeCount`         | Likes                                  |
| `replyCount`        | Child replies                          |
| `retweetCount`      | Reposts                                |
| `quoteCount`        | Quotes                                 |
| `viewCount`         | Views                                  |
| `bookmarkCount`     | Bookmarks                              |
| `author`            | Available public author metadata       |
| `media`             | Images, videos, GIFs, and variants     |
| `entities`          | Hashtags, cashtags, mentions, and URLs |
| `quoted_tweet`      | Quoted post when available             |
| `retweeted_tweet`   | Reposted post when available           |

Full rows also preserve available source metadata. This includes `isNoteTweet`,
`isReply`, `isLimitedReply`, `isQuoteStatus`, `source`, `type`,
`displayTextRange`, `contentDisclosure`, `article`, `bookmarked`, `card`,
`communityNote`, `edit`, `favorited`, `grokAnalysisButton`, `grokImageEditable`,
`isTranslatable`, `noteTweet`, `place`, `possiblySensitive`,
`possiblySensitiveEditable`, `previousCounts`, `quickPromoteEligibility`,
`retweeted`, and `viewState`.

Conversation fields make flat rows reconstructable:

- `rootTweetId`
- `parentReplyId`
- `depth`
- `isDirectReply`
- `isOriginalPost`
- `sourceTweetId`
- `sourceTarget`
- `sourceUrl`
- `resultType`
- `schemaVersion`
- `_schema_version`

#### Author Metadata

The nested `author` object preserves available public fields. These can include
`id`, `username`, `name`, `description`, `followers`, `following`, `verified`,
`isBlueVerified`, `isVerified`, `verifiedType`, `location`, `url`, `createdAt`,
`profilePicture`, `coverPicture`, `profileBannerUrl`, `statusesCount`,
`mediaCount`, `favouritesCount`, `protected`, `canDm`, `hasCustomTimelines`,
`isTranslator`, `withheldInCountries`, `possiblySensitive`, `pinnedTweetIds`,
`isAutomated`, `automatedBy`, `unavailable`, `unavailableReason`,
`affiliatesHighlightedLabel`, `businessAccountAffiliatesCount`, `canMediaTag`,
`creatorSubscriptionsCount`, `followRequestSent`, `hasGraduatedAccess`,
`hasHiddenSubscriptionsOnProfile`, `highlightsInfo`, `identityVerification`,
`isProfileTranslatable`, `notificationsEnabled`, `parodyCommentaryFanLabel`,
`profileDescriptionLanguage`, `profileImageShape`, `profileInterstitialType`,
`profileSortEnabled`, `profileTranslatorType`, `superFollowEligible`,
`superFollowedBy`, `superFollowing`, `communityRole`, `viewerFollowedBy`,
`viewerFollowing`, `viewerBlockedBy`, `viewerBlocking`, `viewerLiveFollowing`,
`viewerMuting`, and `profile_bio`.

Flat output adds `authorId`, `authorUsername`, `authorName`, `authorFollowers`,
`authorFollowing`, and `authorVerified`.

#### Media Metadata

Media objects can include `id`, `type`, `mediaUrl`, `url`, `displayUrl`,
`expandedUrl`, `altText`, `width`, `height`, `durationMillis`, `sizes`,
`videoVariants`, `aspectRatio`, `mediaKey`, `allowDownload`,
`availabilityStatus`, `faceRects`, `focusRects`, `indices`, `monetizable`, and
availability fields.

Flat output adds `mediaUrls`.

### Output Modes

#### Compact

Set `outputMode: "compact"` for analysis-ready fields. This reduces dataset
width while preserving text, conversation, author, engagement, and media.

#### Full

Set `outputMode: "full"` to preserve every supported public field.

#### Raw

Set `outputMode: "raw"` to add a sanitized source snapshot under `raw`.

#### Nested or Flat

The default `flat` layout keeps nested objects and adds table-ready author
fields. Set `outputPreset: "nested"` to omit the added flat fields.

#### Field Naming

Set `fieldStyle` to `source`, `camelCase`, or `snake_case`. The Actor avoids
overwriting colliding source keys.

### Diagnostic Rows

Every started run writes at least 1 default dataset row unless its charge limit
blocks all rows.

Successful data rows use `resultType: "reply"`. Non-data exits write exactly 1
row with `resultType: "diagnostic"` and an actionable fix.

Every outcome writes `run-report`, including no-input and invalid-input exits.

Possible statuses include:

- `no-input`
- `invalid-input`
- `replies-incomplete`
- `zero-output`
- `aborted`
- `unexpected-error`

Filter diagnostics with:

```javascript
const replies = dataset.filter((row) => row.resultType !== 'diagnostic');
```

### How Much Does It Cost?

On paid Apify plans, Xquik's intended listing price is
**$0.15 per 1,000
delivered rows**. This equals `$0.00015` per row. The live
Apify pricing box is authoritative before every run.

The free plan can use a separate anti-abuse tier. Check the live pricing box for
your plan. Do not use free-tier anti-abuse pricing for paid-plan cost
comparisons.

Xquik charges only default dataset rows. No separate start, URL, query,
pagination, filter, or proxy fee applies.

Each data row and the single possible diagnostic row is billable. The run report
separates delivered rows from the estimated row charge.

Apify platform usage follows the pricing box shown for your account.

### Public Task Examples

Choose from 50 public tasks with bounded inputs and useful dataset views. Each
task stays editable before you run it.

Examples cover:

- reply sentiment datasets
- customer feedback collection
- nested thread reconstruction
- most-liked reply ranking
- launch and event reaction research
- verified-author reply discovery
- media reply collection
- multilingual conversation research
- public profile reply timelines
- CSV and RAG exports
- continuation cursor workflows

Agent-focused examples include:

- [Collect replies for AI agents](https://apify.com/xquik/x-reply-scraper/examples/collect-replies-for-ai-agents)
- [Build an X reply RAG dataset](https://apify.com/xquik/x-reply-scraper/examples/build-x-reply-rag-dataset)
- [Archive replies for LLM processing](https://apify.com/xquik/x-reply-scraper/examples/archive-replies-for-llm-processing)
- [Extract reply leads for CRM](https://apify.com/xquik/x-reply-scraper/examples/extract-reply-leads-for-crm)

### API Example

#### JavaScript

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

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });
const run = await client
  .actor('xquik/x-reply-scraper')
  .call({
    tweetIds: ['2082577277246972300'],
    collectionStrategy: 'auto',
    scope: 'all',
    maxItems: 100,
  });

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")
run = client.actor("xquik/x-reply-scraper").call(run_input={
    "tweetIds": ["2082577277246972300"],
    "collectionStrategy": "auto",
    "scope": "all",
    "maxItems": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/xquik~x-reply-scraper/run-sync-get-dataset-items" \
  -X POST \
  -H "Authorization: Bearer <APIFY_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"tweetIds":["2082577277246972300"],"maxItems":100}'
```

### Automation & Integrations

Run the Actor through Apify schedules, webhooks, API clients, Make, Zapier, n8n,
Google Sheets, cloud storage, or the
[Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

Eligible agent workflows can also use
[x402](https://docs.apify.com/integrations/x402) or
[Skyfire](https://docs.apify.com/integrations/skyfire).

Xquik also provides 47 dashboard tools and 128 REST operations. This Actor
remains a focused reply collection surface.

### Responsible Use

Collect only public data. Follow applicable laws and platform rules.

Reply datasets can contain personal data. Choose a lawful purpose. Minimize
retention. Protect exports. Honor deletion and access requests where required.

The Actor does not bypass protected accounts. It does not request customer X
passwords, session cookies, or authentication tokens.

### FAQ

#### Do I Need an X Login or API Key?

No. Do not paste X credentials into Actor input.

#### Can It Scrape Nested Replies?

Yes. Set `scope: "all"` or `scope: "nested"`. Use `maxDepth` to bound depth.

#### Why Did Auto Mode Switch to Search?

X can report an incomplete direct reply page. Auto mode then uses conversation
search.

#### Can I Scrape a User's Replies?

Yes. Pass `usernames`, `twitterHandles`, `screenname`, or profile URLs.

#### Can I Sort by Likes or Date?

Yes. Use `likes`, `latest`, `oldest`, or `relevance`.

#### Can I Exclude Spam Before Billing?

Yes. Use `excludeWords`, author filters, engagement limits, and media filters.

#### Can I Resume a Large Conversation?

Yes. Read `next-cursors`, then pass one cursor through `startCursor`.

#### Does It Download Media Files?

No. It returns public media URLs and metadata. This controls storage costs.

#### Does It Run Custom JavaScript From Input?

No. The Actor does not execute untrusted mapping code.

#### What Happens When No Reply Matches?

The Actor writes exactly 1 diagnostic row with a suggested fix.

#### Which Export Formats Work?

Use Apify's JSON, JSONL, CSV, Excel, XML, RSS, or HTML exports.

#### Where Can I Report an Issue?

Use the Actor Issues tab. Include the public target, input, and run ID. Never
include passwords, tokens, cookies, or private data.

# Actor input Schema

## `startUrls` (type: `array`):

Public x.com or twitter.com post and profile URLs. Mix both in one run. Strings and {"url":"..."} objects are accepted.

## `tweetIds` (type: `array`):

Numeric Tweet IDs. Each ID becomes a reply-conversation target.

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

X usernames with or without @. Returns reply posts from each public With Replies timeline.

## `collectionStrategy` (type: `string`):

auto uses the direct reply endpoint and switches to conversation search when X reports incomplete replies. conversationSearch favors broad conversation coverage. replies forces the direct reply endpoint. thread reads the full conversation context.

## `scope` (type: `string`):

direct keeps replies to the source post. nested keeps replies to replies. all keeps every available conversation reply.

## `maxDepth` (type: `integer`):

Maximum parent-child depth from the source post. 1 keeps direct replies. Leave empty for every available depth.

## `sort` (type: `string`):

Keep X relevance order, or sort the collected result by latest, oldest, or most liked.

## `includeOriginalPost` (type: `boolean`):

Add the source post as depth 0 when available.

## `maxItems` (type: `integer`):

Global reply-row limit across every target. Agents should set this explicitly. Leave empty to use the Apify maximum-charge limit when set. Otherwise, the Actor uses 200.

## `maxItemsPerTarget` (type: `integer`):

Optional delivered-row cap for each post or profile target.

## `maxPagesPerTarget` (type: `integer`):

Safety cap for source pagination. Continuation cursors remain available in the key-value store.

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

Resume one target from a prior X pagination cursor. For multi-target runs, use separate runs per saved cursor.

## `dedupeAcrossTargets` (type: `boolean`):

Write the first occurrence when the same reply appears under multiple targets.

## `exactPhrase` (type: `string`):

Keep replies containing this exact phrase. Case-insensitive.

## `anyWords` (type: `array`):

Keep replies containing at least 1 listed word or phrase.

## `excludeWords` (type: `array`):

Remove replies containing any listed word or phrase.

## `hashtags` (type: `array`):

Keep replies containing at least 1 listed hashtag. Values may include #.

## `cashtags` (type: `array`):

Keep replies containing at least 1 listed cashtag. Values may include $.

## `fromUser` (type: `string`):

Keep replies written by this username.

## `toUser` (type: `string`):

Keep replies whose reply target is this username.

## `mentioning` (type: `string`):

Keep replies mentioning this username.

## `lang` (type: `string`):

Keep an X language code such as en, es, tr, de, or ja.

## `excludeOriginalAuthor` (type: `boolean`):

Remove self-replies from the source-post author when author data is available.

## `verifiedOnly` (type: `boolean`):

Keep replies from accounts with any public verification signal.

## `blueVerifiedOnly` (type: `boolean`):

Keep replies from X Premium or Blue verified accounts.

## `minLikes` (type: `integer`):

Minimum like count per delivered reply.

## `minReplies` (type: `integer`):

Minimum reply count on each delivered reply.

## `minRetweets` (type: `integer`):

Minimum repost count per delivered reply.

## `minQuotes` (type: `integer`):

Minimum quote count per delivered reply.

## `minViews` (type: `integer`):

Minimum view count per delivered reply.

## `minBookmarks` (type: `integer`):

Minimum bookmark count per delivered reply.

## `hasMediaOnly` (type: `boolean`):

Keep replies with an image, video, or GIF attachment.

## `mediaType` (type: `string`):

Keep replies containing any media, an image, video, GIF, or link.

## `since` (type: `string`):

Inclusive date or timestamp, such as 2026-07-01 or an ISO 8601 timestamp.

## `until` (type: `string`):

Exclusive date or timestamp, such as 2026-08-01 or an ISO 8601 timestamp.

## `outputMode` (type: `string`):

compact keeps analysis-ready fields. full preserves every supported public reply field. raw also adds the sanitized source row.

## `outputPreset` (type: `string`):

nested preserves author and media objects. flat adds top-level author fields and media URL arrays for CSV and spreadsheets.

## `fieldStyle` (type: `string`):

Preserve source names or normalize nested output to camelCase or snake\_case.

## `includeTargetMetadata` (type: `boolean`):

Add sourceTweetId, sourceTarget, and sourceUrl fields to every delivered row.

## `urls` (type: `array`):

Alias for Start URLs. Accepts URL strings or {"url":"..."} objects.

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

Tweet or post URL alias.

## `postUrls` (type: `array`):

Post URL alias.

## `profileUrls` (type: `array`):

Profile URL alias for public With Replies timelines.

## `conversationIds` (type: `array`):

Alias for Tweet IDs.

## `postIds` (type: `array`):

Alias for Tweet IDs.

## `ids` (type: `array`):

Alias for Tweet IDs.

## `tweetId` (type: `string`):

Single Tweet ID alias.

## `id` (type: `string`):

Single Tweet ID alias.

## `twitterHandles` (type: `array`):

Alias for Usernames.

## `screenname` (type: `string`):

Single profile-reply username alias.

## `useSearch` (type: `boolean`):

Compatibility alias. true selects conversationSearch.

## `includeNestedReplies` (type: `boolean`):

Compatibility alias for Reply Scope. Explicit Reply Scope takes precedence.

## `includeRepliesOfReplies` (type: `boolean`):

Compatibility alias for Reply Scope. Explicit Reply Scope takes precedence.

## `maxResults` (type: `integer`):

Alias for Maximum Delivered Rows.

## `max_results` (type: `integer`):

Alias for Maximum Delivered Rows.

## `resultsLimit` (type: `integer`):

Alias for Maximum Delivered Rows.

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

Alias for Maximum Delivered Rows.

## `maxRepliesPerTweet` (type: `integer`):

Alias for Maximum Rows per Target.

## `maxCommentsPerPost` (type: `integer`):

Compatibility alias for Maximum Rows per Target.

## `queryType` (type: `string`):

Compatibility alias. Latest selects latest. Likes selects most liked. Other values keep relevance.

## `sortBy` (type: `string`):

Alias for Sort Replies.

## `includeOriginalTweet` (type: `boolean`):

Alias for Include Original Post.

## `keywordInclude` (type: `array`):

Alias merged with Any Included Words.

## `keywordExclude` (type: `array`):

Alias merged with Excluded Words.

## `language` (type: `string`):

Alias for Reply Language.

## `minFaves` (type: `integer`):

Alias for Minimum Likes.

## `sinceTime` (type: `string`):

Alias for Replies Since.

## `untilTime` (type: `string`):

Alias for Replies Until.

## `outputVariant` (type: `string`):

Alias for Output Detail.

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

Compatibility alias. true selects raw output.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://x.com/OpenAI/status/2082577277246972300"
    }
  ],
  "tweetIds": [
    "2082577277246972300"
  ],
  "usernames": [
    "OpenAI",
    "@apify"
  ],
  "collectionStrategy": "auto",
  "scope": "all",
  "sort": "relevance",
  "includeOriginalPost": false,
  "maxItems": 25,
  "maxPagesPerTarget": 10,
  "dedupeAcrossTargets": true,
  "excludeOriginalAuthor": false,
  "verifiedOnly": false,
  "blueVerifiedOnly": false,
  "hasMediaOnly": false,
  "outputMode": "full",
  "outputPreset": "flat",
  "fieldStyle": "source",
  "includeTargetMetadata": true,
  "useSearch": false,
  "includeOriginalTweet": false,
  "includeRaw": false
}
```

# Actor output Schema

## `replies` (type: `string`):

Read reply or diagnostic rows with stable resultType values, original-post markers, conversation metadata, authors, engagement, media, and source attribution.

## `runReport` (type: `string`):

Inspect the typed outcome, completion reason, actual collection routes, fallback use, target stop reasons, counts, charge, and anomaly totals.

## `continuationCursors` (type: `string`):

Read target-specific next cursors after page-limited runs.

# 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 = {
    "startUrls": [
        {
            "url": "https://x.com/OpenAI/status/2082577277246972300"
        }
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("xquik/x-reply-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 = {
    "startUrls": [{ "url": "https://x.com/OpenAI/status/2082577277246972300" }],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("xquik/x-reply-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 '{
  "startUrls": [
    {
      "url": "https://x.com/OpenAI/status/2082577277246972300"
    }
  ],
  "maxItems": 25
}' |
apify call xquik/x-reply-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ss97VOmxYmtGJCg6e/builds/5umXrUz9UycWJYgZu/openapi.json