# X Twitter Lead Scraper (`simpleapi/x-twitter-lead-scraper`) Actor

Automate lead discovery on X (Twitter) using the X Twitter Lead Scraper. Gather profile information, emails, websites, follower counts, and social links from targeted accounts. Ideal for marketers, recruiters, and businesses seeking qualified prospects.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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** Lead Scraper 📱

X / **Twitter** Lead Scraper allows you to **extract** valuable **data** from public **Twitter** profiles. This includes lead addresses and other relevant information that can aid in your marketing, research, or outreach efforts.

The tool is designed to work seamlessly with the X platform, providing accurate and reliable results. With this scraper, you can gather **data** in bulk, saving time and effort compared to manual methods.

It ensures that all **extract**ed information is sourced ethically and complies with platform policies. Whether you are looking to build a **contact** list or analyze user profiles, X / **Twitter** Lead Scraper is a versatile and efficient solution.

X / Twitter Lead Scraper is a powerful tool designed to extract lead addresses from Twitter profiles quickly and efficiently. It allows users to gather valuable contact information from public data on the X platform.

With the rise of social media platforms like Twitter, finding accurate lead addresses has become essential for marketing and outreach efforts. This tool simplifies the process by automating lead extraction from Twitter accounts.

Whether you need to extract leads for networking, lead generation, or customer engagement, X / Twitter Lead Scraper provides a reliable solution. It is designed to save time and ensure accuracy in data collection.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Addresses | Extract publicly available lead addresses from Twitter profiles. |
| Profile Names | Capture the names associated with Twitter accounts. |
| Usernames | Retrieve the unique Twitter handles of users. |
| Bio Information | Extract biographical details provided in user profiles. |
| Location Data | Collect location information shared on Twitter accounts. |
| Profile URLs | Gather direct links to Twitter profiles for further reference. |
| Follower Counts | Retrieve the number of followers associated with each account. |
| Profile Images | Download profile pictures of public Twitter accounts. |

### Key Features of **Twitter** Lead Scraper

Here are the **standout features** that make the **Twitter** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** lead extraction from public **Twitter** profiles
- ⭐ User-friendly interface for easy operation and navigation
- ⭐ Bulk data scraping to save time and effort
- ⭐ **Advanced** filtering options to target specific profiles or keywords
- ⭐ Compliance with legal and ethical guidelines for data collection
- ⭐ **Accurate** and reliable results with minimal errors
- ⭐ **Secure** data handling to protect user privacy and information
- ⭐ **Customizable** settings for tailored scraping requirements
- ⭐ Support for exporting data in various formats like CSV or JSON
- ⭐ Real-time scraping capabilities for up-to-date information
- ⭐ **Integration** with other tools and platforms for seamless workflows
- ⭐ Detailed documentation and customer support for troubleshooting

### How to use **Twitter** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Twitter** leads today:

1. ✅ **Sign up** or **log in** to your account on the X  **Twitter** Lead Scraper platform
2. ✅ Enter the keywords or criteria for the **Twitter** profiles you want to target
3. ✅ Set up filters to refine your search such as location or follower count
4. ✅ Choose the data types you wish to extract such as leads or profile names
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once completed review the extracted data for accuracy and relevance
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the extracted information for your marketing research or outreach activities

### Use Cases 🎯

Marketing and Lead Generation
🎯 **Find** potential leads by extracting leads from **Twitter** profiles
🎯 Build targeted lead lists for marketing campaigns

Research and Data Analysis
🎯 Gather public data for academic or market research purposes
🎯 **Analyze** user demographics and behavior on the X platform

Networking and Outreach
🎯 Connect with professionals by accessing their contact information
🎯 Expand your network by reaching out to relevant **Twitter** users

Business Development
🎯 **Identify** potential partners or collaborators through **Twitter** profiles
🎯 Enhance business strategies with accurate contact data

### Why choose us? 💎

X / **Twitter** Lead Scraper is the **best** **Twitter** lead scraping tool for individuals and businesses looking for a **reliable** solution. Our tool is designed to provide accurate and efficient lead extraction while ensuring compliance with all legal and ethical standards.

With **advanced** features like bulk scraping, real-time monitoring, and customizable filters, it caters to a wide range of use cases. Our platform prioritizes user privacy and data security, giving you peace of mind while scraping public data.

We also offer seamless integration with other tools and platforms, making it easy to incorporate the scraped data into your workflows. Whether you're a marketer, researcher, or business owner, our X / **Twitter** Lead Scraper is the perfect tool to help you achieve your goals.

### **Twitter** Lead Scraper Scalability 📈

X / **Twitter** Lead Scraper is built to handle projects of any size, from small-scale data collection to **large-scale** lead extraction. Its bulk scraping capabilities allow you to gather data from thousands of **Twitter** profiles in a single session.

The tool is designed to adapt to your needs, offering **customizable** settings to target specific profiles or keywords. With real-time scraping and **efficient** algorithms, it ensures fast and accurate results even for **extensive** datasets.

Whether you're a small business or a large enterprise, X / **Twitter** Lead Scraper provides the scalability you need to meet your data extraction requirements.

### **Twitter** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Twitter** is **legal** as long as you follow **ethical** and **compliant** practices. The **Twitter** Lead Scraper extracts only **publicly available** information from **public** **Twitter** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Use** X  **Twitter** Lead Scraper only for extracting publicly available data
⚖️ **Ensure** compliance with **Twitter**s terms of service and data usage policies
⚖️ **Do not** use the tool for unauthorized or illegal activities
⚖️ Respect user privacy by avoiding the extraction of sensitive or private information
⚖️ **Obtain** necessary permissions when using the data for commercial purposes
⚖️ **Avoid** spamming or misusing the extracted lead addresses
⚖️ Regularly review and adhere to applicable data protection laws
⚖️ **Use** the tool responsibly to maintain ethical standards in data scraping

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["X / Twitter Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Twitter",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Twitter) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Twitter",
    "keyword": "X / Twitter Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Twitter as the source |
| keyword | Keyword that triggered the result (X / Twitter Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Twitter profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is X / Twitter **Lead Scraper**?

X / Twitter Lead Scraper is a tool designed to extract lead addresses and other public data from Twitter profiles.

#### Is it **legal** to use X / Twitter **Lead Scraper**?

**Yes**, as long as you comply with Twitter's terms of service and use the tool responsibly to extract **publicly available** data.

#### Can I **extract** leads in bulk?

**Yes**, the tool supports bulk lead extraction to save time and effort.

#### What data formats are supported for **export**?

You can export the extracted data in formats such as **CSV** or **JSON**.

#### Is the tool user-friendly?

**Yes**, X / Twitter Lead Scraper features an intuitive interface for easy operation.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable settings for tailored data extraction.

#### Does the tool ensure data accuracy?

**Yes**, it is designed to deliver accurate and reliable results.

#### Is my data **secure** while using the tool?

**Yes**, we prioritize data security and ensure all user information is protected.

#### What are the system requirements for using the tool?

X / Twitter Lead Scraper is compatible with most modern browsers and operating systems.

#### Can I use the tool for research purposes?

**Yes**, the tool is suitable for academic and market research applications.

#### Does the tool comply with GDPR regulations?

**Yes**, it is designed to comply with GDPR and other relevant data protection laws.

#### How can I get support if I face issues?

You can contact our customer support team for assistance with any issues or queries.

#### Can I scrape **private** Twitter accounts?

**No**, the tool only extracts data from public Twitter profiles.

#### Is there a **limit** to the number of profiles I can scrape?

The tool supports scalable operations, allowing you to scrape data from as many profiles as needed.

#### What payment options are available?

We offer various payment options, including credit cards and online payment platforms.

### 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/simpleapi/Twitter-X-Tweets-Scraper) | [Twitter Profile Phone Number Scraper](https://apify.com/simpleapi/twitter-profile-phone-number-scraper) |
| [Twitter (X.com) Tweets & Profiles Scraper](https://apify.com/simpleapi/twitter-x-scraper) | [Twitter Profile Scraper](https://apify.com/simpleapi/twitter-profile-scraper) |
| [Twitter B2b Email Scraper](https://apify.com/simpleapi/twitter-b2b-email-scraper) | [Twitter Trends Scraper](https://apify.com/simpleapi/getdaytrends-trending-scraper) |
| [Twitter B2b Lead Scraper](https://apify.com/simpleapi/twitter-b2b-lead-scraper) | [Twitter User Following Scraper](https://apify.com/simpleapi/twitter-user-following-scraper) |
| [Twitter B2b Phone Number Scraper](https://apify.com/simpleapi/twitter-b2b-phone-number-scraper) | [Twitter X Posts Scraper](https://apify.com/simpleapi/Twitter-X-Posts-Scraper) |
| [Twitter Email Scraper](https://apify.com/simpleapi/twitter-email-scraper) | [Twitter X Reply Scraper](https://apify.com/simpleapi/twitter-x-reply-scraper) |
| [Twitter Lead Scraper](https://apify.com/simpleapi/twitter-lead-scraper) | [Twitter X Tweets Profiles Scraper](https://apify.com/simpleapi/twitter-x-tweets-profiles-scraper) |
| [Twitter Phone Number Scraper](https://apify.com/simpleapi/twitter-phone-number-scraper) | [X Twitter Email Scraper](https://apify.com/simpleapi/x-twitter-email-scraper) |
| [Twitter Posts Scraper](https://apify.com/simpleapi/twitter-posts-scraper) | [X Twitter Phone Number Scraper](https://apify.com/simpleapi/x-twitter-phone-number-scraper) |
| [Twitter Profile Email Scraper](https://apify.com/simpleapi/twitter-profile-email-scraper) | [X Twitter Posts Search](https://apify.com/simpleapi/x-twitter-posts-search) |
| [Twitter Profile Lead Scraper](https://apify.com/simpleapi/twitter-profile-lead-scraper) |  |

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Twitter (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Twitter profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Twitter",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/x-twitter-lead-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/x-twitter-lead-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/x-twitter-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X Twitter Lead Scraper",
        "description": "Automate lead discovery on X (Twitter) using the X Twitter Lead Scraper. Gather profile information, emails, websites, follower counts, and social links from targeted accounts. Ideal for marketers, recruiters, and businesses seeking qualified prospects.",
        "version": "0.1",
        "x-build-id": "TYa5wXJ8vkxO8BQNg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~x-twitter-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-x-twitter-lead-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/simpleapi~x-twitter-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-x-twitter-lead-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/simpleapi~x-twitter-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-x-twitter-lead-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Twitter (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Twitter profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Twitter"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Twitter"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```