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

📧 Target Email Scraper finds targeted email addresses for outreach by extracting from web sources. ✅ Fast, accurate, and SEO-friendly—ideal for B2B lead gen, sales prospecting, and recruitment teams. 🚀

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

### **Target** Email Scraper 📱

**Target** Email Scraper allows you to **extract** a wide range of email-related **data** from the **Target** platform. It is designed to capture email addresses efficiently while ensuring accuracy and relevance.

This tool focuses on targeted email **extract**ion to help businesses and marketers find the right leads for their campaigns. You can also **extract** additional **data** points that provide context and enhance your marketing efforts.

By using this email scraping tool, you can gather bulk email addresses while adhering to legal and ethical guidelines. The **extract**ed **data** is structured and ready for use in your CRM or email marketing software.

This makes it an essential tool for businesses looking to streamline their lead generation process.

Target Email Scraper is a powerful tool designed to extract email addresses from the Target platform efficiently and accurately. It helps businesses and marketers gather valuable contact information for lead generation and outreach campaigns.

Using this email scraping tool, you can automate the process of collecting emails, saving time and effort compared to manual methods. It ensures that you can focus on building relationships rather than spending hours on data collection.

This email extractor software is ideal for businesses looking to expand their customer base or improve their marketing strategies. By extracting emails from websites like Target, you can access a wealth of potential leads quickly and legally.

### 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 addresses | Extract valid email addresses from Target's platform for lead generation. |
| User names | Capture associated names to personalize your outreach efforts. |
| Profile links | Retrieve links to user profiles for additional context. |
| Contact preferences | Identify user preferences for tailored marketing campaigns. |
| Business details | Extract business-related information for B2B marketing. |
| Geolocation data | Gather location-based data to target specific regions. |
| Social media links | Find associated social media profiles for multi-channel outreach. |
| Custom tags | Add tags to categorize and organize extracted data effectively. |

### 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 to save time and effort
- ⭐ **Accurate** and reliable extraction of email addresses
- ⭐ **Customizable** settings for targeted email extraction
- ⭐ Bulk email scraper functionality for large-scale data collection
- ⭐ User-friendly interface suitable for all experience levels
- ⭐ Compliance with legal guidelines for ethical data scraping
- ⭐ **Integration** with CRM and email marketing tools
- ⭐ Detailed data output with structured formats
- ⭐ **Advanced** filtering options to refine results
- ⭐ Real-time data extraction for up-to-date information
- ⭐ **Secure** and private scraping processes
- ⭐ Scalable solution for businesses of all sizes

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

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

1. ✅ **Sign up** for an Apify account if you dont already have one
2. ✅ Navigate to the **Target** Email Scraper in the Apify Store
3. ✅ Click Try for free or Use actor to start the scraping process
4. ✅ **Configure** the scraper settings to define your extraction preferences
5. ✅ Enter the **Target** URLs or search criteria for email scraping
6. ✅ Run the scraper and monitor the progress in the Apify console
7. ✅ Download the extracted data in your preferred format (eg CSV JSON)
8. ✅ Import the data into your CRM or email marketing software for further use
9. ✅ Refine your scraping criteria to improve the quality of results
10. ✅ Schedule automated runs for regular data updates
11. ✅ **Review** the extracted data to ensure accuracy and relevance
12. ✅ Use the data responsibly and in compliance with legal guidelines

### Use Cases 🎯

Lead Generation
🎯 Extract email addresses to build a database of potential customers
🎯 **Identify** leads based on specific criteria like location or industry

Email Marketing
🎯 **Use** extracted emails to send targeted marketing campaigns
🎯 Personalize outreach efforts with additional extracted data

Market Research
🎯 **Analyze** email data to understand customer demographics
🎯 Gather insights on user preferences and behavior

Business Networking
🎯 **Find** professional contacts for partnerships or collaborations
🎯 Expand your network by reaching out to relevant businesses

Recruitment
🎯 **Identify** potential candidates for job openings
🎯 Reach out to professionals with tailored recruitment emails

### Why choose us? 💎

**Target** Email Scraper is the **best** email scraper for businesses looking to streamline their lead generation and marketing efforts. Our tool is designed with user-friendliness and efficiency in mind, making it accessible to users of all experience levels.

We prioritize accuracy and relevance, ensuring that the extracted data meets your specific needs. With **advanced** filtering options and customizable settings, you can target the right audience for your campaigns.

Our email scraping tool also integrates seamlessly with popular CRM and email marketing platforms, saving you time on data management. We are committed to compliance with legal guidelines, so you can use our tool confidently and responsibly.

Whether you're a small business or a large enterprise, **Target** Email Scraper offers a **scalable** solution to meet your data extraction needs. Choose us for a **reliable**, secure, and efficient email scraping experience.

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

**Target** Email Scraper is designed to handle data extraction tasks of any size, making it a scalable solution for businesses of all sizes. Whether you need to scrape a few emails or collect bulk data, our tool can adapt to your requirements.

The automated email scraping process ensures that you can gather large volumes of data without compromising on speed or accuracy. Our **advanced** infrastructure supports high-performance scraping, even for **extensive** datasets.

You can also schedule automated runs to keep your data up-to-date without manual intervention. By offering flexible pricing plans, we make scalability accessible to businesses with varying budgets.

**Target** Email Scraper is the ideal choice for growing businesses that need a reliable and **efficient** email extractor software.

### **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** you have permission to scrape data from the **Target** platform
⚖️ **Use** the extracted data only for legitimate and ethical purposes
⚖️ Comply with all applicable data protection laws such as GDPR or CCPA
⚖️ **Avoid** scraping personal data without the users consent
⚖️ Clearly disclose your intentions when contacting extracted leads
⚖️ **Do not** use scraped data for spamming or malicious activities
⚖️ Regularly review and update your data collection practices to ensure compliance
⚖️ Consult legal professionals if you are unsure about the legality of your scraping activities

### 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 related data from the Target platform for lead generation and marketing purposes.

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

**Yes**, it features a **user-friendly** interface and customizable settings, making it accessible for users of all experience levels.

#### Can I scrape bulk emails with this tool?

**Yes**, Target Email Scraper supports bulk email scraping for large-scale data collection.

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

Our tool is designed to ensure high accuracy and relevance in the extracted data.

#### Does this tool comply with **legal** guidelines?

**Yes**, Target Email Scraper is designed to comply with data protection laws and ethical scraping practices.

#### What formats can I download the data in?

You can download the extracted data in formats like **CSV** or **JSON** for easy integration with other tools.

#### Can I schedule automated runs?

**Yes**, you can schedule **automated** scraping runs to keep your data up-to-date.

#### Is this tool suitable for small businesses?

**Yes**, Target Email Scraper is scalable and suitable for **businesses** of all sizes, including small **businesses**.

#### What additional data can I **extract**?

In addition to email addresses, you can extract user names, profile links, and other contextual data.

#### Is my data **secure** during the scraping process?

**Yes**, we prioritize security and privacy in all scraping processes.

#### Can I integrate this tool with my **CRM**?

**Yes**, the extracted data can be easily integrated with popular CRM and email marketing platforms.

#### What are the pricing plans?

We offer flexible pricing plans to suit **businesses** of all sizes and budgets.

#### How do I ensure compliance while using this tool?

Follow our legal guidelines and consult legal professionals if needed to ensure **compliance**.

#### Can I customize the scraping criteria?

**Yes**, the tool allows you to customize settings for targeted email extraction.

#### What support options are available?

We offer comprehensive support to help you get the most out of Target Email Scraper.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperx/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 finds targeted email addresses for outreach by extracting from web sources. ✅ Fast, accurate, and SEO-friendly—ideal for B2B lead gen, sales prospecting, and recruitment teams. 🚀",
        "version": "0.1",
        "x-build-id": "iN4n9hUd1VntyFekG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~target-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-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/scraperx~target-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-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/scraperx~target-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```