# Instagram Email Scraper Fast Advanced And Cheapest (`scraperoka/instagram-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Email Scraper Fast Advanced & Cheapest — extract emails from websites & leads quickly. ⚡ Fast results, advanced filters, and budget-friendly pricing. 📩 Perfect for B2B prospecting, marketing, and outreach. 🔒 Efficient + reliable.

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

## Pricing

from $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 - Fast, Advanced and Cheapest 🎯

Manually digging through Instagram profiles to collect emails wastes hours you don’t have. **Instagram Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Instagram based on your keywords and domain filters, so marketers, recruiters, and growth teams can build outreach lists faster. This Instagram email scraper (and advanced Instagram email extraction tool) helps you automate getting emails from Instagram with cleaner results—often enough to generate thousands of leads from a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Instagram.com",
  "keyword": "manager",
  "title": "John — Marketing Manager",
  "description": "John is a marketing manager. Contact: hello@gmail.com",
  "url": "https://example.com/instagram-profile",
  "email": "hello@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for each lead row (`Instagram.com`). |
| `keyword` | string | Which keyword you used to discover this lead (useful for segmentation). |
| `title` | string | The result title captured alongside the contact (helps you assess relevance fast). |
| `description` | string | The extracted text around the contact, helpful for context and validation. |
| `url` | string | The linked page associated with the scraped result (good for auditing). |
| `email` | string | The actual email address extracted from publicly available sources. |
| `charged_event_name` | string | Indicates the actor event name used when pushing results (`result`). |
| `status` | string | (If your run is interrupted by platform rules or limits, you’ll still see partial results already pushed.) |
| `error_message` | string | (If a push fails, the actor logs the error, while already-collected rows remain in the dataset.) |
| `keyword + email` | dedupe key | Avoids re-adding the same email across the run (unique email handling is built in). |
| `location` | string | (If provided) lets you understand where you targeted; it influences which results get captured. |
| `customDomains` match | string | (If provided) controls which email domains are considered eligible for extraction. |

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

***

### Why Instagram Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from Instagram — here’s what sets **Instagram Email Scraper - Fast, Advanced and Cheapest** apart.

#### Keyword + Domain Focus for Better Leads

This Instagram lead scraper is designed around your `keywords` and `customDomains`, so you’re not collecting random contacts. When you use targeted keyword variations and email domains (for example, `@gmail.com`), you typically get more usable results.

#### Resilient Runs with Progress Resuming

If a run stops early or you need to resume, the actor keeps track of progress so you can continue without starting from scratch. That means fewer wasted runs when you’re building an Instagram email list builder.

#### Clean, Structured Dataset Output

Each discovered record is pushed into the dataset with consistent fields like `keyword`, `title`, `url`, and `email`. This makes the output an easy input for CRM imports, spreadsheet analysis, and downstream automation.

#### Built for Bulk Email Harvesting

This automated Instagram email harvesting workflow is meant for scraping at scale within your chosen limits. With `maxEmails`, you control how much data you want per run, helping you balance coverage and cost.

***

### Configuring Your Run

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

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries used to find relevant Instagram leads to extract emails from. |
| `location` | ⬜ | Optional location filter to narrow down search results. Leave empty for no location filtering. |
| `customDomains` | ⬜ | Only considers email addresses matching these domains (for example `@gmail.com`, `@yahoo.com`). |
| `maxEmails` | ⬜ | Stops the scraper once the maximum number of emails to collect is reached (helps control runtime and cost). |

***

### Core Capabilities

#### Targeted Email Extraction from Instagram

Emails are extracted from Instagram based on the keywords and email-domain filters you provide. If you’re building an Instagram email finder software workflow, this focus helps keep your dataset relevant.

#### Flexible Input Controls

You can steer results with `keywords`, optionally add a `location`, and restrict eligible contacts using `customDomains`. This makes the actor a practical tool for an Instagram contact finder use case, not a one-size-fits-all scrape.

#### Maximum Results Control for Cost Management

Use `maxEmails` (bounded from 1 to 10000) to set a clear stop condition. This helps you scale up or run smaller tests without letting scraping time balloon.

#### Resilience with Built-In Resuming

The actor persists progress during the run and can resume later using saved cursor state and already-seen emails. That’s especially helpful for a fast Instagram email scraper workflow where you refine keywords/domains iteratively.

#### Dataset-First Output

Results are pushed incrementally into the Apify dataset as they’re found. That keeps your Instagram influencer email scraper pipeline moving and makes it easier to export only what you need.

***

### Who Gets the Most Out of This

Here’s how different teams put **Instagram Email Scraper - Fast, Advanced and Cheapest** to work:

**Growth Teams & Marketers** — Use targeted keywords and `customDomains` to build an Instagram email list for outreach, then export immediately for campaign setup. You’ll end each run with a structured dataset containing `email` and the associated `url`.

**Recruiters & Talent Sourcing Specialists** — When roles are common on Instagram bios, keyword-driven searches help surface contact emails faster than manual profiling. This speeds up early outreach and helps you compile shortlists with email verification context in `description`.

**Sales Development Representatives** — Convert prospecting lists into actionable leads by extracting emails from publicly available sources using your chosen keyword set. With `maxEmails`, you can run consistent batches to keep your pipeline fresh.

**Influencer Marketers** — Find creator and brand contacts by using role-based keywords (like “manager” and “founder”) and limiting results to the email domains you prefer. This supports an influencer email scraping workflow where output is ready for CRM import.

**Data Analysts & Researchers (Technical)** — Run multiple keyword/domain combinations, then analyze which terms produce the highest yield of unique `email` values. The dataset fields (`keyword`, `title`, `url`, `email`) make it straightforward to join with other internal datasets.

***

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

No coding needed. Here's how to run **Instagram Email Scraper - Fast, Advanced and Cheapest** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — set `keywords` (required), optionally add `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use the Apify Proxy option for more reliable scraping, especially for larger runs.
4. **Hit Run and watch the live log** — monitor progress while the actor pushes results into your dataset.
5. **View results in the dataset tab** — each pushed row includes `keyword`, `url`, and `email`.
6. **Export as JSON, CSV, or Excel** — download straight from the dataset tab for use in your tools.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Instagram Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow. Export your dataset as JSON, CSV, or Excel from the Apify dashboard, then load it into spreadsheets, CRMs, or lead tools.

You can also use Apify’s API access to pull results programmatically (see the Apify developer docs at https://apify.com/docs/api) and schedule runs automatically for ongoing Instagram email list building. For deeper automation, connect your run to your stack using webhook-style workflows and no-code tools like Zapier/Make via Apify’s native integrations.

***

### Pricing & Free Trial

**Instagram Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage is limited by credits, and if you’re on a free plan there is also a maximum email limit applied by the actor to control run size.

For full flexibility and higher-volume Instagram email harvesting, switch to a paid plan on Apify. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit pressure | Built for bulk runs with practical throttling and pacing. |
| Run interruptions | Progress is saved so you can resume without redoing everything. |
| Email duplication across runs | Tracks `seen_emails` to avoid pushing the same email repeatedly. |
| Partial results | Data is pushed incrementally, so you keep what you already collected. |
| Result targeting quality | You control output with `keywords`, optional `location`, and `customDomains`. |
| Output consistency | Dataset rows follow the same field structure (`network`, `keyword`, `title`, `url`, `email`). |

Limitations: the actor works with publicly available Instagram content, and it can only extract emails that appear in eligible publicly available sources. Private or login-gated accounts are out of scope.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes—Apify offers a free tier. Keep in mind the actor applies a free-user cap to control how many emails can be collected in a run.

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

No. This actor extracts email addresses from publicly available sources, so you don’t need an Instagram login.

#### How accurate is the data?

The actor extracts emails that match your provided domain filters from publicly available text it processes. If an account doesn’t publish an email in eligible places, there may be fewer or no results.

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

You control the number of emails using `maxEmails` (bounded by the actor and free-tier rules). The scraper stops once the limit is reached, if set.

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

Freshness depends on when you run the actor. Each run extracts what’s currently available from publicly available sources at runtime.

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

It’s designed to use **publicly available data** that doesn’t require login. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable regulations in your use and storage of the results.

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

Yes. You can export the Apify dataset as JSON, CSV, or Excel from the dashboard, which works well for imports into tools like spreadsheets.

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

Yes. You can schedule actor runs on Apify so your Instagram email list stays updated automatically.

#### Can I access this via API?

Yes. You can trigger runs and retrieve results via the Apify API—details are available in the Apify developer docs at https://apify.com/docs/api.

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

If errors occur, the actor logs them and continues collecting what it can. Because results are pushed incrementally and progress is saved, you typically keep partial output rather than losing everything.

***

### Need Help or Have a Request?

Got a question about **Instagram Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook on completion and batch CSV upload support, and we actively maintain this Instagram email scraper based on user feedback.

***

### Disclaimer & Responsible Use

*Instagram Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build an email list from public Instagram sources — start your free run today.*

This actor collects **publicly available data**. It does not access private Instagram accounts, login-gated content, or password-protected pages. You are responsible for GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using and storing the extracted data. 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 or queries to search for.

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

Location to filter search results.

## `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.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Email Scraper Fast Advanced & Cheapest — extract emails from websites & leads quickly. ⚡ Fast results, advanced filters, and budget-friendly pricing. 📩 Perfect for B2B prospecting, marketing, and outreach. 🔒 Efficient + reliable.",
        "version": "1.0",
        "x-build-id": "L4l4eFoHfezGH0ZNR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~instagram-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-instagram-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-instagram-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-instagram-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter 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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
