# Instacart Email Scraper (`api-empire/instacart-email-scraper`) Actor

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

- **URL**: https://apify.com/api-empire/instacart-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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

### **Instacart** Email Scraper 📱

The **Instacart** Email Scraper allows you to **extract** a variety of **data** types from **Instacart**, enabling you to gather valuable insights and **contact** information. This tool is specifically designed to help you collect **emails** and other related **data** for marketing, research, or customer engagement purposes.

By using the **Instacart** **data** **extract**ion tool, you can efficiently compile an **Instacart** email list without manual effort. The scraper is capable of handling large volumes of **data** while maintaining accuracy and compliance with ethical guidelines.

Whether you need to **extract** **emails** for targeted campaigns or analyze customer **data**, this tool provides a reliable solution for your needs.

Instacart Email Scraper is a powerful tool designed to help you extract email addresses and other relevant data from Instacart efficiently. It is the best Instacart scraping tool for businesses and individuals looking to streamline their data collection processes.

With this automated Instacart email scraper, you can save time and effort by collecting valuable contact information in just a few clicks. This tool is ideal for generating an Instacart email list for marketing or research purposes.

The Instacart data extraction tool is built to handle large-scale data scraping while maintaining accuracy and compliance. It ensures that you can extract emails from Instacart without compromising on quality or speed.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract verified email addresses of customers or businesses listed on Instacart. |
| Usernames | Retrieve usernames associated with Instacart accounts for better identification. |
| Contact names | Collect names linked to email addresses for personalized communication. |
| Business details | Gather details about businesses listed on Instacart, including names and locations. |
| Profile links | Extract links to user or business profiles for further exploration. |
| Customer reviews | Scrape customer reviews to analyze feedback and sentiment. |
| Product data | Retrieve information about products listed on Instacart, such as names and prices. |
| Order history | Access historical order data for research or analysis purposes. |

### Key Features of **Instacart** Email Scraper

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

- ⭐ **Automated** data extraction to save time and effort
- ⭐ User-friendly interface suitable for all experience levels
- ⭐ **High** accuracy in extracting verified email addresses
- ⭐ Ability to handle large-scale data scraping tasks efficiently
- ⭐ **Customizable** scraping options to meet specific needs
- ⭐ Compliant with ethical and legal data collection guidelines
- ⭐ **Fast** processing speeds for quick data retrieval
- ⭐ **Secure** scraping process to protect user data and privacy
- ⭐ **Regular** updates to ensure compatibility with **Instacart**
- ⭐ Detailed documentation and support for seamless usage
- ⭐ Export data in multiple formats for easy integration
- ⭐ **Advanced** filtering options to refine extracted data

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

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

1. ✅ **Sign up** for the **Instacart** Email Scraper tool on our platform
2. ✅ Log in to your account and navigate to the scraper dashboard
3. ✅ Enter the specific **Instacart** URLs or keywords you want to scrape
4. ✅ Customize your scraping preferences such as data types and filters
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraper in real time on the dashboard
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 email list for marketing research or analysis
10. ✅ Repeat the process as needed for additional data collection

### Use Cases 🎯

Marketing Campaigns
🎯 Generate targeted email lists for promotional campaigns
🎯 Reach out to potential customers with personalized offers

Customer Research
🎯 **Analyze** customer data to identify trends and preferences
🎯 Gather insights from customer reviews and feedback

Business Outreach
🎯 **Collect** contact information for B2B communication
🎯 Build a database of potential business partners or clients

Product Analysis
🎯 Extract product data to compare prices and features
🎯 Monitor competitor products listed on **Instacart**

### Why choose us? 💎

The **Instacart** Email Scraper is the **best** **Instacart** scraping tool for businesses and individuals seeking **reliable** and efficient data extraction. Our tool is designed with user-friendliness in mind, making it accessible to both technical and non-technical users.

We prioritize accuracy and compliance, ensuring that all extracted data is **reliable** and ethically sourced. With **advanced** features like customizable scraping options and secure data handling, our software stands out as the top choice for **Instacart** email harvesting.

Our team is committed to providing **regular** updates and dedicated support to enhance your experience. Whether you need to extract emails from **Instacart** for marketing, research, or analysis, our tool offers a comprehensive solution tailored to your needs.

Choose us for a seamless, efficient, and secure data scraping experience that delivers results.

### **Instacart** Email Scraper Scalability 📈

The **Instacart** Email Scraper is built to handle data extraction tasks of any size, making it suitable for both small businesses and large enterprises. Our tool is optimized for scalability, allowing you to scrape large volumes of data without compromising on speed or accuracy.

Whether you need to extract a few hundred emails or compile an **extensive** database, our software can accommodate your requirements. The automated **Instacart** email scraper ensures consistent performance even during high-demand tasks.

With **advanced** filtering and export options, you can easily manage and utilize the data you collect. Our scalable solution grows with your needs, providing the flexibility and reliability you need for long-term success.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Instacart**s terms of service when using the scraper
⚖️ **Do not** use the tool to collect data for illegal or unethical purposes
⚖️ **Obtain** proper consent before contacting individuals from the extracted email list
⚖️ **Avoid** scraping sensitive or personal information beyond what is publicly available
⚖️ **Use** the scraper responsibly to prevent overloading **Instacart**s servers
⚖️ **Adhere** to data protection regulations such as GDPR and CCPA when handling scraped data
⚖️ **Do not** resell or distribute the extracted data without proper authorization
⚖️ Regularly review and update your scraping practices to align with legal requirements

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is the Instacart **Email Scraper**?

The Instacart Email Scraper is a tool designed to extract email addresses and other data from Instacart efficiently.

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

**Yes**, the tool features a **user-friendly** interface suitable for users of all experience levels.

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

You can extract email addresses, usernames, contact names, business details, profile links, and more.

#### Is the scraper compliant with **legal** guidelines?

**Yes**, the scraper is designed to ensure **compliance** with data protection regulations and ethical guidelines.

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

**Yes**, the scraper allows you to customize scraping preferences such as data types and filters.

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

You can export the data in multiple formats, including **CSV** and **JSON**, for easy integration.

#### Is the tool suitable for **large-scale** data scraping?

**Yes**, the Instacart Email Scraper is optimized for scalability and can handle **large volumes** of data efficiently.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Instacart and to add new features.

#### Can I use this tool for marketing purposes?

**Yes**, the tool is ideal for generating targeted email lists for marketing campaigns.

#### Is **customer support** available?

**Yes**, our team provides **dedicated support** to assist you with any issues or questions.

#### What are the system requirements for using the scraper?

The scraper is web-based and does not require any specific system requirements.

#### Can I scrape product data from Instacart?

**Yes**, the scraper allows you to extract product data such as names and prices.

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

**Yes**, the scraper ensures a **secure** data extraction process to protect user data and privacy.

#### How long does it take to scrape data?

The time required depends on the volume of data being scraped but is generally fast and efficient.

#### Can I try the tool before purchasing?

**Yes**, a free trial or demo version is available to help you evaluate the tool.

# Actor input Schema

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

List of keywords to search for on Instacart (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Instacart 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": "Instacart",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/instacart-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/instacart-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/instacart-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instacart Email Scraper",
        "description": "Automate email extraction from Instacart with Instacart Email Scraper. The actor scans store and product pages and pulls available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "iObkHaBdmHM1HyhoT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~instacart-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-instacart-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/api-empire~instacart-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-instacart-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/api-empire~instacart-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-instacart-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 Instacart (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Instacart profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Instacart"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instacart"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```