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

Target Email Scraper helps you collect store and brand emails directly from Target listings and profiles. Use the data for B2B sales, retail marketing, and marketplace outreach campaigns.

- **URL**: https://apify.com/scrapio/target-email-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$14.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 📱

The **Target** Email Scraper allows users to **extract** a variety of **data** points from **Target**'s website. This email scraping software is designed to gather essential **contact** information, making it a valuable tool for businesses and researchers.

Users can **extract** **emails**, names, job titles, phone numbers, and other relevant **data**. The scraper is highly customizable, allowing you to specify the type of **data** you need.

It also supports filtering options to ensure you get only the most relevant information. With its automated email scraping capabilities, the tool eliminates the need for manual **data** collection.

This makes it an efficient and time-saving solution for **extract**ing **emails** from **Target**. Whether you need a comprehensive email list or specific **data** points, the **Target** Email Scraper has you covered.

Target Email Scraper is a powerful tool designed to extract email addresses and other contact information from Target's website efficiently. It is an automated email scraping software that helps users gather valuable data for business or research purposes.

With the Target Email Scraper, you can save time and effort by automating the process of extracting emails from websites. This email scraper tool is ideal for businesses, marketers, and researchers looking to streamline their data collection.

Our Target email extractor is user-friendly and designed to deliver accurate results while adhering to ethical guidelines. The software ensures that you can extract emails from Target without compromising data integrity.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses from Target's website for targeted outreach. |
| Names | Collect names associated with email addresses or profiles. |
| Job Titles | Retrieve job titles linked to specific contacts or profiles. |
| Phone Numbers | Extract phone numbers where available for direct communication. |
| Company Information | Gather company names and details associated with contacts. |
| Social Media Links | Identify and extract social media profiles linked to contacts. |
| Location Data | Collect location details such as city and state if available. |
| Custom Fields | Extract additional data fields based on your specific requirements. |

### 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 fast and accurate data collection
- ⭐ **Customizable** filters to target specific data points on **Target**s website
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Supports large-scale data extraction for extensive projects
- ⭐ Ensures compliance with ethical and legal guidelines for data scraping
- ⭐ Provides detailed data output in structured formats like CSV or JSON
- ⭐ Built-in error handling for uninterrupted scraping sessions
- ⭐ **Secure** and reliable email scraping software with regular updates
- ⭐ Compatible with various platforms and operating systems
- ⭐ Offers scalable solutions for both small businesses and large enterprises
- ⭐ Real-time data extraction with minimal manual intervention
- ⭐ **Comprehensive** customer support for troubleshooting and assistance

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

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

1. ✅ Download and install the **Target** Email Scraper software on your device
2. ✅ Launch the application and **log in** with your credentials
3. ✅ Enter the **Target** website URL or specific page URL to scrape data from
4. ✅ **Configure** the scraping settings by selecting the data types you want to extract
5. ✅ Set up filters to narrow down the results based on your requirements
6. ✅ **Start** the scraping process and monitor the progress in real-time
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or JSON
9. ✅ Use the extracted data for your business or research purposes
10. ✅ Repeat the process as needed for additional data extraction tasks
11. ✅ Adjust settings and filters for different scraping projects
12. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Marketing Campaigns
🎯 Extract email addresses for targeted email marketing campaigns
🎯 Gather contact information for lead generation and outreach

Recruitment and Hiring
🎯 **Find** job titles and contact details for potential candidates
🎯 **Collect** professional profiles for recruitment purposes

Market Research
🎯 **Analyze** customer data to understand market trends and preferences
🎯 Extract location data to identify regional customer demographics

Business Development
🎯 Build a database of potential partners or clients from **Target**s website
🎯 **Use** extracted data to establish business connections and collaborations

Academic Research
🎯 Gather data for academic studies or research projects
🎯 Extract information for case studies or reports

### Why choose us? 💎

Our **Target** Email Scraper is designed to provide users with a **reliable** and efficient solution for email scraping. With its **advanced** features and **user-friendly** interface, it is the **best** email scraper for businesses and individuals alike.

The tool is highly customizable, allowing you to tailor the scraping process to your specific needs. We prioritize accuracy and ensure that the extracted data is clean and well-structured.

Our email scraping services are built to save you time and effort, enabling you to focus on your core tasks. The software is secure and **regular**ly updated to meet the latest standards in data scraping technology.

We also offer comprehensive customer support to assist you at every step of the process. Whether you are extracting emails from **Target** for marketing, research, or business development, our tool is the perfect choice.

Choose us for a seamless, **scalable**, and ethical email scraping experience.

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

The **Target** Email Scraper is built to handle data extraction tasks of any scale. Whether you need to scrape a small set of emails or gather **extensive** data for **large-scale** projects, our tool can accommodate your needs.

It is designed to process large volumes of data **efficient**ly without compromising on accuracy. The software supports batch processing, allowing you to extract data from multiple pages or sections of **Target**'s website simultaneously.

With its robust infrastructure, the scraper can handle high workloads and deliver results quickly. Our email scraping software is also optimized for performance, ensuring that it can scale with your growing data collection requirements.

Whether you are a small business or a large enterprise, the **Target** Email Scraper offers the scalability you need to succeed.

### **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 **Target**s terms of service before using the email scraper tool
⚖️ **Use** the **Target** Email Scraper only for lawful and ethical purposes
⚖️ **Avoid** using the scraper to collect data for spamming or unsolicited marketing
⚖️ Respect the privacy of individuals and do not misuse the extracted data
⚖️ **Do not** extract sensitive or confidential information from **Target**s website
⚖️ Verify the accuracy of the extracted data before using it for business purposes
⚖️ **Obtain** necessary permissions if required for data collection activities
⚖️ Regularly review and adhere to relevant data protection laws and 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 the Target **Email Scraper**?

The Target Email Scraper is an **automated** email scraping software designed to extract email addresses and other contact information from Target's website.

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

The scraper uses advanced algorithms to scan Target's website and extract specified data points such as **emails**, names, and phone numbers.

#### Is the Target **Email Scraper** easy to use?

**Yes**, the tool features a **user-friendly** interface that simplifies the setup and data extraction process.

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

**Yes**, the scraper allows you to configure settings and filters to target specific data types and refine results.

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

The extracted data can be exported in formats such as **CSV** or **JSON** for easy integration with other tools.

#### Is the Target **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Target's terms of service and relevant data protection laws, using the scraper is legal.

#### Can the scraper handle **large-scale** data **extract**ion?

**Yes**, the Target Email Scraper is designed for scalability and can process **large volumes** of data efficiently.

#### What kind of **customer support** is available?

We offer comprehensive customer support to assist with setup, troubleshooting, and any other issues you may encounter.

#### Does the scraper work on all devices?

The Target Email Scraper is compatible with various platforms and operating systems for maximum flexibility.

#### How often is the software updated?

The scraper is regularly updated to ensure compatibility with Target's website and to incorporate the latest features.

#### Can I use the scraper for other websites?

The Target Email Scraper is specifically designed for Target's website, but we offer other tools for different platforms.

#### Is the data **extract**ion process **secure**?

**Yes**, the scraper is built with security features to protect your data and ensure a safe extraction process.

#### Are there any **limit**ations on the data I can **extract**?

The scraper allows you to extract **publicly available** data while adhering to ethical and legal guidelines.

#### Do I need technical skills to use the scraper?

**No**, the tool is designed for users of all skill levels, and our support team is available to help if needed.

#### What is the pricing for the Target **Email Scraper**?

Please visit our website or contact our sales team for detailed pricing information.

# 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("scrapio/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("scrapio/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 scrapio/target-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Email Scraper",
        "description": "Target Email Scraper helps you collect store and brand emails directly from Target listings and profiles. Use the data for B2B sales, retail marketing, and marketplace outreach campaigns.",
        "version": "0.1",
        "x-build-id": "9vd7TviUKHEfHFRCY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~target-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~target-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~target-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
