# Complete X (Twitter) Scraper 🐦 (`api402/complete-x-twitter-scraper`) Actor

A powerful, production-ready scraper to extract tweets, users, profiles, lists, and media from X (Twitter) with smart auto-detection, advanced filtering, and structured outputs.

- **URL**: https://apify.com/api402/complete-x-twitter-scraper.md
- **Developed by:** [Synapz (Api402)](https://apify.com/api402) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 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.
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 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

## 🚀 Complete X (Twitter) Scraper

#### ⚡ Fast • 💰 Cost-Effective • 🎯 Smart • 🔥 Production Ready

Extract **tweets, users, profiles, lists, and media** from X (Twitter) with **high speed, low cost, and zero manual configuration**.

Built for developers, startups, AI pipelines, and data-driven products.

---

### 🌟 Why This Scraper?

Most scrapers are:

* ❌ Slow
* ❌ Expensive
* ❌ Hard to configure

This one is:

* ⚡ **Blazing Fast** – Optimized scraping engine with smart routing
* 💰 **Cost Efficient** – Minimal requests + optimized pagination
* 🧠 **Smart Detection** – No need to select modes manually
* 🔄 **Fully Automated** – Handles retries, pagination & errors
* 📦 **Structured Output** – Clean JSON ready for pipelines

---

### 🧠 What Makes It Unique?

#### 🔥 Smart Auto-Detection Engine

Just provide input — the scraper decides everything:

| Input    | Automatically Does       |
| -------- | ------------------------ |
| Username | Scrapes profile + tweets |
| List URL | Scrapes list tweets      |
| Keywords | Searches tweets or users |

👉 **No configuration needed. Just run.**

---

### 🚀 Features

#### 👤 Profile Scraping

* Full profile data (bio, followers, location, etc.)
* Tweets extraction
* Replies support
* Retweets support

---

#### 📷 Media Scraping

* Extract images & videos
* Direct media URLs
* HLS preview support for videos

---

#### 🔍 Advanced Search

* Global tweet search
* User discovery
* Profile-based search

---

#### 🎯 Advanced Filtering

* 📅 Date range (from / until)
* 📊 Engagement (likes, replies, retweets)
* 🌍 Location-based filtering
* ✔️ Verified users only
* 📷 Media type filtering

---

#### ⚙️ Built-in Reliability

* 🔄 Auto retry with exponential backoff
* 🛡️ Rate limit protection
* 🌐 Proxy rotation support
* 📄 Auto pagination

---

### 💡 Use Cases

This scraper is perfect for:

#### 📊 Data Collection

* Social media analytics
* Trend tracking
* Market research

#### 🤖 AI / ML Pipelines

* Training datasets
* Sentiment analysis
* NLP pipelines

#### 🚀 Startups & SaaS

* Lead generation
* Influencer discovery
* Competitor analysis

#### 📈 Growth & Marketing

* Hashtag tracking
* Engagement analysis
* Audience research

---

### 📋 Input Configuration

#### 1️⃣ Scrape Profiles

```json
{
  "twitterHandles": ["elonmusk", "nasa"],
  "maxItems": 100
}
````

***

#### 2️⃣ Search Tweets

```json
{
  "searchTerms": ["AI", "#startup"],
  "searchType": "tweets"
}
```

***

#### 3️⃣ Search Users

```json
{
  "searchTerms": ["data scientist"],
  "searchType": "users"
}
```

***

#### 4️⃣ Scrape Lists

```json
{
  "listUrls": ["https://x.com/i/lists/123456"]
}
```

***

#### 5️⃣ Media Only Mode

```json
{
  "twitterHandles": ["nasa"],
  "mediaOnly": true
}
```

***

### ⚙️ Configuration Options

#### Profile Options

| Option          | Description       |
| --------------- | ----------------- |
| includeReplies  | Include replies   |
| includeRetweets | Include retweets  |
| mediaOnly       | Only media tweets |

***

#### Filters

| Filter   | Example                     |
| -------- | --------------------------- |
| Date     | `"startDate": "2024-01-01"` |
| Likes    | `"minLikes": 50`            |
| Language | `"tweetLanguage": "en"`     |
| Verified | `"onlyVerified": true`      |

***

### 📊 Output Format

#### 🧾 Tweet

```json
{
  "type": "tweet",
  "tweet_id": "123456",
  "text": "AI is the future",
  "likes": 120,
  "retweets": 30,
  "comments": 10
}
```

***

#### 👤 Profile

```json
{
  "type": "profile",
  "username": "nasa",
  "followers": "10M",
  "bio": "Exploring space"
}
```

***

#### 🔍 User

```json
{
  "type": "user",
  "username": "@john_doe",
  "verified": true
}
```

***

### ⚡ Performance & Cost Advantage

| Feature     | This Scraper   | Others    |
| ----------- | -------------- | --------- |
| Speed       | ⚡ Fast         | Slow      |
| Cost        | 💰 Low         | Expensive |
| Setup       | 🟢 Zero Config | Complex   |
| Reliability | 🛡️ High       | Medium    |
| Automation  | 🤖 Full        | Partial   |

***

### 🧠 How It Works

```
Input → Smart Detection → Correct Scraper → Structured Output
```

#### Internal Flow

```
Usernames → Profile Scraper
Lists → List Extractor
Search → Tweet/User Search Engine
```

***

### ⚡ Best Practices

- Start with small `maxItems`
- Avoid aggressive scraping
- Use filters to reduce cost
- Monitor logs
- Rotate instances if needed

***

### 🐛 Troubleshooting

#### ❌ No Data

- Check username spelling
- Remove strict filters
- Try different query

***

#### ⚠️ Rate Limit

- Reduce pages
- Increase delay
- Use proxies

***

#### 📷 No Media Found

- Disable `mediaOnly`
- Check if profile has media

***

### 🔐 Ethics & Legal

- Follow platform policies
- Respect privacy laws (GDPR, etc.)
- Avoid scraping sensitive/private data
- Use responsibly

***

### 🎯 Quick Start

```
1. Add input (username / search / list)
2. Set filters (optional)
3. Run scraper 🚀
```

***

### 🧩 Tech Stack

- Python Scraper Engine
- Apify SDK
- Proxy Rotation System
- Smart Routing Logic

***

### 💬 Support

- Check logs
- Review documentation
- Raise issues

***

### 📄 License

MIT License – Free to use with responsibility.

***

### 🔥 Final Note

This is a **complete, scalable, and cost-efficient X scraper** built for:

- Developers
- Startups
- AI Builders
- Growth Hackers

***

# Actor input Schema

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

Enter Twitter usernames to scrape (with or without @). Example: elonmusk, apify

## `listUrls` (type: `array`):

Enter Twitter/X list URLs to scrape. Format: https://x.com/i/lists/123456 or https://twitter.com/i/lists/123456

## `searchTerms` (type: `array`):

Search queries to find tweets or users. For profile search, provide both username and search term. Examples: 'web scraping', 'AI', '#python'

## `searchType` (type: `string`):

When using Search Terms, what to search for

## `includeReplies` (type: `boolean`):

Include reply tweets from profiles (automatically switches to 'with replies' mode)

## `includeRetweets` (type: `boolean`):

Include retweets in returned tweet results when available

## `mediaOnly` (type: `boolean`):

Only scrape tweets that contain images or videos

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

Maximum number of items (tweets/users) to scrape. 0 = unlimited

## `maxPages` (type: `integer`):

Maximum number of pages to scrape per handle/query

## `startDate` (type: `string`):

Filter tweets from this date onwards (YYYY-MM-DD format)

## `endDate` (type: `string`):

Filter tweets up to this date (YYYY-MM-DD format)

## `location` (type: `string`):

Filter tweets by location (e.g., 'Los Angeles', 'New York', 'London')

## `onlyImages` (type: `boolean`):

Filter tweets that contain images

## `onlyVideos` (type: `boolean`):

Filter tweets that contain videos

## `onlyVerified` (type: `boolean`):

Only include tweets from verified accounts

## `onlyQuotes` (type: `boolean`):

Only include quote tweets

## `includeNativeRetweets` (type: `boolean`):

Include native retweets in search-based tweet results

## `includeLinks` (type: `boolean`):

Filter tweets that contain external links

## `latestTweets` (type: `boolean`):

Only scrape tweets from the last 7 days

## `safeSearch` (type: `boolean`):

Enable safe search to filter sensitive content

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

Minimum number of likes a tweet must have

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

Minimum number of replies a tweet must have

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

Minimum number of retweets a tweet must have

## `tweetLanguage` (type: `string`):

Best-effort filter by language code when tweet language is present in the source HTML (e.g., 'en', 'es', 'fr')

## `scrapeProfileInfo` (type: `boolean`):

Extract detailed profile information (bio, stats, avatar, etc.)

## `nitterInstance` (type: `string`):

Nitter base URL to use for scraping

## `useResidentialProxy` (type: `boolean`):

Enable Apify residential proxy for better reliability (requires Apify paid plan)

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

Apify proxy configuration (requires paid plan)

## `proxyCountryCode` (type: `string`):

Optional 2-letter country code for the residential proxy

## `maxRetries` (type: `integer`):

Number of retry attempts for failed requests

## Actor input object example

```json
{
  "twitterHandles": [
    "elonmusk"
  ],
  "listUrls": [],
  "searchTerms": [],
  "searchType": "Search Users",
  "includeReplies": false,
  "includeRetweets": true,
  "mediaOnly": false,
  "maxItems": 100,
  "maxPages": 100,
  "startDate": "2024-01-01",
  "endDate": "2024-12-31",
  "location": "",
  "onlyImages": false,
  "onlyVideos": false,
  "onlyVerified": false,
  "onlyQuotes": false,
  "includeNativeRetweets": true,
  "includeLinks": false,
  "latestTweets": false,
  "safeSearch": false,
  "minLikes": 0,
  "minReplies": 0,
  "minRetweets": 0,
  "tweetLanguage": "en",
  "scrapeProfileInfo": true,
  "nitterInstance": "https://nitter.net",
  "useResidentialProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "proxyCountryCode": "",
  "maxRetries": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "twitterHandles": [
        "elonmusk"
    ],
    "listUrls": [],
    "searchTerms": [],
    "searchType": "Search Users"
};

// Run the Actor and wait for it to finish
const run = await client.actor("api402/complete-x-twitter-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 = {
    "twitterHandles": ["elonmusk"],
    "listUrls": [],
    "searchTerms": [],
    "searchType": "Search Users",
}

# Run the Actor and wait for it to finish
run = client.actor("api402/complete-x-twitter-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 '{
  "twitterHandles": [
    "elonmusk"
  ],
  "listUrls": [],
  "searchTerms": [],
  "searchType": "Search Users"
}' |
apify call api402/complete-x-twitter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Complete X (Twitter) Scraper 🐦",
        "description": "A powerful, production-ready scraper to extract tweets, users, profiles, lists, and media from X (Twitter) with smart auto-detection, advanced filtering, and structured outputs.",
        "version": "0.0",
        "x-build-id": "BHwGKf2oo9PrlJnbK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api402~complete-x-twitter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api402-complete-x-twitter-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/api402~complete-x-twitter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api402-complete-x-twitter-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/api402~complete-x-twitter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api402-complete-x-twitter-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",
                "properties": {
                    "twitterHandles": {
                        "title": "👥 Twitter Usernames",
                        "type": "array",
                        "description": "Enter Twitter usernames to scrape (with or without @). Example: elonmusk, apify",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listUrls": {
                        "title": "📋 Twitter List URLs",
                        "type": "array",
                        "description": "Enter Twitter/X list URLs to scrape. Format: https://x.com/i/lists/123456 or https://twitter.com/i/lists/123456",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "🔍 Search Terms",
                        "type": "array",
                        "description": "Search queries to find tweets or users. For profile search, provide both username and search term. Examples: 'web scraping', 'AI', '#python'",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "🎯 Search Type",
                        "enum": [
                            "tweets",
                            "users",
                            "profile_tweets"
                        ],
                        "type": "string",
                        "description": "When using Search Terms, what to search for",
                        "default": "users"
                    },
                    "includeReplies": {
                        "title": "💬 Include Replies",
                        "type": "boolean",
                        "description": "Include reply tweets from profiles (automatically switches to 'with replies' mode)",
                        "default": false
                    },
                    "includeRetweets": {
                        "title": "🔁 Include Retweets",
                        "type": "boolean",
                        "description": "Include retweets in returned tweet results when available",
                        "default": true
                    },
                    "mediaOnly": {
                        "title": "🖼️ Media Only",
                        "type": "boolean",
                        "description": "Only scrape tweets that contain images or videos",
                        "default": false
                    },
                    "maxItems": {
                        "title": "🔢 Max Items to Scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of items (tweets/users) to scrape. 0 = unlimited",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "📄 Max Pages",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape per handle/query",
                        "default": 100
                    },
                    "startDate": {
                        "title": "📅 Start Date (From)",
                        "type": "string",
                        "description": "Filter tweets from this date onwards (YYYY-MM-DD format)",
                        "default": ""
                    },
                    "endDate": {
                        "title": "📅 End Date (Until)",
                        "type": "string",
                        "description": "Filter tweets up to this date (YYYY-MM-DD format)",
                        "default": ""
                    },
                    "location": {
                        "title": "📍 Location Filter",
                        "type": "string",
                        "description": "Filter tweets by location (e.g., 'Los Angeles', 'New York', 'London')",
                        "default": ""
                    },
                    "onlyImages": {
                        "title": "🖼️ Only Images",
                        "type": "boolean",
                        "description": "Filter tweets that contain images",
                        "default": false
                    },
                    "onlyVideos": {
                        "title": "🎥 Only Videos",
                        "type": "boolean",
                        "description": "Filter tweets that contain videos",
                        "default": false
                    },
                    "onlyVerified": {
                        "title": "✅ Only Verified Users",
                        "type": "boolean",
                        "description": "Only include tweets from verified accounts",
                        "default": false
                    },
                    "onlyQuotes": {
                        "title": "🗯️ Only Quote Tweets",
                        "type": "boolean",
                        "description": "Only include quote tweets",
                        "default": false
                    },
                    "includeNativeRetweets": {
                        "title": "🔁 Include Native Retweets",
                        "type": "boolean",
                        "description": "Include native retweets in search-based tweet results",
                        "default": true
                    },
                    "includeLinks": {
                        "title": "🔗 Only Tweets with Links",
                        "type": "boolean",
                        "description": "Filter tweets that contain external links",
                        "default": false
                    },
                    "latestTweets": {
                        "title": "🕒 Latest Tweets Only (Last 7 Days)",
                        "type": "boolean",
                        "description": "Only scrape tweets from the last 7 days",
                        "default": false
                    },
                    "safeSearch": {
                        "title": "🛡️ Safe Search",
                        "type": "boolean",
                        "description": "Enable safe search to filter sensitive content",
                        "default": false
                    },
                    "minLikes": {
                        "title": "❤️ Minimum Likes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of likes a tweet must have",
                        "default": 0
                    },
                    "minReplies": {
                        "title": "💬 Minimum Replies",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of replies a tweet must have",
                        "default": 0
                    },
                    "minRetweets": {
                        "title": "🔁 Minimum Retweets",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of retweets a tweet must have",
                        "default": 0
                    },
                    "tweetLanguage": {
                        "title": "🌐 Tweet Language",
                        "type": "string",
                        "description": "Best-effort filter by language code when tweet language is present in the source HTML (e.g., 'en', 'es', 'fr')",
                        "default": ""
                    },
                    "scrapeProfileInfo": {
                        "title": "👤 Scrape Profile Info",
                        "type": "boolean",
                        "description": "Extract detailed profile information (bio, stats, avatar, etc.)",
                        "default": true
                    },
                    "nitterInstance": {
                        "title": "⚙️ Nitter Instance",
                        "type": "string",
                        "description": "Nitter base URL to use for scraping",
                        "default": "https://nitter.net"
                    },
                    "useResidentialProxy": {
                        "title": "🏠 Use Residential Proxy",
                        "type": "boolean",
                        "description": "Enable Apify residential proxy for better reliability (requires Apify paid plan)",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration (requires paid plan)",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "proxyCountryCode": {
                        "title": "🏳️ Proxy Country Code",
                        "type": "string",
                        "description": "Optional 2-letter country code for the residential proxy",
                        "default": ""
                    },
                    "maxRetries": {
                        "title": "🔄 Max Retries per Request",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```