# Twitter X Reply Scraper (`scrapier/twitter-x-reply-scraper`) Actor

🐦 Twitter X Reply Scraper collects tweet replies at scale—usernames, timestamps, text, likes—from public threads. 🔎 Ideal for social listening, brand monitoring, competitor analysis & research. 📊 Export CSV/JSON and integrate via API for sentiment, reporting & dashboards. 🚀

- **URL**: https://apify.com/scrapier/twitter-x-reply-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 X Reply Scraper

Twitter X Reply Scraper is a production-ready Apify actor that collects tweet replies at scale from public X (Twitter) search results. It acts as a focused Twitter reply scraper and X reply extractor that pulls the Latest search timeline and then loads direct replies per tweet — perfect for social listening, brand monitoring, competitor analysis, and research. Built for marketers, developers, data analysts, and researchers, it lets you scrape Twitter replies, download tweet replies, and power dashboards and sentiment analysis workflows at scale.

### What data / output can you get?

This actor saves a structured item for each tweet found in your X search results, plus an array of direct replies for each tweet.

| Data field | Description | Example value |
| --- | --- | --- |
| tweetLink | Canonical link to the tweet | https://x.com/acme/status/1784567890123456789 |
| avatar | Author profile image URL (bigger size) | https://pbs.twimg.com/profile_images/..._bigger.jpg |
| fullname | Author display name | Acme Inc. |
| handle | Author handle (with @) | @acme |
| verified | Whether the author is verified (true/false or null) | true |
| tweetDate | Tweet timestamp in ISO-like format | 2026-04-26T12:34:56.000Z |
| tweetContent | Full text of the tweet | Launching our new product today! |
| commentCount | Reply count on the tweet | 42 |
| retweetCount | Retweet/Repost count | 18 |
| quoteCount | Quote count | 5 |
| likeCount | Like count | 256 |
| repliesData | Array of direct reply objects (same fields as above, excluding repliesData) | [ { ...reply object... } ] |

Notes:
- Each repliesData item includes: tweetLink, avatar, fullname, handle, verified, tweetDate, tweetContent, commentCount, retweetCount, quoteCount, likeCount.
- You can export your dataset as CSV or JSON and access it via the Apify API for integration with reporting and dashboards.

### Key features

- 🔎 Latest search timeline + direct replies
  Uses X GraphQL SearchTimeline to collect the Latest search results, then loads direct replies with TweetDetail for precise, conversation-focused extraction.

- 🧭 Dynamic GraphQL query ID resolution
  Automatically extracts live query IDs from X’s main JavaScript bundle and generates x-client-transaction-id values, improving stability over hardcoded approaches.

- 🔐 Session-auth scraping (auth token + ct0)
  Runs with your authenticated X session (authToken and ct0), enabling reliable access and accurate data for your queries.

- 🌐 Smart proxy strategy (optional)
  Start direct by default or enable Apify Proxy. The actor escalates connection strategy on blocks (direct → datacenter → residential) to keep your runs moving.

- 📊 Configurable scope and depth
  Control throughput with maxSearchResults (per search URL) and tailor conversation depth with maxReplies (per tweet).

- 💾 Export-ready results
  Structured output designed for analytics: export CSV/JSON or pull via the Apify API for BI dashboards, reporting, and sentiment pipelines.

- 🧰 Developer-friendly (Python + API)
  Built on apify/actor-python with clean dataset output — ideal for Python Twitter reply scraper workflows and “Twitter reply scraping API” integrations.

- 🧱 Production-focused reliability
  Robust error handling, ID discovery, and controller_data handling from the first timeline page ensure consistent scraping across runs.

### How to use Twitter X Reply Scraper - step by step

1. Sign in to Apify and open the Twitter X Reply Scraper actor.
2. Add Start URLs: paste one or more X search page links (the same URLs you get when you search on x.com). The actor parses the q= parameter automatically.
3. Set your session: enter authToken and ct0 in the input or set environment variables AUTH_TOKEN and CT0 in Apify.
4. Configure limits: choose maxSearchResults (per search URL) and maxReplies (per tweet) to control volume and depth.
5. (Optional) Enable Apify Proxy: toggle proxyConfiguration.useApifyProxy to true if you prefer routing through Apify’s network from the start.
6. Run the actor: click Start. The run logs will show pages loaded and rows saved as each tweet and its replies are processed.
7. Download results: open the Output / Dataset tab to browse, then export to CSV or JSON. Use the Apify API to integrate with your systems.

Pro Tip: Chain this Twitter replies crawler with your NLP pipeline for sentiment and topics, or trigger it via the Apify API to keep your “Twitter reply export tool” updated on a schedule.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening & brand monitoring | Track brand mentions and analyze direct replies for sentiment and themes using a tweet replies extractor. |
| Competitor analysis | Monitor competitor announcements and mine reply reactions to benchmark engagement and feedback. |
| Campaign performance | Capture reply streams around launches or hashtags to evaluate audience response in near real time. |
| Customer support insights | Surface common issues and questions in replies for faster triage and improved knowledge bases. |
| Academic & market research | Collect conversation data from public threads to study discourse, topics, and attention patterns. |
| Reporting & dashboards | Export Twitter replies to CSV and connect via API to BI tools for daily or weekly reporting. |
| API pipelines | Use as a Twitter reply scraping API source in ETL workflows to populate data lakes and ML features. |
| Product feedback mining | Gather direct customer feedback from replies to inform roadmap prioritization. |

### Why choose Twitter X Reply Scraper?

Built for precision, automation, and reliability, this X reply scraper outperforms brittle, manual tools.

- 🎯 GraphQL-native accuracy: Uses SearchTimeline and TweetDetail with controller_data for consistent, first-class extraction.
- 🔐 Session-based reliability: Authenticated runs with authToken + ct0 keep results stable for your specific queries.
- 📈 Scalable controls: Tune maxSearchResults (1–5000) and maxReplies (1–500) for breadth and depth that fit your needs.
- 🧰 Developer access: Integrate via Apify’s dataset API for a Python Twitter reply scraper workflow or internal automations.
- 🌐 Resilient networking: Optional Apify Proxy with automatic escalation from direct to DC to residential on blocks.
- 💾 Analytics-ready: Clean JSON you can export to CSV or pull via API to power dashboards and sentiment analysis.
- 🛡️ Safer than extensions: Avoid unstable browser add-ons — run on Apify’s infrastructure with production-grade reliability.

In short, a focused Twitter comments scraper and Twitter conversation scraper designed for structured data and scale.

### Is it legal / ethical to use Twitter X Reply Scraper?

Yes — when done responsibly. This actor collects data from public X (Twitter) content and requires your authenticated session to access standard features. You are responsible for ensuring your use complies with X’s terms and applicable laws.

Guidelines to follow:
- Scrape only public content you’re permitted to access with your session.
- Respect platform terms and rate limits.
- Comply with data protection laws (e.g., GDPR, CCPA) and internal policies.
- Keep authToken and ct0 secure; never share them publicly.
- Consult your legal team for edge cases or commercial deployments.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://x.com/search?q=%23journorequest%20min_replies%3A10&src=typed_query&f=live"
  ],
  "maxSearchResults": 10,
  "maxReplies": 5,
  "authToken": "YOUR_AUTH_TOKEN_HERE",
  "ct0": "YOUR_CT0_HERE",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

- startUrls (array, required)
  - Description: Add one or more X search page links (the same URLs you get when you search on x.com). Each link defines what topic or keywords you want to follow.
  - Default: none
- maxSearchResults (integer, optional)
  - Description: Choose how many posts you want from each search link.
  - Default: 10 (min 1, max 5000)
- maxReplies (integer, optional)
  - Description: For each post found, decide how many replies to keep in your results.
  - Default: 5 (min 1, max 500)
- authToken (string, optional)
  - Description: Your X account session token (or set the AUTH\_TOKEN environment variable in Apify).
  - Default: ""
- ct0 (string, optional)
  - Description: The companion security value for your X session (or use the CT0 env var).
  - Default: ""
- proxyConfiguration (object, optional)
  - Description: Optional Apify Proxy settings for smoother runs in the cloud.
  - Default prefill: { "useApifyProxy": false }

Example JSON output

```json
[
  {
    "tweetLink": "https://x.com/acme/status/1784567890123456789",
    "avatar": "https://pbs.twimg.com/profile_images/abc_bigger.jpg",
    "fullname": "Acme Inc.",
    "handle": "@acme",
    "verified": true,
    "tweetDate": "2026-04-26T12:34:56.000Z",
    "tweetContent": "Launching our new product today!",
    "commentCount": 42,
    "retweetCount": 18,
    "quoteCount": 5,
    "likeCount": 256,
    "repliesData": [
      {
        "tweetLink": "https://x.com/user123/status/1784567890123456790",
        "avatar": "https://pbs.twimg.com/profile_images/def_bigger.jpg",
        "fullname": "Jane Doe",
        "handle": "@user123",
        "verified": null,
        "tweetDate": "2026-04-26T12:40:10.000Z",
        "tweetContent": "Congrats! Looking forward to trying it out.",
        "commentCount": 1,
        "retweetCount": 0,
        "quoteCount": 0,
        "likeCount": 7
      }
    ]
  }
]
```

Notes:

- repliesData contains direct replies only — those where the in\_reply\_to status matches the focal tweet. Nested replies to replies are not included.
- Some fields may be null or zero when not present in the source (e.g., verified).

### FAQ

#### Do I need to log in or provide cookies to use this tool?

Yes. You must provide your X session via authToken and ct0 in the input, or set the AUTH\_TOKEN and CT0 environment variables. This session enables the actor to access the Latest search results reliably and fetch tweet replies.

#### What types of data does the Twitter X Reply Scraper extract?

It outputs each tweet’s link, author avatar, fullname, handle, verified flag, date, full text, and engagement counts, plus an array of direct reply objects with the same fields. This makes it a precise tweet replies extractor for public conversations.

#### Does it collect entire threads or only direct replies?

It collects direct replies to the focal tweet. Each reply in repliesData is validated against the original tweet ID, so deeper nested replies (replies to replies) are not included.

#### How many results can I collect per run?

You control volume with two limits: maxSearchResults per search URL (1–5000) and maxReplies per tweet (1–500). This flexibility supports both quick samples and larger X reply scraper jobs.

#### Can I export to CSV/JSON and integrate via API or Python?

Yes. Results are stored in an Apify dataset you can download as CSV or JSON, or access via the Apify API. This fits Python Twitter reply scraper workflows and “Twitter reply scraping API” integrations for pipelines and dashboards.

#### Do I need to enable a proxy?

Not necessarily. By default, the actor tries a direct connection. If blocks occur, it escalates from direct to Apify datacenter and then residential proxies. You can also enable Apify Proxy from the start via proxyConfiguration.

#### Which searches are supported?

Provide X search URLs (e.g., https://x.com/search?q=...\&f=live). The actor parses the q parameter and requests the Latest product results, functioning as a targeted Twitter reply exporter for your chosen keywords and filters.

#### Is it legal to scrape Twitter/X with this tool?

Yes, when done responsibly. The actor accesses public content using your session and leaves compliance to your use case. Ensure you follow X’s terms and applicable laws, and keep your session credentials secure.

### Final thoughts

Twitter X Reply Scraper is built to extract tweet replies from public X search results with structure and scale. With authenticated stability, dynamic GraphQL handling, optional proxying, and export-ready datasets, it serves marketers, analysts, researchers, and developers alike. Connect it to your Twitter reply scraping API workflow, power Python pipelines, and export Twitter replies to CSV for sentiment, reporting, and dashboards. Start extracting smarter conversation insights, at the depth and scale your projects demand.

### What are other Twitter scraping tools?

If you want to scrape specific Twitter data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Twitter (X) Tweets Scraper](https://apify.com/scrapier/Twitter-X-Tweets-Scraper) | [Twitter Profile Phone Number Scraper](https://apify.com/scrapier/twitter-profile-phone-number-scraper) |
| [Twitter (X.com) Tweets & Profiles Scraper](https://apify.com/scrapier/twitter-x-scraper) | [Twitter Profile Scraper](https://apify.com/scrapier/twitter-profile-scraper) |
| [Twitter B2b Email Scraper](https://apify.com/scrapier/twitter-b2b-email-scraper) | [Twitter Trends Scraper](https://apify.com/scrapier/getdaytrends-trending-scraper) |
| [Twitter B2b Lead Scraper](https://apify.com/scrapier/twitter-b2b-lead-scraper) | [Twitter User Following Scraper](https://apify.com/scrapier/twitter-user-following-scraper) |
| [Twitter B2b Phone Number Scraper](https://apify.com/scrapier/twitter-b2b-phone-number-scraper) | [Twitter X Posts Scraper](https://apify.com/scrapier/Twitter-X-Posts-Scraper) |
| [Twitter Email Scraper](https://apify.com/scrapier/twitter-email-scraper) | [Twitter X Tweets Profiles Scraper](https://apify.com/scrapier/twitter-x-tweets-profiles-scraper) |
| [Twitter Lead Scraper](https://apify.com/scrapier/twitter-lead-scraper) | [X Twitter Email Scraper](https://apify.com/scrapier/x-twitter-email-scraper) |
| [Twitter Phone Number Scraper](https://apify.com/scrapier/twitter-phone-number-scraper) | [X Twitter Lead Scraper](https://apify.com/scrapier/x-twitter-lead-scraper) |
| [Twitter Posts Scraper](https://apify.com/scrapier/twitter-posts-scraper) | [X Twitter Phone Number Scraper](https://apify.com/scrapier/x-twitter-phone-number-scraper) |
| [Twitter Profile Email Scraper](https://apify.com/scrapier/twitter-profile-email-scraper) | [X Twitter Posts Search](https://apify.com/scrapier/x-twitter-posts-search) |
| [Twitter Profile Lead Scraper](https://apify.com/scrapier/twitter-profile-lead-scraper) |  |

# Actor input Schema

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

📋 Add one or more X search page links (the same URLs you get when you search on x.com). Each link defines what topic or keywords you want to follow. You can add as many as you need — great for tracking several topics in one run! 🌍✅

## `maxSearchResults` (type: `integer`):

🎯 Choose how many posts you want from each search link — higher numbers give you a broader snapshot; lower numbers finish faster. Pick what fits your project! ⚡📈

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

💡 For each post found, decide how many replies to keep in your results. Ideal when you want a taste of the conversation or a deeper thread — you’re in control! 🙌🧵

## `authToken` (type: `string`):

🔑 Your X account session token (or set the AUTH\_TOKEN environment variable in Apify). This lets the actor use your logged-in session. Keep it private — never share it publicly! 🤫🔒

## `ct0` (type: `string`):

✨ The companion security value for your X session (or use the CT0 env var). It works together with your auth token so everything stays in sync — like a key and a lock! 🔐💙

## `proxyConfiguration` (type: `object`):

🌍 Optional **Apify Proxy** settings for smoother runs in the cloud. Turn it on if you prefer routing traffic through Apify’s network — handy for stable jobs and privacy-friendly setups. Off by default; enable when it suits you! ☁️✅

## Actor input object example

```json
{
  "startUrls": [
    "https://x.com/search?q=%23journorequest+min_replies%3A10&src=typed_query&f=live"
  ],
  "maxSearchResults": 10,
  "maxReplies": 5,
  "authToken": "",
  "ct0": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://x.com/search?q=%23journorequest+min_replies%3A10&src=typed_query&f=live"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/twitter-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": ["https://x.com/search?q=%23journorequest+min_replies%3A10&src=typed_query&f=live"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/twitter-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": [
    "https://x.com/search?q=%23journorequest+min_replies%3A10&src=typed_query&f=live"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/twitter-x-reply-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter X Reply Scraper",
        "description": "🐦 Twitter X Reply Scraper collects tweet replies at scale—usernames, timestamps, text, likes—from public threads. 🔎 Ideal for social listening, brand monitoring, competitor analysis & research. 📊 Export CSV/JSON and integrate via API for sentiment, reporting & dashboards. 🚀",
        "version": "0.1",
        "x-build-id": "xE769d94nhLCMeYbW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~twitter-x-reply-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-twitter-x-reply-scraper",
                "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/scrapier~twitter-x-reply-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-twitter-x-reply-scraper",
                "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/scrapier~twitter-x-reply-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-twitter-x-reply-scraper",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Start URLs — where to look on X",
                        "type": "array",
                        "description": "📋 Add one or more X search page links (the same URLs you get when you search on x.com). Each link defines what topic or keywords you want to follow. You can add as many as you need — great for tracking several topics in one run! 🌍✅",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSearchResults": {
                        "title": "📊 Maximum posts to collect",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎯 Choose how many posts you want from each search link — higher numbers give you a broader snapshot; lower numbers finish faster. Pick what fits your project! ⚡📈",
                        "default": 10
                    },
                    "maxReplies": {
                        "title": "💬 Maximum replies per post",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "💡 For each post found, decide how many replies to keep in your results. Ideal when you want a taste of the conversation or a deeper thread — you’re in control! 🙌🧵",
                        "default": 5
                    },
                    "authToken": {
                        "title": "🔐 Session — auth token",
                        "type": "string",
                        "description": "🔑 Your X account session token (or set the AUTH_TOKEN environment variable in Apify). This lets the actor use your logged-in session. Keep it private — never share it publicly! 🤫🔒",
                        "default": ""
                    },
                    "ct0": {
                        "title": "🛡️ Session — security (ct0)",
                        "type": "string",
                        "description": "✨ The companion security value for your X session (or use the CT0 env var). It works together with your auth token so everything stays in sync — like a key and a lock! 🔐💙",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Connection & privacy (proxy)",
                        "type": "object",
                        "description": "🌍 Optional **Apify Proxy** settings for smoother runs in the cloud. Turn it on if you prefer routing traffic through Apify’s network — handy for stable jobs and privacy-friendly setups. Off by default; enable when it suits you! ☁️✅"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
