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

📧 Instacart Email Scraper extracts email addresses from Instacart listings to streamline outreach. 🚀 Perfect for lead generation, B2B sales, and market research—fast, efficient, and easy to use.

- **URL**: https://apify.com/scrapeengine/instacart-email-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **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

### **Instacart** Email Scraper 📱

The **Instacart** Email Scraper allows you to **extract** a variety of **data** points from the **Instacart** platform. This tool is designed to gather customer email addresses, which can be used for marketing, customer relationship management, and analytics.

You can also **extract** supplementary **data** such as customer names, order details, and timestamps to provide context to the collected **emails**. The **extract**ed **data** is organized and delivered in a structured format, ensuring easy integration into your existing systems.

With this tool, businesses can gain access to valuable insights and improve their outreach strategies. It is a versatile solution for **extract**ing **data** from grocery apps like **Instacart** while maintaining high accuracy and efficiency.

Instacart Email Scraper is a powerful tool designed to help businesses extract valuable email data from the Instacart platform efficiently. This tool is ideal for companies looking to streamline their customer outreach and marketing efforts.

With the Instacart Email Scraper, you can automate the process of gathering customer emails from Instacart, saving time and resources. It is a reliable solution for businesses aiming to enhance their data-driven strategies.

This Instacart data extraction tool is tailored for marketers, researchers, and businesses seeking to extract Instacart customer emails seamlessly. It ensures accurate and secure data collection for various use cases.

### 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 |
| --- | --- |
| Customer Emails | Extract email addresses of Instacart users for outreach and marketing purposes. |
| Customer Names | Retrieve names associated with the email addresses for personalized communication. |
| Order Details | Collect information about customer orders, including items purchased and quantities. |
| Order Timestamps | Capture the date and time of customer orders for better analysis. |
| User Locations | Extract location data to understand geographic distribution of customers. |
| Shopper Emails | Scrape emails of Instacart shoppers for recruitment or engagement purposes. |
| Marketing Preferences | Identify user preferences for targeted marketing campaigns. |
| Account Status | Retrieve account activity status to filter active users. |

### 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** extraction of customer and shopper emails from **Instacart**
- ⭐ **High**ly accurate data scraping with minimal errors or duplicates
- ⭐ **Customizable** scraping parameters to fit specific business needs
- ⭐ **Secure** and compliant data collection methods to protect user privacy
- ⭐ Ability to extract supplementary data such as names locations and order details
- ⭐ User-friendly interface for easy setup and operation
- ⭐ **Fast** data processing to handle large volumes efficiently
- ⭐ Export data in multiple formats for seamless integration with other tools
- ⭐ **Regular** updates to ensure compatibility with **Instacart**s platform changes
- ⭐ 247 customer support to assist with any technical issues

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

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

1. ✅ **Sign up** for an account on our platform to access the **Instacart** Email Scraper
2. ✅ Log in to your account and navigate to the **Instacart** Email Scraper dashboard
3. ✅ Enter the specific parameters for your data extraction such as location or date range
4. ✅ Connect your **Instacart** account or provide the necessary access credentials
5. ✅ **Select** the data types you wish to extract such as customer emails or order details
6. ✅ **Start** the scraping process by clicking the Run button on the dashboard
7. ✅ Monitor the progress of the data extraction through the real-time status updates
8. ✅ Once the scraping is complete download the extracted data in your preferred format
9. ✅ **Review** the collected data for accuracy and completeness before using it
10. ✅ **Integrate** the data into your CRM or marketing tools to begin leveraging insights

### Use Cases 🎯

Marketing Campaign Optimization
🎯 Extract **Instacart** customer emails for targeted email marketing campaigns
🎯 **Identify** customer preferences to personalize promotional offers
🎯 **Analyze** order history to create tailored marketing strategies

Customer Relationship Management
🎯 Gather customer emails and names to build a comprehensive CRM database
🎯 Segment users based on location or purchasing behavior for better engagement
🎯 Improve customer retention by understanding shopping patterns

Market Research and Analysis
🎯 Extract data to analyze customer demographics and shopping trends
🎯 **Identify** high-demand products and popular shopping locations
🎯 **Use** data insights to refine product offerings and services

Business Expansion Strategies
🎯 Leverage shopper emails to recruit new delivery personnel in specific areas
🎯 Understand geographic trends to expand into new markets effectively
🎯 **Use** email data to communicate with potential partners or collaborators

### Why choose us? 💎

Our **Instacart** Email Scraper is designed with precision and reliability to meet the needs of businesses of all sizes. We prioritize data accuracy, ensuring that the emails and supplementary data you extract are error-free and ready for use.

Our tool is customizable, allowing you to tailor the scraping process to your specific requirements, whether you need customer emails, order details, or shopper information. We also ensure that our software complies with ethical data usage standards, giving you peace of mind while collecting data.

With a **user-friendly** interface and robust customer support, our email scraping software for **Instacart** is easy to use, even for those with limited technical expertise. Additionally, our tool is **regular**ly updated to stay compatible with changes to the **Instacart** platform, ensuring uninterrupted service.

By choosing us, you gain a **reliable** partner in your data-driven business endeavors, helping you achieve your goals efficiently and effectively.

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

The **Instacart** Email Scraper is built to handle data extraction tasks of any scale, making it suitable for both small businesses and large enterprises. Whether you need to scrape a few hundred emails or process thousands of records, our tool can adapt to your requirements **seamless**ly.

It is optimized for speed and efficiency, ensuring that even **large-scale** scraping tasks are completed in a timely manner. Our software is designed to minimize server load and maximize performance, allowing you to scale your data collection efforts without compromising quality.

Additionally, our tool supports batch processing and **advanced** filtering options, enabling you to extract only the data you need. With robust infrastructure and regular updates, the **Instacart** Email Scraper is a scalable solution for businesses looking to grow and expand their data-driven strategies.

### **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** that you have the necessary permissions before scraping data from **Instacart**
⚖️ **Use** the **Instacart** Email Scraper in compliance with **Instacart**s terms of service
⚖️ **Do not** use the tool to collect sensitive or personal data without proper authorization
⚖️ **Avoid** using the extracted data for spamming or unethical marketing practices
⚖️ **Ensure** that all data collection activities comply with applicable data protection laws such as GDPR or CCPA
⚖️ Inform users and obtain consent if required by law before using their data for marketing purposes
⚖️ Regularly review and update your data handling practices to maintain compliance with legal standards
⚖️ **Do not** share or sell the extracted data to unauthorized third parties

### 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 customer and shopper **emails**, along with other relevant data, from the Instacart platform.

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

The tool automates the process of collecting data by connecting to the Instacart platform and extracting specified information.

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

**Yes**, the tool features a **user-friendly** interface and straightforward setup process, making it accessible to users of all technical levels.

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

You can extract customer **emails**, names, order details, timestamps, shopper **emails**, and more.

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

**Yes**, our tool uses **secure** methods to ensure the protection of data during the extraction process.

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

**Yes**, the scraper allows you to set specific parameters such as location, date range, and data types to be extracted.

#### Is the Instacart **Email Scraper** compliant with **legal** regulations?

**Yes**, the tool is designed to comply with data protection laws like GDPR and CCPA when used responsibly.

#### What formats can I **export** the data in?

You can export the extracted data in various formats, including **CSV** and **JSON**, for easy integration with other tools.

#### Does the tool support **large-scale** data scraping?

**Yes**, the Instacart Email Scraper is built to handle both small and large-scale data extraction tasks efficiently.

#### What kind of support do you offer?

We provide 24/7 customer support to assist with any technical issues or questions you may have.

#### Can I use this tool for other platforms?

**No**, this tool is specifically designed for scraping data from the Instacart platform.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with changes to the Instacart platform.

#### Is there a free trial available?

**Yes**, we offer a free trial so you can test the tool before committing to a subscription.

#### Can I scrape data in real-time?

**Yes**, the Instacart Email Scraper supports real-time data extraction for up-to-date information.

#### What happens if I encounter issues while using the tool?

You can contact our 24/7 support team for assistance with any issues or questions.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instacart Email Scraper",
        "description": "📧 Instacart Email Scraper extracts email addresses from Instacart listings to streamline outreach. 🚀 Perfect for lead generation, B2B sales, and market research—fast, efficient, and easy to use.",
        "version": "0.1",
        "x-build-id": "vVshU8dmAJy3Aitkf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~instacart-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-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/scrapeengine~instacart-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-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/scrapeengine~instacart-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```