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

- **URL**: https://apify.com/scrapapi/target-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 enables users to **extract** valuable email **data** from the **Target** website with ease. This tool is designed to identify and retrieve email addresses from various sections of the website, ensuring comprehensive **data** collection.

Users can **extract** **emails** associated with customer inquiries, business **contact**s, and other relevant sources. The scraper ensures that the **data** is accurate and up-to-date, providing reliable information for marketing and lead generation.

With its automation capabilities, the tool minimizes manual effort and maximizes efficiency. Whether you need a targeted email list builder or an email **extract**or for businesses, this tool is designed to meet your needs.

It is suitable for email scraping for marketing campaigns, customer outreach, or building a **data**base of potential leads. By using this email **data** **extract**ion software, you can save time and focus on growing your business.

Target Email Scraper is a powerful tool designed to help businesses extract email addresses from the Target website efficiently and accurately. It is an essential resource for companies seeking to build targeted email lists for marketing and lead generation purposes.

With the rise of email marketing, having access to reliable email scraping tools like Target Email Scraper can give businesses a competitive edge. This tool simplifies the process of collecting email data from Target, saving time and effort.

Target Email Scraper leverages advanced automation to ensure that the data extraction process is both fast and precise. It is ideal for businesses looking to enhance their email marketing campaigns with verified contact information.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses from various sections of the Target website. |
| Contact names | Retrieve names associated with email addresses for personalized communication. |
| Business categories | Identify the categories or industries associated with the extracted emails. |
| Location details | Extract location-based information linked to email contacts. |
| Customer inquiries | Gather email data from customer inquiry sections for follow-ups. |
| Marketing leads | Collect email addresses of potential leads for targeted marketing campaigns. |
| Social media links | Identify and extract social media profiles connected to email addresses. |
| Phone numbers | Retrieve phone numbers associated with email contacts, if available. |

### 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
- ⭐ **Accurate** and up-to-date email address retrieval from **Target**
- ⭐ User-friendly interface requiring no technical expertise
- ⭐ Capability to extract multiple data types including names and locations
- ⭐ **Customizable** scraping options for targeted email list building
- ⭐ **Fast** processing speed for large-scale email data extraction
- ⭐ **Integration** with marketing tools for seamless workflow
- ⭐ **Secure** and compliant data scraping processes
- ⭐ Detailed reporting and export options in various formats
- ⭐ 247 customer support for troubleshooting and assistance
- ⭐ **Regular** updates to ensure compatibility with **Target**s website
- ⭐ 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. ✅ Log in to your Apify account or sign up if you are a new user
2. ✅ Search for the **Target** Email Scraper in the Apify Actors library
3. ✅ Click on the scraper and review its details and requirements
4. ✅ **Configure** the scraper by entering the necessary parameters such as target URLs
5. ✅ Set up any filters or preferences for the data you wish to extract
6. ✅ Run the scraper and monitor its progress in real-time on the dashboard
7. ✅ Once the scraping process is complete download the extracted data in your preferred format
8. ✅ **Review** the data and integrate it into your marketing or lead generation tools
9. ✅ If needed adjust the settings and rerun the scraper for additional data
10. ✅ Contact Apify support if you encounter any issues during the process

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Enhance customer outreach with verified email contacts

Lead Generation
🎯 **Identify** potential customers by extracting relevant email addresses
🎯 Streamline the process of building a database of leads

Business Networking
🎯 Connect with businesses and professionals through extracted emails
🎯 Expand your network with accurate contact information

Customer Support
🎯 Retrieve customer inquiry emails for better service
🎯 Follow up with customers using accurate email data

### Why choose us? 💎

**Target** Email Scraper is designed to provide businesses with a **reliable** and efficient solution for email data extraction. Our tool is built with **advanced** automation features, ensuring fast and accurate results.

By using our scraper, you can save time and focus on growing your business instead of manually collecting email addresses. We prioritize user-friendliness, making it accessible to both technical and non-technical users.

Our solution is equipped with robust data security measures, ensuring compliance with legal and ethical standards. Whether you are looking to build a targeted email list or enhance your marketing efforts, our scraper is tailored to meet your needs.

We offer **regular** updates to ensure compatibility with the **Target** website, so you can rely on our tool for consistent performance. With 24/7 customer support, we are committed to providing assistance whenever you need it.

Choose **Target** Email Scraper for a seamless and effective email scraping experience.

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

**Target** Email Scraper is designed to handle data extraction needs of all sizes, making it suitable for small businesses and large enterprises alike. Its scalable architecture allows you to extract email data from a few pages or the entire **Target** website, depending on your requirements.

The tool's automation capabilities ensure that it can process large volumes of data **efficient**ly without compromising accuracy. Whether you need to build a small targeted email list or extract **extensive** data for a comprehensive marketing campaign, our scraper can adapt to your needs.

With **customizable** settings, you can scale your data extraction efforts as your business grows. Our solution is built to handle high-demand scenarios, ensuring reliable performance even during peak usage.

By choosing **Target** Email Scraper, you can confidently scale your email scraping efforts to match your business objectives.

### **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 when using the scraper
⚖️ **Do not** use the scraper to collect personal data without consent
⚖️ **Adhere** to data protection laws such as GDPR and CCPA during data extraction
⚖️ **Use** the extracted data responsibly and only for legitimate business purposes
⚖️ **Avoid** scraping sections of the website that require authentication or special permissions
⚖️ Regularly review and update your scraping practices to align with legal standards
⚖️ Respect the privacy of individuals when using the extracted email data
⚖️ Consult legal counsel 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 other related data from the Target website efficiently.

#### Who can use Target **Email Scraper**?

It is suitable for **businesses**, marketers, and professionals looking to build targeted email lists or enhance lead generation.

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

**Yes**, it features a **user-friendly** interface that requires no technical expertise.

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

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

#### How do I download the **extract**ed data?

You can download the data in various formats, such as **CSV** or **JSON**, directly from the Apify dashboard.

#### Is the scraper compliant with data protection laws?

**Yes**, it is designed to adhere to laws like GDPR and CCPA when used responsibly.

#### Can I customize the scraping process?

**Yes**, you can configure filters and preferences to tailor the data extraction to your needs.

#### Does the scraper work on all sections of the Target website?

It works on publicly accessible sections but avoids areas requiring authentication.

#### How often is the scraper updated?

The scraper is regularly updated to ensure compatibility with changes to the Target website.

#### What support is available if I encounter issues?

We offer 24/7 customer support to assist with any problems you may face.

#### Can I use the scraper for **large-scale** data **extract**ion?

**Yes**, it is scalable and can handle **large volumes** of data efficiently.

#### Is there a free trial available?

Please check the Apify platform for details on free trial availability.

#### How **secure** is the data **extract**ion process?

The scraper employs robust security measures to ensure data is extracted safely and ethically.

#### Can I integrate the **extract**ed data with other tools?

**Yes**, the data can be easily integrated with marketing and lead generation tools.

#### What happens if Target changes its website structure?

Our team provides updates to ensure the scraper remains functional with any changes.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Email Scraper",
        "version": "0.1",
        "x-build-id": "aRHbcwmskDbaJ7gvd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~target-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~target-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~target-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```