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

🐦 Twitter X Reply Scraper (twitter-x-reply-scraper) extracts public replies from X posts—usernames, handles, timestamps, text, and engagement—at scale. 🔎 Threads, filters & pagination. 📄 Export CSV/JSON. ⚡ Perfect for social listening, brand monitoring, research & customer support.

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

## Pricing

from $4.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

The Twitter X Reply Scraper collects “Latest” search results from X (Twitter) and extracts direct replies for each post at scale. It solves the challenge of capturing conversation context by combining tweet discovery with reply harvesting — ideal for marketers, developers, data analysts, and researchers who need a reliable Twitter reply scraper or X replies extractor. Use it as a tweet replies scraper for social listening, a Twitter conversation thread scraper for brand monitoring, or a Twitter reply crawler for customer support analytics — all streamlined into a structured dataset for CSV/JSON export.

### What data / output can you get?

Below are the exact fields this actor saves to your dataset for each post (plus nested replies):

| Data type     | Description                                              | Example value |
| --- | --- | --- |
| tweetLink | Direct link to the post | https://x.com/example/status/1779999999999999999 |
| avatar | Profile image URL (upsized from “_normal” to “_bigger” when available) | https://pbs.twimg.com/profile_images/..._bigger.jpg |
| fullname | Display name of the author | Jane Doe |
| handle | Handle of the author (with @) | @janedoe |
| verified | Whether the author is verified (true/false or null) | true |
| tweetDate | ISO-like timestamp from X “created_at” | 2026-04-20T15:42:00.000Z |
| tweetContent | Full text of the post | Excited to launch our new product today! |
| commentCount | Reply count shown on the post | 42 |
| retweetCount | Retweet count | 15 |
| quoteCount | Quote tweet count | 3 |
| likeCount | Like (favorite) count | 128 |
| repliesData | Array of direct reply objects (same structure as above, without nested replies) | [ { reply object }, ... ] |

Notes:
- repliesData contains only direct replies to the focal tweet (where in_reply_to_status_id_str matches the tweet).
- Export your dataset to CSV or JSON directly from Apify.

### Key features

- 🔎 Latest results + direct replies extraction
  Uses X GraphQL SearchTimeline to find posts in the “Latest” tab, then loads direct replies per post via TweetDetail — perfect for scrape Twitter replies workflows and conversation analysis.

- 🧠 Dynamic GraphQL & transaction handling
  Automatically resolves dynamic query IDs from X’s main JS bundle and generates x-client-transaction-id headers for resilient, accurate calls to SearchTimeline and TweetDetail.

- 🧵 Conversation-aware reply parsing
  Captures direct replies by matching the in_reply_to relation, returning clean, per-post threads in repliesData. Ideal as a Twitter thread replies downloader or Twitter replies extractor.

- 📈 Scale with limits & pagination
  Control collection with maxSearchResults (per search link) and maxReplies (per post). The actor paginates via cursors to cover long “Latest” timelines reliably.

- 🌐 Smart connectivity with proxies
  Choose to start with direct connections or enable Apify Proxy. The actor escalates automatically (direct → DC → Residential) when connection blocks are detected.

- 💾 Streamed dataset output
  Each post (with its repliesData) is pushed to the dataset as it’s processed — great for incremental pipelines, dashboards, or Twitter replies export CSV.

- 💻 Developer-friendly integration
  Run via Apify’s API and connect with Python or automation tools. Use it as a Twitter replies API scraper component in your data workflows.

- 🔐 Session-based, no API keys required
  Works with your X session (authToken + ct0). No official API keys needed — a practical X replies scraper without API keys for authenticated, public content access.

- ⚙️ Production-ready reliability
  Built on Apify infrastructure with structured logs, retry logic, and header/cookie management. Optimized for consistent, large-scale runs.

### How to use Twitter X Reply Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Twitter X Reply Scraper actor.
3. Add Start URLs:
   - Paste one or more X search URLs (e.g., https://x.com/search?q=%23yourtopic&src=typed_query&f=live). The q parameter is parsed automatically.
4. Provide your session:
   - Enter authToken and ct0 from your X (Twitter) session. These are required for the actor to access public content with your account.
5. Set limits:
   - maxSearchResults controls how many posts to collect per search link.
   - maxReplies limits how many direct replies to save for each post.
6. (Optional) Configure proxy:
   - Set proxyConfiguration.useApifyProxy to true if you prefer routing through Apify Proxy from the start. Otherwise, the actor begins direct and escalates on blocks.
7. Run the actor:
   - Click Start. The actor loads “Latest” results, follows pagination, and pushes each post with repliesData to the dataset as it goes.
8. Export results:
   - Go to the Dataset tab to browse, then export to CSV or JSON for analysis and reporting.

Pro Tip: Automate social listening or support tagging by triggering this Twitter reply scraper tool via the Apify API and sending the dataset to your BI stack or CRM. Perfect for Twitter replies export CSV pipelines.

### Use cases

| Use case name | Description |
| --- | --- |
| Brand monitoring + reply analysis | Track brand mentions and scrape Twitter replies to measure sentiment, spot issues, and surface customer insights across conversation threads. |
| Social listening for campaigns | Analyze “Latest” timelines for keywords/hashtags to understand audience feedback and top replies during launches or events with a tweet replies scraper. |
| Customer support triage | Pull direct replies to product announcements to identify bugs, feature requests, and support questions quickly. |
| Competitive research | Monitor competitor posts and replies to benchmark engagement patterns and recurring themes using an X reply scraper. |
| Content strategy optimization | Use reply-level feedback and counts to refine messaging based on what resonates most with your audience. |
| Academic & policy research | Collect structured conversation data for studies on discourse, virality, and community behavior with a Twitter replies extractor. |
| Data pipelines / API enrichment | Integrate as a Twitter replies API scraper component in ETL jobs; export JSON for downstream NLP, clustering, or dashboards. |

### Why choose Twitter X Reply Scraper?

The Twitter X Reply Scraper is built for precision, scale, and workflow automation — a production-ready alternative to brittle browser add-ons.

- ✅ Accurate, conversation-aware extraction: Direct replies are identified via in_reply_to relationships.
- 🌍 Scalable & resilient: Cursor-based pagination, dynamic query IDs, and x-client-transaction-id ensure consistent runs.
- 🔌 Developer access: Integrate via Apify’s API, schedule runs, and plug results into Python or no-code tools.
- 🧩 CSV/JSON outputs: Clean, structured exports for dashboards, analytics, or CRM enrichment.
- 🌐 Proxy-ready reliability: Optional Apify Proxy with automatic escalation on blocks.
- 🔐 Safe by design: Uses your own X session (authToken + ct0), avoiding the need for official API keys.
- 💸 Cost-effective vs. extensions: More stable and maintainable than ad hoc browser-based tools.

In short, it’s the reliable X reply scraper you can run at scale for consistent, structured results.

### Is it legal / ethical to use Twitter X Reply Scraper?

Yes — when used responsibly. This actor accesses publicly available content on X (Twitter) using your authenticated session.

Guidelines:
- Only collect data that is publicly visible to your account.
- Review and respect X’s Terms of Service and robots rules.
- Ensure compliance with data protection laws (e.g., GDPR, CCPA) and your internal policies.
- Use the data for legitimate purposes; avoid misuse or spam.
- Consult your legal team if you have specific compliance questions.

### Input parameters & output format

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

#### Parameters

| Name | Type | Description | Default | Required |
| --- | --- | --- | --- | --- |
| startUrls | 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. | — | Yes |
| maxSearchResults | integer | Choose how many posts you want from each search link — higher numbers give you a broader snapshot; lower numbers finish faster. | 10 | No |
| maxReplies | integer | For each post found, decide how many replies to keep in your results. | 5 | No |
| authToken | string | Your X account session token (or set the AUTH\_TOKEN environment variable in Apify). | "" | No |
| ct0 | string | The companion security value for your X session (or use the CT0 env var). | "" | No |
| proxyConfiguration | object | Optional Apify Proxy settings for smoother runs in the cloud. Off by default; enable when it suits you. | {"useApifyProxy": false} | No |

Notes:

- Both authToken and ct0 are required at runtime. If not provided in input, the actor reads AUTH\_TOKEN and CT0 from environment variables.
- startUrls should be X “Latest” search URLs; the q parameter is parsed automatically.

#### Example JSON output

```json
[
  {
    "tweetLink": "https://x.com/acme/status/1780012345678900000",
    "avatar": "https://pbs.twimg.com/profile_images/1234567890/abc_bigger.jpg",
    "fullname": "ACME Inc.",
    "handle": "@acme",
    "verified": true,
    "tweetDate": "2026-04-20T12:30:00.000Z",
    "tweetContent": "We’re excited to share our new update! 🚀",
    "commentCount": 27,
    "retweetCount": 12,
    "quoteCount": 2,
    "likeCount": 103,
    "repliesData": [
      {
        "tweetLink": "https://x.com/janedoe/status/1780012345678901111",
        "avatar": "https://pbs.twimg.com/profile_images/2222222222/def_bigger.jpg",
        "fullname": "Jane Doe",
        "handle": "@janedoe",
        "verified": false,
        "tweetDate": "2026-04-20T12:35:00.000Z",
        "tweetContent": "Congrats! Looking forward to trying it out.",
        "commentCount": 1,
        "retweetCount": 0,
        "quoteCount": 0,
        "likeCount": 5
      }
    ]
  }
]
```

Field notes:

- verified may be null if not available.
- avatar may be empty if not resolvable.
- repliesData includes only direct replies to the focal tweet.

### FAQ

#### Do I need to log in or provide cookies?

✅ Yes. Provide your X session values via authToken and ct0 in the input, or set AUTH\_TOKEN and CT0 as environment variables. The actor uses your session to access publicly visible content.

#### Does this use the official Twitter API?

❌ No official API keys are required. The actor calls X’s GraphQL endpoints (SearchTimeline and TweetDetail) with your session and generated headers, working as a Twitter replies API scraper without API keys.

#### What kind of replies does it collect?

🧵 It collects direct replies to each focal tweet (where in\_reply\_to matches the tweet). These replies are returned in repliesData for each post.

#### How many posts and replies can I scrape?

📈 You can collect up to maxSearchResults (1–5000) posts per search URL and up to maxReplies (1–500) replies per post. Set these in the input to match your needs.

#### Can I export the results?

💾 Yes. Open the Dataset for your run and export to CSV or JSON. This makes it easy to plug into analytics pipelines or share with stakeholders.

#### Can I use proxies?

🌐 Yes. You can enable Apify Proxy via proxyConfiguration.useApifyProxy. The actor also escalates connectivity from direct to DC and then to Residential proxies when blocks are detected.

#### Does it work with Python or automation tools?

💻 Yes. Trigger the actor via Apify’s API, integrate with your Python scripts, or orchestrate runs with tools like Make or n8n. It’s built to slot into data pipelines as a Twitter reply scraper Python-friendly component.

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

🛡️ Yes, when done responsibly. Only collect publicly visible content, comply with X’s terms and applicable regulations (e.g., GDPR/CCPA), and use the data ethically. Consult your legal team for specific use cases.

### Closing CTA / Final thoughts

The Twitter X Reply Scraper is built to capture “Latest” posts and their direct replies in a clean, structured format. With session-based access, dynamic GraphQL handling, proxy resilience, and CSV/JSON exports, it’s ideal for marketers, analysts, developers, and researchers who need a dependable X reply scraper.

Run it on Apify to automate social listening, brand monitoring, and research — or call it via API from your Python workflows to power Twitter replies export CSV pipelines. Start extracting smarter, conversation-aware insights from X at scale.

# 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("scraper-engine/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("scraper-engine/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 scraper-engine/twitter-x-reply-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 (twitter-x-reply-scraper) extracts public replies from X posts—usernames, handles, timestamps, text, and engagement—at scale. 🔎 Threads, filters & pagination. 📄 Export CSV/JSON. ⚡ Perfect for social listening, brand monitoring, research & customer support.",
        "version": "0.1",
        "x-build-id": "bRK09O0uXfzfmeE9f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~twitter-x-reply-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~twitter-x-reply-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~twitter-x-reply-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
