# Instagram Email Scraper (`scraperoka/instagram-email-scraper`) Actor

📧 Instagram Email Scraper extracts emails from public Instagram profiles with speed & accuracy. 🚀 Perfect for lead gen, outreach, and B2B marketing. 🔒 User-friendly & efficient—save time, boost results.

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

## Pricing

from $0.01 / 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

### Instagram Email Scraper ⚡ — Extract Emails from Public Instagram Bios at Scale

Manually visiting Instagram profiles to find contact emails wastes hours you don’t have. **Instagram Email Scraper** streamlines email harvesting from publicly available Instagram bios and posts using your keywords and email-domain filters. This Instagram email extractor helps teams build an Instagram contact email finder list fast—ideal for marketers, recruiters, and growth teams. You can collect thousands of potential contacts in minutes, then export and use the dataset right away.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Instagram.com",
  "keyword": "founder",
  "title": "Marketing leader at Riverstone Co",
  "description": "Riverstone Co | Email: hello@riverstoneco.com | We build growth systems",
  "url": "https://www.example.com/profile/riverstoneco",
  "email": "hello@riverstoneco.com",
  "proxyGroups": [
    "legacy"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network (Instagram.com) for filtering and reporting. |
| `keyword` | string | The keyword that helped surface this contact, so you can track what works. |
| `title` | string | A page result title to help you contextualize the email source. |
| `description` | string | The surrounding snippet text where the email was detected (useful for validation). |
| `url` | string | The source page link tied to the email, so you can review before outreach. |
| `email` | string | The extracted email address you can put into your outreach workflow. |
| `proxyGroups` | array | The proxy configuration used for the scraping run (useful for troubleshooting data quality). |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Instagram Email Scraper?

There are a lot of ways to pull data from Instagram — here’s what sets Instagram Email Scraper apart.

#### Keyword and Domain Targeting 🎯

Instagram Email Scraper finds emails from Instagram bios and posts related to your keywords, then filters results using your custom email domains (for example, targeting `@gmail.com`). This makes it much easier to build an Instagram email list builder that fits your ideal outreach profile.

#### Built for Scaled Email Harvesting 💼

You control the number of emails collected with `maxEmails`, so you can run quick tests or larger jobs without losing control of runtime. For big searches or high email limits, the actor supports longer timeouts via Run Options.

#### Resilient Retrieval with Fallbacks 🔁

If results are sparse or blocked mid-run, the scraper includes resilience features like retries and fallbacks, improving the chance of getting meaningful output. This helps avoid the “empty dataset” problem when you’re relying on Instagram lead scraper emails.

#### Structured, Integration-Ready Output ✅

Every extracted email is pushed as a structured data record including the source URL and the keyword used. That means your Instagram influencer email scraping results are ready for analysis, deduplication steps, and CRM import.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Instagram",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper uses these to locate relevant Instagram bios and posts to extract emails from. |
| `location` | ⬜ | A location filter to narrow where results come from (leave blank to use no location constraint). |
| `platform` | ⬜ | Selects the platform to scrape. This actor supports `Instagram`. |
| `customDomains` | ⬜ | Filters extracted emails by allowed email domains (for example, `@gmail.com`), improving targeting for your outreach lists. |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; the run stops once the limit is reached to control scraping time and cost. |
| `engine` | ⬜ | Choose `cost-effective` or `legacy` engine for scraping. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run (recommended for more reliable scraping at scale). |

***

### Core Capabilities

#### Extracts Emails from Instagram Bios and Posts

Instagram Email Scraper is designed to pull emails found in Instagram bios and posts related to your provided keywords. If you’re building public Instagram emails extraction workflows, this gives you a direct path from keyword targeting to email harvesting from Instagram profiles.

#### Flexible Input for Better Lead Targeting

You can steer results using `keywords`, optionally refine by `location`, and restrict outputs via `customDomains`. This combination is useful for Instagram contact email finder efforts where only certain domains (like `@gmail.com`) should be included.

#### Controlled Volume with `maxEmails`

Set `maxEmails` to decide how many emails you want to collect per run. This helps you test new keyword sets quickly and then scale up for larger lead sourcing when you see strong results.

#### Engine Choice for Cost vs. Reliability

The actor provides an `engine` setting so you can choose between `cost-effective` and `legacy` modes. This flexibility helps teams balance budget and robustness depending on how large your Instagram email scraper tool job is.

#### Writes Results to Your Dataset as They’re Found

Each extracted email is pushed as a result record, including the source page details such as `url`, `title`, and `description`. That means your Instagram profile email grabber output is immediately usable without waiting for the entire run to finish.

***

### Who Gets the Most Out of This

Here’s how different teams put Instagram Email Scraper to work:

**Outreach and Growth Marketing Teams** — Use Instagram Email Scraper to generate an email list from publicly available Instagram profiles by focusing on keywords like “founder” and “marketing,” then filter to the domains that match your outreach strategy. The outcome is a ready-to-import dataset for campaigns and segmentation.

**Recruiters Sourcing Startup Talent** — Instead of manually searching for contact emails, recruiters can run Instagram email extractor jobs with role-like keywords and restrict domains to improve deliverability and reduce guesswork. The result is faster hiring outreach lists assembled from Instagram bios.

**Influencer and Creator Marketing Managers** — Build shortlists by extracting emails related to influencer marketing themes. With keyword-led searching and customDomains filtering, Instagram influencer email scraping becomes an efficient step in the creator vetting process.

**Data Analysts and Lead Ops Researchers** — Use the structured output fields (including `keyword`, `url`, and `description`) to analyze which keywords yield the most email matches and where contacts are sourced from. This supports repeatable Instagram email list builder workflows with clearer evaluation.

**Automation Developers** — Trigger runs and pipe dataset output into downstream systems for enrichment and CRM import. Because Instagram Email Scraper outputs consistent JSON records, it fits cleanly into scheduled pipelines for lead generation automation.

***

### Step-by-Step: How to Use It

No coding needed. Here’s how to run Instagram Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Instagram Email Scraper.
2. **Enter your inputs** — set `keywords` (required), and optionally add `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — if you plan larger runs, configure `proxyConfiguration` for more reliable scraping.
4. **Choose your engine** — pick `legacy` or `cost-effective` depending on your needs.
5. **Hit Run and watch the live log** — monitor progress and see when emails are found and pushed to the dataset.
6. **View results in the dataset tab** — each extracted email appears as a structured record with source context.
7. **Export your dataset** — download as JSON, CSV, or Excel from the Apify interface.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Instagram Email Scraper plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab, including **JSON**, **CSV**, and **Excel**. This makes it easy to use Instagram email scraper tool outputs in spreadsheets, BI tools, and marketing lists.

For automation and delivery, you can connect to downstream systems using Apify’s native integrations and common automation platforms like Zapier or Make. You can also access results programmatically via the Apify API (see [apify.com/docs/api](https://apify.com/docs/api)) and trigger actions when runs complete via webhooks.

***

### Pricing & Free Trial

Instagram Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can begin with a few test runs, then move to paid usage when you’re scaling. Apify pricing is generally based on platform compute (CU) and plan tiers—check the Apify pricing page for the most current details. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits and intermittent failures | Includes retries and resilience features to keep runs productive. |
| Better results with targeted filters | `keywords` and `customDomains` help reduce irrelevant matches. |
| Proxy-backed scraping support | Works with configured proxy settings to improve reliability for larger jobs. |
| Large search considerations | Mentions that large searches/high email limits may take longer and you can increase timeout in Run Options. |
| Data consistency in output | Each extracted email is pushed with consistent fields like `url`, `title`, and `description`. |

Limitations: The actor works with publicly accessible data and targets emails related to your keywords found in Instagram bios and posts. If an Instagram profile doesn’t publish an email (or the email doesn’t match your `customDomains`), results may be lower than expected. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Apify offers a free tier to help you get started without a credit card. You can run smaller tests first, then upgrade when you want to scale up Instagram lead scraper emails collection.

#### Do I need to log in to Instagram to use this?

No. Instagram Email Scraper is designed for publicly available Instagram data, so you don’t need an Instagram login or session to run it.

#### How accurate is the data?

The actor extracts emails that appear in publicly available sources related to your keywords, and it filters them by your custom email domains. Accuracy depends on what the account owner has published in bios/posts, so results will vary by profile.

#### How many results can I get per run?

You can control the maximum number of emails with `maxEmails`. The actor stops once the limit is reached, but the run may also finish earlier if there are fewer matching emails than expected.

#### How often is the data updated / how fresh is it?

Freshness depends on when Instagram profile content was published and what’s accessible at run time. If you run the actor again later with the same keywords and domains, you may find new emails as they appear publicly.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as a tool for collecting publicly available data and handle compliance on your side. Make sure your processing, storage, and outreach practices comply with GDPR, CCPA, and any applicable regulations and platform rules.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dashboard in formats like JSON, CSV, or Excel. If you need Google Sheets specifically, use your preferred import method or connect via Apify integrations/automation tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs using Apify’s automation features so your Instagram email extractor jobs run automatically. This is helpful for keeping your Instagram email list builder up to date.

#### Can I access this via API?

Yes. You can trigger and access results programmatically using the Apify API. Check [apify.com/docs/api](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

The actor includes resilience features like retries and fallbacks to improve outcomes when results are sparse or blocked. If issues persist, you’ll still be able to review what was captured so far in the dataset.

***

### Need Help or Have a Request?

Got a question about Instagram Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and welcome feature requests like batch CSV upload and webhook notifications on completion.

***

### Disclaimer & Responsible Use

*Instagram Email Scraper is the fastest, most reliable way to extract publicly available Instagram emails—start your free run today.* **publicly available data** only; it does not access private Instagram accounts, login-gated content, or password-protected pages. You’re responsible for using the output in compliance with GDPR, CCPA, platform terms, and applicable laws. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Instagram",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/instagram-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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/instagram-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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/instagram-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Email Scraper",
        "description": "📧 Instagram Email Scraper extracts emails from public Instagram profiles with speed & accuracy. 🚀 Perfect for lead gen, outreach, and B2B marketing. 🔒 User-friendly & efficient—save time, boost results.",
        "version": "0.0",
        "x-build-id": "FmyrbipsuMAuErJCl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~instagram-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-instagram-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/scraperoka~instagram-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-instagram-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/scraperoka~instagram-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-instagram-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Instagram"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instagram"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
