# Twitter Profile Email Scraper By Keyword (`scraper-mind/twitter-profile-email-scraper`) Actor

Twitter Profile Email Scraper: Extract verified B2B/B2C emails, target by keyword & country, and build high-quality Twitter/X leads instantly. Perfect for marketers, agencies, and growth teams.

- **URL**: https://apify.com/scraper-mind/twitter-profile-email-scraper.md
- **Developed by:** [Scraper Mind](https://apify.com/scraper-mind) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 12 total users, 0 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 Profile Email Search 🔍

**Twitter Profile Email Search** helps you discover targeted email leads associated with X (Twitter) profiles by running keyword-based searches and filtering results by country and email availability. If you’re looking for a **twitter profile email search**, a way to **find email from twitter profile**, or a **twitter email search tool** for lead generation and outreach, this actor streamlines the process by collecting publicly available contact information at scale—saving you hours of manual work.

---

### 🚀 Why choose Twitter Profile Email Search?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-driven lead discovery** | Use `keywords` to search for relevant Twitter/X profiles and contacts in one run |
| ✅ **Country targeting** | Filter results using `country` to focus on leads from your preferred geography |
| ✅ **B2C or B2B email selection** | Choose `emailType` to collect emails aligned with your outreach strategy |
| ✅ **Max email collection control** | Set `maxEmails` to limit how many emails the actor will collect (useful for budget and workflow control) |
| ✅ **Structured dataset output** | Save results into a ready-to-analyze dataset with consistent fields (keyword, profile info, email, and classification) |
| ✅ **Scale-friendly execution** | Designed to run in batches with practical resilience so you can grow your lead lists efficiently |

---

### 🔑 Key features

- 🎯 **Keyword-based targeting**: Search using your chosen `keywords` and collect matching profile contact emails  
- 🌍 **Country filtering for relevance**: Focus on leads from the `country` you select  
- 🧩 **B2C / B2B email modes**: Use `emailType` set to **B2C** or **B2B** to align results with your campaign type  
- 📌 **Structured fields per result**: Each dataset row includes `keyword`, profile `title`, `url`, `description`, and email details  
- 💾 **Dataset-ready output**: Results are stored immediately in the **X (Twitter) Email Data** dataset (table view: “Scraped Emails”)  
- 🛡️ **Resilience & fallbacks**: Includes retries and fallbacks to improve reliability during scraping runs  
- 📊 **Email classification and domains**: Outputs both `email` and `email_domain`, plus `email_type` for downstream filtering  

---

### 📝 Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | Enter one or more keywords to search for on X (Twitter). The actor will use these keywords to guide discovery. |
| `country` | ✅ | Specify the country to target. This helps prioritize leads from your chosen geography. |
| `emailType` | ✅ | Choose one: **B2C** or **B2B**. Use this to match the email style you want to collect. |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect. Min is 1, max is 10000. (Default: 20) |

***

### 📦 Output

The actor saves each profile’s data in JSON format into the dataset **X (Twitter) Email Data** (view: **Scraped Emails**). The dataset transformation fields are:

```json
[
  {
    "keyword": "fitness",
    "title": "Example Profile Title",
    "url": "https://x.com/example_profile",
    "description": "Example profile description text",
    "email": "lead@example.com",
    "email_domain": "example.com",
    "email_type": "B2C",
    "country": "United States"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that guided this lead/profile result |
| `title` | string | Title text associated with the profile result |
| `url` | string | Link to the profile page (shown as **View Profile** in the dataset table) |
| `description` | string | Text description associated with the result |
| `email` | string | The extracted email address for the lead (if available) |
| `email_domain` | string | The domain part of the extracted email (e.g., `example.com`) |
| `email_type` | string | The email classification used for the result (B2C or B2B) |
| `country` | string | The country used for filtering/targeting |

***

### 🚀 How to use Twitter Profile Email Search (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and navigate to the **Actors** section.

2. **Find the actor**\
   Search for **Twitter Profile Email Search** and open the actor page.

3. **Go to the INPUT section**\
   Use the built-in form and/or paste your `input.json` values.

4. **Set your lead discovery keywords**\
   Enter one or more items in `keywords` (for example: `fitness`, `gym`, `workout`).

5. **Choose your targeting country**\
   Select `country` from the provided list (default is **United States**).

6. **Pick B2C or B2B email mode**\
   Set `emailType` to **B2C** or **B2B** depending on your outreach plan.

7. **Control how many emails you want**\
   Set `maxEmails` (default **20**). This is ideal for testing, budget control, or phased lead building.

8. **Run and review logs**\
   Start the run and watch execution logs for progress, resilience behavior, and completion status.

9. **Open the dataset results**\
   After the run finishes, open the dataset **X (Twitter) Email Data** → view **Scraped Emails**. Export the dataset to JSON/CSV from the dataset UI as needed.

No coding required — get accurate results in minutes with **Twitter Profile Email Search**. 🔥

***

### ⚙️ Advanced features & SEO optimization

- 🔎 **Engineered for “find email from twitter profile” workflows**: Uses your `keywords` plus `emailType` to collect leads suited to your outreach goals (including common “twitter profile contact email” use cases)
- 🌍 **Designed for geo-focused lead lists**: `country` helps you narrow results and improve campaign targeting for “twitter username email lookup” style needs
- 🧰 **Structured output for analysis**: Consistent fields like `email_domain` and `email_type` make it easier to filter, enrich, and segment your “twitter profile email finder” results
- 🛡️ **Reliability improvements**: Includes retries and fallbacks to reduce failed runs and improve extraction consistency
- 🧱 **Practical email collecting cap**: `maxEmails` helps keep your run predictable—useful for “twitter email address verification” style downstream validation workflows

***

### 🎯 Best use cases

- 📈 **Sales teams building outbound lists**: Generate targeted emails for follow-up outreach from “twitter profile contact email” leads, organized by `keyword` and `country`
- 🧑‍💼 **Recruiters sourcing candidates**: Use “lookup twitter user's email” style collection to find public contact emails for roles and collaborations
- 📣 **Marketing teams finding partnership contacts**: Collect “twitter DM email request”-adjacent contacts and segment by `email_type` (B2C vs B2B)
- 🧪 **Data analysts enriching contact databases**: Combine `email_domain`, `email_type`, and `url` for clean lead dataset building and reporting
- 🏢 **B2B lead generation ops**: Run “twitter email search tool” workflows focused on business-style emails via `emailType: "B2B"`
- 🧭 **Market researchers studying niche communities**: Use “extract email address from twitter” results to compare contact availability across keywords and regions
- 💻 **CRM/automation pipelines**: Feed structured dataset exports into your CRM, sequences, or validation jobs using `email` and `email_domain`

***

### 🧠 Technical specifications

- **Supported Input Formats**
  - ✅ `keywords`: array of strings
  - ✅ `country`: string (from the provided enum list)
  - ✅ `emailType`: string (`B2C` or `B2B`)
  - ✅ `maxEmails`: integer (min 1, max 10000)

- **Proxy Support**
  - ✅ Includes proxy support for more reliable scraping runs (built for real-world conditions)

- **Retry Mechanism**
  - ✅ Retries and fallbacks are included to improve resilience during scraping

- **Dataset Structure**
  - ✅ Dataset title: **X (Twitter) Email Data**
  - ✅ View: **Scraped Emails**
  - ✅ Fields: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `country`

- **Rate Limits & Performance**
  - ✅ Designed for batch processing and practical extraction flows
  - ✅ `maxEmails` helps you control run size and cost

- **Limitations**
  - ❌ Results depend on publicly available sources and whether an email is present in the accessible profile data
  - ❌ Not every profile will yield an email address

***

### ❓ FAQ

#### How many emails can I collect with Twitter Profile Email Search?

You can control the maximum number of emails using the `maxEmails` input field. The schema allows values from 1 up to 10000, so you can scale from quick tests to large lead pulls.

#### Is Twitter Profile Email Search limited to a specific type of lead?

You can choose between `emailType` = **B2C** or **B2B**. This lets you align the extraction with your outreach strategy, whether you’re running consumer campaigns or business-focused lead generation.

#### What does the dataset output include?

The dataset output (view **Scraped Emails**) includes fields such as `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, and `country`—so you can analyze and segment leads immediately.

#### Do I need to provide Twitter/X profile URLs directly?

No. The actor is designed to search using your `keywords` input and apply `country` and `emailType` filtering. This makes it useful for “twitter profile email search” workflows without manually assembling profile lists.

#### Can I export the results to other tools?

Yes. The actor saves results in the Apify dataset. From the dataset UI, you can export the data (commonly in formats like JSON/CSV) to use in CRMs, spreadsheets, and analytics workflows.

#### Does this tool access private or protected profiles?

No. **Twitter Profile Email Search** is intended to collect information only from **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content.

#### Can I integrate this into an automated workflow?

Yes. Because the actor produces structured dataset fields like `email` and `email_domain`, it’s well-suited for automated pipelines where you enrich and validate leads before outreach.

***

### 🤝 Support & feature requests

Want to improve **Twitter Profile Email Search** (for example, better CSV export workflows, additional segmentation options, or enhancements to how results are structured)? Share your ideas.

💡 **Feature Requests:** Tell us what would make your “twitter profile email finder” workflow smoother—such as more export formats or additional fields for analysis.

📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback helps shape future improvements to **Twitter Profile Email Search**. 🚀

***

### *Twitter Profile Email Search* — final thoughts

If you’re serious about building targeted lead lists, **Twitter Profile Email Search** gives you a structured, dataset-friendly way to find profile contact emails at scale. 🔍

# 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("scraper-mind/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("scraper-mind/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 scraper-mind/twitter-profile-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Profile Email Scraper By Keyword",
        "description": "Twitter Profile Email Scraper: Extract verified B2B/B2C emails, target by keyword & country, and build high-quality Twitter/X leads instantly. Perfect for marketers, agencies, and growth teams.",
        "version": "1.0",
        "x-build-id": "S3D8QlnJyTfYVhYYw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-mind~twitter-profile-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-mind-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/scraper-mind~twitter-profile-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-mind-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/scraper-mind~twitter-profile-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-mind-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
