# X/Twitter Profile Email Scraper (`scrapebridge/twitter-profile-email-scraper`) Actor

Twitter Profile Email Scraper extracts publicly available email addresses, profile details, bios, follower counts, website links, locations, and social media data from Twitter/X profiles. Ideal for lead generation, influencer outreach, market research, sales prospecting, and audience analysis.

- **URL**: https://apify.com/scrapebridge/twitter-profile-email-scraper.md
- **Developed by:** [Scrape Bridge](https://apify.com/scrapebridge) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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 Profile Email Search ⚡ — Find targeted leads on X (Twitter) fast

If you’re trying to get email addresses from X (Twitter) profiles, manual copy-pasting slows outreach to a crawl. **Twitter Profile Email Search** helps you find contact emails using your keywords, with optional country targeting and B2C/B2B email filtering—so you can move from discovery to outreach sooner. If you’re looking for a **Twitter profile email search** tool, a way to **search Twitter user email**, or a **Twitter email address finder** that extracts what’s publicly available, this actor is built for you. Sales teams, B2B lead gen specialists, and researchers use it to collect up to thousands of emails per run—then filter and export immediately.

---

### See the Data: Sample Output

Here’s a real record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Fitness Coach & Trainer",
  "url": "https://x.com/example_fitness",
  "description": "🏋️ Training plans available. 📧 Contact us: hello@fitcoach.com",
  "email": "hello@fitcoach.com",
  "email_domain": "fitcoach.com",
  "email_type": "B2C",
  "country": "United States",
  "status": "success",
  "error_message": null
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to guide the search for this contact (useful for reporting and prioritization). |
| `title` | string | The profile’s title/name to help you recognize the lead quickly in your CRM. |
| `url` | string | The profile link so you can verify context before outreach. |
| `description` | string | A text snippet from the source that supports the email’s context (handy for personalization). |
| `email` | string | The actual email address you can use for outreach. |
| `email_domain` | string | The company or organization domain behind the email (great for account-level grouping). |
| `email_type` | string | Whether the found email was categorized as **B2C** or **B2B**. |
| `country` | string | The selected target country you configured for the run. |
| `status` | string | Indicates whether the record was returned successfully. |
| `error_message` | string | Error details when a record can’t be produced—useful for debugging and clean data pipelines. |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["fitness", "gym", "workout"],
  "country": "United States",
  "emailType": "B2B",
  "maxEmails": 20
}
```

**Input Fields**

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | Provide one or more keywords to search for on X (Twitter). |
| `country` | ✅ | Choose the country you want to target for results (as a country label filter). |
| `emailType` | ✅ | Select whether you want **B2C** or **B2B** style email addresses. |
| `maxEmails` | ✅ | Set the maximum number of emails to collect (1–10,000). |

***

### What It Does

Twitter Profile Email Search scrapes contact emails from publicly available X (Twitter) profile sources and saves structured leads into your dataset.

#### Find emails using your X keywords

You enter `keywords`, and the actor focuses on matching those terms across the profile data it processes, producing leads tied back to the keyword that triggered them.

#### Country targeting for tighter lead lists

Set the `country` input to narrow down the set of leads you collect to the geography you care about—helpful for region-specific campaigns and localized research.

#### B2C vs B2B email filtering

Use `emailType` to choose **B2C** or **B2B**. This makes Twitter profile contact email search output more usable for outreach teams that need the right audience type.

#### Clean, integration-ready dataset rows

Each dataset row is stored with consistent fields like `keyword`, `title`, `url`, `email`, `email_domain`, `email_type`, and `country`, so you can immediately filter, deduplicate, or enrich downstream.

#### Built-in proxy support for more reliable scraping

The actor includes built-in proxy support for reliable scraping runs, which helps when collecting large lists.

#### Includes retries and fallbacks for resilience

If requests fail intermittently, the actor is designed to handle errors gracefully and continue working so you keep as much useful output as possible for your Twitter profile email address search.

Overall, Twitter Profile Email Search turns X (Twitter) profile contact emails into a structured dataset you can export and act on quickly.

***

### Why Twitter Profile Email Search?

There are plenty of ways to pull data from X (Twitter) — here’s why Twitter Profile Email Search stands out.

#### Built for lead generation outcomes

Instead of returning raw links only, Twitter Profile Email Search is designed to return emails plus the supporting profile context (`title`, `description`, `url`), so your next step—outreach—needs less manual work.

#### Keyword-first relevance

Your results are tied to the `keywords` you provide, which makes a Twitter account email lookup workflow easier to manage across different niches like “fitness”, “gym”, or “workout”.

#### Clear output fields for downstream filtering

With explicit `email_domain` and `email_type`, you can quickly build account-level lists, segment by B2C/B2B, and route results to the right systems—ideal for a Twitter DM email address search style workflow.

***

### Real-World Use Cases

Here's how different teams put Twitter Profile Email Search to work:

**Sales Teams**\
A sales rep running a targeted outbound sequence needs “find business email from Twitter account” leads for the fitness niche in the United States. They set `keywords`, choose `emailType` as **B2B**, and collect a capped list using `maxEmails` for a quick first batch. The dataset export lets them import contacts into their CRM with domains grouped by `email_domain`.

**Marketing Agencies**\
An agency builds lead lists for multiple clients and wants results that are easy to segment later. They run Twitter profile email search for each client niche using different `keywords` and then filter by `email_type` to keep consumer and business outreach cleanly separated.

**Freelance Researchers**\
A researcher needs a repeatable dataset for “locate email address for Twitter user” tasks but wants provenance. They use the returned `url`, `title`, and `description` fields for quick validation before adding records to their findings.

**Automation & Data Engineers**\
A developer wants to connect a Twitter contact email search tool into a pipeline. They trigger the actor, store the dataset output, and then use fields like `keyword`, `email`, and `country` to automatically deduplicate and enrich contacts in their data store.

**Business Owners**\
A founder running campaigns wants a fast “how to get email from Twitter” workflow for prospects who show contact info publicly. They run with B2C or B2B selection using `emailType`, export the dataset, and start outreach without switching between multiple tools.

***

### How to Run It

No code required. Here’s how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to the actor page: [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `keywords`, pick a `country`, choose `emailType` (**B2C** or **B2B**), and set `maxEmails`.
3. **Configure proxy settings** — if you want maximum reliability, use Apify’s proxy options when available for your run.
4. **Start the run and watch the live log** — confirm it’s collecting results and monitor progress.
5. **Open the Dataset tab** — view scraped rows in real time (including `email`, `email_domain`, and `url`).
6. **Export your results** — download your dataset as JSON, CSV, or Excel from the Apify dashboard.
7. **Refine and rerun** — adjust `keywords`, switch `emailType`, or increase/decrease `maxEmails` for the next batch.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Twitter Profile Email Search fits directly into your existing workflow.

Export formats include **JSON**, **CSV**, and **Excel** via the Apify dataset tab. From there, you can import into CRMs, spreadsheets, and analysis tools with minimal cleanup.

You can also connect results programmatically using **Apify API** access, integrate with tools like **Zapier / Make**, and use **webhooks** for downstream actions when a run completes.

***

### Pricing

Twitter Profile Email Search runs on Apify, which includes a **free tier** — no credit card needed to start.

You’ll get access to enough usage for several real test runs on the free tier. For heavier workloads, Apify uses a pay-as-you-go model based on Actor compute units (CU), and you can scale up via Apify’s plans when needed. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Scraping reliability | Built-in proxy support for more consistent data collection |
| Intermittent request issues | Retries and fallbacks for resilience |
| Data collection continuity | Results are written as the run progresses so you can use what’s available |
| Data structure stability | Consistent dataset fields like `email`, `email_domain`, `email_type`, and `country` |

Limitations: Twitter Profile Email Search only works with **publicly available data** from X (Twitter) sources. Profiles that don’t expose contact email information won’t produce usable email outputs, and availability can vary depending on what the account owner has published publicly.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes—Apify offers a free tier that’s enough for several real test runs. For larger batches, you’ll use Apify’s paid plans based on your run volume.

#### Do I need to log in or create an account on X (Twitter)?

No. This actor is designed to work from publicly available profile information—no X (Twitter) login is required.

#### How accurate is the extracted data?

The actor returns emails and related context as provided in the publicly available sources it processes. Accuracy depends on whether the profile actually publishes contact emails.

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

You control the cap with the `maxEmails` input (minimum 1, maximum 10,000). The actor will collect up to that maximum for your run settings.

#### How fresh is the data?

The data is collected at run time, so freshness depends on when you run the actor and what the profile has publicly available at that moment.

#### Is this legal? Does it comply with GDPR / CCPA?

Use of the extracted emails is subject to your compliance responsibilities. Twitter Profile Email Search is designed to use **publicly available data**, but you must apply GDPR, CCPA, platform rules, and spam regulations appropriately.

#### Can I export to Google Sheets or Excel?

Yes. You can export your Apify dataset as JSON, CSV, or Excel, which you can then import into Google Sheets or other tools.

#### Can I schedule this to run automatically?

Yes. Apify supports scheduling runs so you can automate recurring Twitter profile email address search workflows without manual launches.

#### Can I access results via the API?

Yes. You can retrieve results programmatically using the Apify API after the run completes.

#### What happens when the actor encounters an error?

When an issue occurs, the actor returns structured dataset rows as available and includes error details via `error_message` alongside a `status` value for each record where applicable.

***

### Get Help & Use Responsibly

Got a question about Twitter Profile Email Search or a feature you’d like added? Reach out at <dataforleads@gmail.com> — we actively maintain this actor and respond to thoughtful requests like adding more output filters or improving dataset field coverage for specific outreach workflows.

**publicly available data** on first use. The actor does not access private accounts, login-gated pages, or password-protected content. You’re responsible for GDPR, CCPA, and any applicable platform ToS when using the results. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter one or more keywords to search for on X (Twitter).

## `country` (type: `string`):

Specify the country to target for Google search results.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

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

Enter the maximum number of emails to collect.

## Actor input object example

```json
{
  "keywords": [
    "fitness",
    "gym",
    "workout"
  ],
  "country": "United States",
  "emailType": "B2C",
  "maxEmails": 20
}
```

# 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": [
        "fitness",
        "gym",
        "workout"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebridge/twitter-profile-email-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": [
        "fitness",
        "gym",
        "workout",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapebridge/twitter-profile-email-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": [
    "fitness",
    "gym",
    "workout"
  ]
}' |
apify call scrapebridge/twitter-profile-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X/Twitter Profile Email Scraper",
        "description": "Twitter Profile Email Scraper extracts publicly available email addresses, profile details, bios, follower counts, website links, locations, and social media data from Twitter/X profiles. Ideal for lead generation, influencer outreach, market research, sales prospecting, and audience analysis.",
        "version": "1.0",
        "x-build-id": "hz26GRqdG3TIRMKeo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebridge~twitter-profile-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebridge-twitter-profile-email-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/scrapebridge~twitter-profile-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebridge-twitter-profile-email-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/scrapebridge~twitter-profile-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebridge-twitter-profile-email-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",
                    "country",
                    "emailType",
                    "maxEmails"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more keywords to search for on X (Twitter).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "India",
                            "Japan",
                            "Brazil",
                            "Italy",
                            "Spain",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Hungary",
                            "Romania",
                            "Bulgaria",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Estonia",
                            "Latvia",
                            "Lithuania",
                            "Portugal",
                            "Greece",
                            "Cyprus",
                            "Malta",
                            "Luxembourg",
                            "Ireland",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Liechtenstein",
                            "Iceland",
                            "South Korea",
                            "China",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Venezuela",
                            "Ecuador",
                            "Uruguay",
                            "Paraguay",
                            "Bolivia",
                            "Guyana",
                            "Suriname",
                            "French Guiana",
                            "Falkland Islands (Malvinas)",
                            "South Georgia and the South Sandwich Islands",
                            "Bonaire, Sint Eustatius and Saba",
                            "Curaçao",
                            "Aruba",
                            "Sint Maarten (Dutch part)",
                            "Turks and Caicos Islands",
                            "British Virgin Islands",
                            "Anguilla",
                            "Montserrat",
                            "Antigua and Barbuda",
                            "Barbados",
                            "Dominica",
                            "Grenada",
                            "Saint Kitts and Nevis",
                            "Saint Lucia",
                            "Saint Vincent and the Grenadines",
                            "Trinidad and Tobago",
                            "Jamaica",
                            "Bahamas",
                            "Belize",
                            "Costa Rica",
                            "Guatemala",
                            "Honduras",
                            "Nicaragua",
                            "Panama",
                            "El Salvador",
                            "Cuba",
                            "Dominican Republic",
                            "Haiti",
                            "Puerto Rico",
                            "U.S. Virgin Islands",
                            "American Samoa",
                            "Guam",
                            "Northern Mariana Islands",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "Bahrain",
                            "Iraq",
                            "Iran, Islamic Republic of",
                            "Israel",
                            "Jordan",
                            "Kuwait",
                            "Lebanon",
                            "Oman",
                            "Qatar",
                            "Syrian Arab Republic",
                            "Yemen",
                            "Afghanistan",
                            "Bangladesh",
                            "Bhutan",
                            "Maldives",
                            "Nepal",
                            "Pakistan",
                            "Sri Lanka",
                            "Myanmar",
                            "Cambodia",
                            "Lao People's Democratic Republic",
                            "Thailand",
                            "Viet Nam",
                            "Malaysia",
                            "Singapore",
                            "Brunei Darussalam",
                            "Philippines",
                            "Indonesia",
                            "Timor-Leste",
                            "Papua New Guinea",
                            "Fiji",
                            "New Zealand",
                            "Solomon Islands",
                            "Vanuatu",
                            "New Caledonia",
                            "French Polynesia",
                            "Wallis and Futuna",
                            "Samoa",
                            "Tonga",
                            "Tuvalu",
                            "Kiribati",
                            "Nauru",
                            "Federated States of Micronesia",
                            "Marshall Islands",
                            "Palau",
                            "Cook Islands",
                            "Niue",
                            "Tokelau"
                        ],
                        "type": "string",
                        "description": "Specify the country to target for Google search results.",
                        "default": "United States"
                    },
                    "emailType": {
                        "title": "Email Type",
                        "enum": [
                            "B2C",
                            "B2B"
                        ],
                        "type": "string",
                        "description": "Choose one — B2C or B2B.",
                        "default": "B2C"
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Enter the maximum number of emails to collect.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
