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

📧 Twitter Profile Email Scraper extracts email addresses from public Twitter profiles to help power lead gen, B2B outreach, and contact enrichment. ⚡ Fast, accurate, and automation-friendly—perfect for sales, marketing & research teams.

- **URL**: https://apify.com/scraperx/twitter-profile-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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** Email Scraper 📱

The **Twitter** Profile Email Scraper allows you to **extract** valuable **data** from **Twitter** profiles, focusing on publicly available information. It is designed to help users gather essential **contact** details efficiently and accurately.

The tool ensures that only legally accessible **data** is collected, providing a reliable and ethical solution for email **extract**ion. With this scraper, you can **extract** **emails**, profile names, usernames, bio information, and other relevant details from **Twitter** accounts.

It is suitable for various use cases, including lead generation, networking, and market research. The scraper is optimized for large-scale **data** **extract**ion, ensuring fast and accurate results.

By automating the process, it saves users significant time and effort compared to manual **data** collection methods.

Twitter Profile Email Scraper is a powerful tool designed to extract publicly available email addresses from Twitter profiles efficiently and accurately. It helps businesses, marketers, and researchers gather contact information for outreach purposes while saving time and effort.

This Twitter email extraction tool is ideal for automating the process of finding emails from Twitter users, eliminating the need for manual searches. It ensures a seamless and reliable way to scrape emails from Twitter profiles without compromising data quality.

By using the Twitter Profile Email Scraper, you can access valuable contact details from Twitter accounts for networking, lead generation, or market research. It is a reliable and user-friendly solution for extracting essential Twitter profile data.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extract publicly available email addresses from Twitter profiles. |
| Profile Name | Retrieve the full name associated with the Twitter account. |
| Username | Capture the Twitter handle or username of the profile. |
| Bio Information | Extract the bio or description text from Twitter profiles. |
| Location | Scrape the location details if provided on the profile. |
| Website URL | Retrieve any website links shared on the Twitter profile. |
| Profile Picture URL | Extract the URL of the profile's display picture. |
| Follower and Following Count | Capture the number of followers and following for the profile. |

### Key Features of **Twitter** Email Scraper

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

- ⭐ **Automated** extraction of publicly available email addresses from **Twitter** profiles
- ⭐ Supports large-scale data scraping for high-volume projects
- ⭐ User-friendly interface with straightforward setup and execution
- ⭐ **Accurate** data extraction with minimal errors or duplicates
- ⭐ Ability to filter and customize data collection based on specific criteria
- ⭐ **Secure** and compliant with data privacy regulations and ethical guidelines
- ⭐ **Fast** processing speeds to handle bulk data extraction efficiently
- ⭐ Detailed logs and reports for tracking scraping activities and results
- ⭐ Option to export data in multiple formats including CSV and JSON
- ⭐ **Regular** updates to ensure compatibility with **Twitter**s platform changes
- ⭐ Built-in error handling to manage failed requests or incomplete data
- ⭐ **Customizable** scraping parameters to target specific user groups

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

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

1. ✅ **Sign up** or **log in** to your Apify account to access the **Twitter** Profile Email Scraper
2. ✅ Navigate to the scrapers page and click on the **Start** button to begin the configuration process
3. ✅ Enter the list of **Twitter** profile URLs or keywords you want to scrape emails from
4. ✅ Adjust the settings to customize the data extraction process such as filters or limits
5. ✅ **Start** the scraper and monitor the progress in real-time through the Apify console
6. ✅ Wait for the scraper to complete the data extraction process based on your input
7. ✅ Once the scraping is finished download the extracted data in your preferred format such as CSV or JSON
8. ✅ **Review** the collected data to ensure accuracy and completeness before using it for your intended purpose
9. ✅ If needed adjust the settings and rerun the scraper for additional data extraction
10. ✅ Use the extracted data for lead generation marketing campaigns or other use cases
11. ✅ Refer to the documentation or contact support if you encounter any issues during the process
12. ✅ Log out of your Apify account once you have completed your data extraction tasks

### Use Cases 🎯

Lead Generation
🎯 Extract emails from **Twitter** users to build targeted email lists for marketing campaigns
🎯 **Identify** potential clients or collaborators by gathering contact details from relevant profiles

Market Research
🎯 **Analyze** **Twitter** profiles to understand user demographics and preferences
🎯 Gather data for competitor analysis or industry trends

Networking and Outreach
🎯 **Find** contact information of influencers or professionals for collaboration opportunities
🎯 Streamline outreach efforts by accessing emails directly from **Twitter** profiles

Content Personalization
🎯 **Use** extracted data to tailor content or offers for specific audiences
🎯 Enhance customer engagement by understanding user interests through profile analysis

### Why choose us? 💎

Our **Twitter** Profile Email Scraper stands out as a **reliable** and efficient tool for extracting publicly available email addresses from **Twitter** profiles. It is designed to save time and effort by automating the data collection process while ensuring accuracy and compliance.

The scraper is equipped with **advanced** features, such as customizable filters, error handling, and fast processing speeds, making it the **best** **Twitter** email scraper for professionals and businesses. We prioritize user experience by providing a **user-friendly** interface and detailed documentation to guide you through the process.

Our tool is **regular**ly updated to adapt to changes in **Twitter**'s platform, ensuring uninterrupted performance. Whether you are a marketer, researcher, or business owner, our scraper offers a **scalable** and secure solution for your data extraction needs.

By choosing our tool, you gain access to a **reliable** **Twitter** email finder tool that delivers high-quality results for various use cases.

### **Twitter** Email Scraper Scalability 📈

The **Twitter** Profile Email Scraper is designed to handle data extraction tasks of any scale, from small projects to large enterprise-level operations. It supports bulk scraping, allowing you to process thousands of **Twitter** profiles **efficient**ly.

The tool's **advanced** architecture ensures fast processing speeds without compromising accuracy or data quality. Whether you need to scrape emails from a few profiles or an **extensive** list, our scraper adapts to your requirements **seamless**ly.

It also offers **customizable** settings to target specific user groups or filter data based on your criteria. With its robust infrastructure, the scraper can manage high volumes of requests while maintaining stability and performance.

This scalability makes it an ideal choice for businesses, researchers, and marketers looking to extract **Twitter** profile data at scale.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you only extract publicly available email addresses from **Twitter** profiles
⚖️ **Do not** use the scraper to collect private or sensitive information without consent
⚖️ Comply with **Twitter**s terms of service and data usage policies when using the tool
⚖️ **Avoid** using the scraper for spamming or other unethical practices
⚖️ Respect the privacy of **Twitter** users and do not misuse the extracted data
⚖️ Verify the legality of data scraping in your jurisdiction before using the tool
⚖️ **Use** the extracted data responsibly and only for legitimate purposes
⚖️ Regularly review and update your practices to ensure compliance with relevant laws and regulations

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Twitter Profile Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Twitter",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails 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": "Twitter Profile Email 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",
    "email": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

#### What is the Twitter Profile **Email Scraper**?

The Twitter Profile Email Scraper is a tool designed to extract **publicly available** email addresses and other data from Twitter profiles efficiently.

#### Is it **legal** to scrape emails from Twitter profiles?

Scraping **publicly available** data is generally legal, but you must comply with Twitter's terms of service and local laws.

#### What data can I **extract** using this tool?

You can extract email addresses, profile names, usernames, bio information, location, website URLs, profile picture URLs, and follower counts.

#### How do I use the Twitter Profile **Email Scraper**?

Simply provide the Twitter profile URLs or keywords, configure the settings, and start the scraper to extract the data.

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

**No**, the scraper only extracts data from publicly accessible Twitter profiles.

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

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

#### Is the scraper compatible with **large-scale** data **extract**ion?

**Yes**, the scraper is designed to handle bulk data extraction efficiently and accurately.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Twitter's platform changes and maintain performance.

#### Can I customize the data **extract**ion process?

**Yes**, you can adjust settings such as filters and limits to customize the scraping process.

#### What should I do if I encounter issues with the scraper?

Refer to the documentation or contact support for assistance with any technical issues.

#### Is the Twitter Profile **Email Scraper** **secure** to use?

**Yes**, the scraper is designed with security measures to ensure safe and compliant data extraction.

#### Can I use the scraper for **lead generation**?

**Yes**, the tool is ideal for extracting **emails** and other data for lead generation purposes.

#### Does the scraper store the **extract**ed data?

**No**, the data is only stored temporarily for your access and can be downloaded **secure**ly.

#### What are the ethical guidelines for using this tool?

Use the scraper responsibly, avoid spamming, and respect user privacy by adhering to ethical practices.

#### Can I scrape data from hashtags or keywords?

**Yes**, you can configure the scraper to target profiles based on hashtags or keywords.

# 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("scraperx/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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Profile Email Scraper",
        "description": "📧 Twitter Profile Email Scraper extracts email addresses from public Twitter profiles to help power lead gen, B2B outreach, and contact enrichment. ⚡ Fast, accurate, and automation-friendly—perfect for sales, marketing & research teams.",
        "version": "0.1",
        "x-build-id": "f6rCa5lwuSzjkJ8Nf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~twitter-profile-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-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/scraperx~twitter-profile-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-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/scraperx~twitter-profile-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-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"
                ],
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```