# Target Email Scraper (`api-empire/target-email-scraper`) Actor

Automate email extraction from Target with Target Email Scraper. The actor scans store or brand pages and pulls available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/target-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 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

### **Target** Email Scraper 📱

**Target** Email Scraper enables users to **extract** various types of **data** from **Target**'s website with precision and speed. This tool is designed to harvest email addresses and associated information for marketing and outreach purposes.

It supports bulk email scraping to gather large amounts of **data** efficiently. The scraper can identify and **extract** structured **data** such as names, email addresses, and additional **contact** details.

Users can automate email scraping processes to save time and focus on strategic tasks. **Target** Email Scraper ensures accurate **data** **extract**ion while adhering to ethical practices and legal guidelines.

It is a comprehensive solution for businesses looking to enhance their email scraping automation capabilities.

Target Email Scraper is a powerful tool designed to extract email addresses from Target's website efficiently and accurately. It simplifies the process of email scraping for marketing and outreach purposes.

By using Target Email Scraper, businesses can streamline their email address harvesting efforts and access valuable contact information. This tool is ideal for bulk email scraping and automation needs.

With advanced email scraping tools, Target Email Scraper ensures precise data extraction while maintaining compliance with legal guidelines. It is one of the best email scraping tools available for targeted campaigns.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses listed on Target's website for outreach and marketing purposes. |
| Names | Scrape names associated with email addresses for personalized communication. |
| Contact Details | Gather additional contact information such as phone numbers, if available. |
| Business Information | Extract business-related data linked to email addresses for B2B campaigns. |
| Social Media Links | Identify and collect social media profiles connected to contact information. |
| Location Details | Scrape location-based data tied to email addresses for targeted outreach. |
| Job Titles | Extract professional titles associated with contact information for segmentation. |
| Website Links | Gather links to associated websites for additional context and verification. |

### Key Features of **Target** Email Scraper

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

- ⭐ **Automated** email scraping for efficient data extraction from **Target**s website
- ⭐ Supports bulk email scraping to gather large quantities of contact information quickly
- ⭐ **Advanced** filtering options to refine extracted data based on specific criteria
- ⭐ **Accurate** data harvesting ensures high-quality email addresses for marketing campaigns
- ⭐ User-friendly interface simplifies the process of scraping emails from websites
- ⭐ Compliance with legal guidelines ensures ethical email scraping practices
- ⭐ **Integration** capabilities with email scraper software and other tools for seamless workflows
- ⭐ **Customizable** scraping settings allow users to tailor data extraction to their needs
- ⭐ Real-time data extraction delivers up-to-date contact information for outreach
- ⭐ **Secure** and reliable scraper software protects user data during the extraction process
- ⭐ Detailed reports and analytics provide insights into harvested data for strategic use
- ⭐ Scalable solution for businesses of all sizes looking to automate email scraping

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

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

1. ✅ Install the **Target** Email Scraper software on your device
2. ✅ Launch the scraper and configure the settings according to your requirements
3. ✅ Enter the **Target** website URL or specific pages to scrape emails from
4. ✅ Define the data types you want to extract such as email addresses or names
5. ✅ Set filters to refine the scraping process and focus on relevant information
6. ✅ **Start** the scraping process and monitor progress through the user interface
7. ✅ **Review** the extracted data once the scraping is complete
8. ✅ **Export** the harvested data in your preferred format for further use
9. ✅ **Integrate** the extracted data with your email marketing tools or CRM software
10. ✅ Repeat the process as needed for additional pages or updated information
11. ✅ Ensure compliance with legal guidelines when using the extracted data
12. ✅ Contact support if you encounter any issues during the scraping process

### Use Cases 🎯

Marketing Campaigns
🎯 Extract email addresses for targeted email marketing campaigns
🎯 Harvest contact details for personalized outreach and engagement

Lead Generation
🎯 Gather potential leads by scraping emails from **Target**s website
🎯 **Identify** key contacts for B2B lead generation efforts

Data Analysis
🎯 **Analyze** harvested email addresses for trends and segmentation
🎯 **Use** extracted data to refine marketing strategies and audience targeting

Customer Outreach
🎯 Build a database of customer email addresses for communication
🎯 Enhance customer engagement through personalized email campaigns

Competitor Research
🎯 Extract business-related data for competitive analysis
🎯 **Identify** key contacts and strategies used by competitors

### Why choose us? 💎

**Target** Email Scraper is a **reliable** and efficient solution for email address harvesting and marketing outreach. It simplifies the process of extracting contact information from **Target**'s website, saving time and resources for businesses.

With **advanced** automation capabilities, this tool supports bulk email scraping to gather large amounts of data quickly. It ensures accurate and high-quality data extraction, making it one of the **best** email scraping tools available.

Our scraper software is designed with **user-friendly** features to enhance the experience for marketers and professionals. We prioritize compliance with legal guidelines to ensure ethical email scraping practices.

**Target** Email Scraper is **scalable** and customizable, catering to the needs of businesses of all sizes. By choosing us, you gain access to a powerful tool that integrates seamlessly with your existing workflows.

Our solution is ideal for businesses looking to automate email scraping for marketing and lead generation purposes.

### **Target** Email Scraper Scalability 📈

**Target** Email Scraper is designed to handle data extraction tasks of varying scales, making it suitable for businesses of all sizes. Whether you need to scrape a few email addresses or gather bulk data, our tool ensures **efficient** and accurate results.

The scraper software supports automation, allowing users to extract large quantities of data without manual intervention. It offers **customizable** settings to adapt to specific business needs and data requirements.

**Target** Email Scraper is built to process high volumes of data while maintaining speed and reliability. Our solution is ideal for businesses looking to scale their email scraping efforts for marketing and outreach.

With **advanced** features and integration capabilities, **Target** Email Scraper provides a scalable and robust solution for long-term use.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with data protection laws such as GDPR when using **Target** Email Scraper
⚖️ **Do not** use the scraper to extract personal information without proper authorization
⚖️ **Avoid** scraping data for purposes that violate **Target**s terms of service
⚖️ **Use** extracted email addresses responsibly and refrain from sending unsolicited emails
⚖️ Verify the legality of email scraping in your region before using the tool
⚖️ Respect privacy rights and ethical guidelines when harvesting contact information
⚖️ **Obtain** consent from individuals before using their email addresses for marketing purposes
⚖️ Regularly review legal updates to ensure ongoing compliance with data scraping regulations

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Target Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Target",
  "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 (Target) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Target",
    "keyword": "Target 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 Target as the source |
| keyword | Keyword that triggered the result (Target Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Target profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Target **Email Scraper**?

Target Email Scraper is a tool designed to extract email addresses and contact information from Target's website efficiently.

#### How does Target **Email Scraper** work?

It uses automation to scrape **emails** and associated data from Target's website based on user-defined settings.

#### Is Target **Email Scraper** **legal**?

**Yes**, it is legal when used in **compliance** with data protection laws and ethical guidelines.

#### Can I use Target **Email Scraper** for bulk email scraping?

**Yes**, the tool supports bulk email scraping to gather large quantities of data efficiently.

#### What types of data can I **extract**?

You can extract email addresses, names, contact details, business information, and more.

#### Is the tool user-friendly?

**Yes**, Target Email Scraper is designed with a **user-friendly** interface for ease of use.

#### Does it support automation?

**Yes**, the scraper automates the email extraction process to save time and resources.

#### Can I customize the scraping settings?

**Yes**, the tool offers customizable settings to tailor data extraction to your needs.

#### Is the data **extract**ed accurate?

Target Email Scraper ensures accurate and high-quality data extraction for reliable results.

#### Can I **export** the **extract**ed data?

**Yes**, you can export the harvested data in various formats for further use.

#### Does it comply with **legal** guidelines?

**Yes**, the scraper is designed to comply with legal and ethical guidelines for data scraping.

#### What industries can benefit from Target **Email Scraper**?

Industries such as marketing, sales, and research can benefit from using this tool.

#### Is support available for troubleshooting?

**Yes**, support is available to assist users with any issues during the scraping process.

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

**Yes**, you can extract business-related data for competitive analysis and research.

#### How scalable is Target **Email Scraper**?

The tool is scalable and suitable for **businesses** of all sizes, handling tasks of varying scales efficiently.

# Actor input Schema

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

List of keywords to search for on Target (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Target 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": "Target",
  "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("api-empire/target-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("api-empire/target-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 api-empire/target-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Email Scraper",
        "description": "Automate email extraction from Target with Target Email Scraper. The actor scans store or brand pages and pulls available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "mmiuDnZsY4n7Ia1bp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~target-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-target-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/api-empire~target-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-target-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/api-empire~target-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-target-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 Target (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Target profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Target"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Target"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```