# Mass Instagram Leads Generator (`scraperoka/mass-instagram-leads-generator`) Actor

📈 Mass Instagram Leads Generator helps you find targeted Instagram leads at scale. Extract key profiles & insights fast for outreach, growth, and sales. 🚀 Save time, boost conversions, and expand your audience effortlessly.

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

## Pricing

from $1.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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Leads Generator - B2B & B2C Email Finder 🎯

Manually visiting Instagram profiles to collect emails wastes hours you don’t have. **Instagram Leads Generator - B2B & B2C Email Finder** extracts Instagram usernames, bios, and email addresses at scale using keyword-driven discovery. This Instagram email finder is ideal for marketers, recruiters, and growth teams who want targeted lead generation and outreach email lists fast—potentially thousands of records in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "marketing",
  "url": "https://www.instagram.com/example.co/",
  "username": "example.co",
  "biography": "🚀 Growth for B2B brands | email: hello@example.co",
  "emails": ["hello@example.co"],
  "user_id": "1234567890",
  "full_name": "Example Co",
  "followers": 18420,
  "following": 612,
  "post_count": 245,
  "is_verified": false,
  "is_business_account": true,
  "is_professional_account": true,
  "profile_pic_url": "https://example.com/profile_pic.jpg",
  "profile_pic_url_hd": "https://example.com/profile_pic_hd.jpg",
  "external_url": "https://example.co"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The niche keyword used to discover this lead |
| `username` | string | The Instagram handle you can match to your CRM/contact list |
| `full_name` | string | The display name shown on the profile |
| `emails` | array | The email addresses the actor extracted from the profile’s published bio content |
| `url` | string | Direct link to the Instagram profile for quick verification |
| `followers` | number | Social proof to help prioritize B2B and B2C outreach |
| `following` | number | Useful for assessing profile size and engagement context |
| `post_count` | number | A quick signal of how active the account is |
| `biography` | string | The bio text where email addresses are detected |
| `external_url` | string | The link in bio, useful for building richer company/influencer context |
| `profile_pic_url` | string | Standard profile picture URL (handy for enrichment pipelines) |
| `is_verified` | boolean | Whether the account is marked verified |
| `is_business_account` | boolean | Helps segment business profiles for B2B email prospecting |
| `is_professional_account` | boolean | Identifies creator/business-style account types |
| `user_id` | string | Internal profile identifier returned by the enrichment step |
| `profile_pic_url_hd` | string | Higher-quality profile picture URL (when available) |

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

***

### Why Instagram Leads Generator - B2B & B2C Email Finder?

There are a lot of ways to pull data from Instagram — here’s what sets Instagram Leads Generator - B2B & B2C Email Finder apart.

#### Keyword-driven lead discovery (B2B & B2C)

You provide a list of `keywords` and the actor focuses on finding relevant Instagram profiles around those niches. It’s built for both Instagram B2B leads and Instagram B2C leads, so your prospecting leads start aligned with your target market.

#### Email extraction from publicly available bios

When email discovery is enabled, the actor extracts emails into a structured `emails` array. This makes it an Instagram email finder you can use directly for outreach email list building.

#### Complete profile context, not just handles

Each record includes useful context like `full_name`, `biography`, `external_url`, and profile metadata such as `followers`, `post_count`, and `is_verified`. That extra structure makes it easier to prioritize leads, qualify segments, and enrich your workflow downstream.

#### Resilient batch processing

The actor uses concurrent enrichment for profiles and includes retries/fallback behavior for resilience during processing. You get a more stable experience when you run multiple keywords or larger batches for Instagram scraping for leads (email).

***

### Configuring Your Run

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

```json
{
  "keywords": ["marketing", "fitness"],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": true
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | List of niche keywords the actor searches to find relevant Instagram profiles |
| `country` | ⬜ | Sets the target country used for lead discovery (selected from the supported list) |
| `maxLeadsPerKeyword` | ⬜ | Caps how many leads to collect for each keyword (free users are capped at 100 emails total per run) |
| `scrapeLeadsWithEmail` | ⬜ | If enabled, returns only profiles that have a public email address |

***

### Core Capabilities

#### Bulk collection by keyword

Instead of manually hunting Instagram profiles, you can submit multiple niches via `keywords`. The actor processes each keyword and builds a lead set you can export immediately.

#### Targeted filtering for email-ready outreach

With `scrapeLeadsWithEmail` enabled, the actor only keeps profiles where an `emails` array is present and non-empty. This is designed to reduce manual cleanup when you’re building outreach email lists for Instagram outreach and targeted lead generation Instagram email.

#### Rich lead records for qualification

Your results include more than just an email: `username`, `full_name`, `biography`, `external_url`, `followers`, `following`, and account-type flags like `is_business_account` and `is_professional_account`. This structure helps you quickly segment Instagram contact extractor outputs for B2B email prospecting from Instagram or creator collaboration outreach.

#### Resilient processing for batch runs

The actor supports retries during page scraping and during profile enrichment, helping it succeed even when some profiles can’t be fetched or are temporarily unavailable. It also uses controlled concurrency for enrichment batches to keep the run moving.

#### Direct dataset writing and clean exports

Leads are pushed into the Apify dataset as structured JSON objects, ready for export. From there, you can download as JSON, CSV, or Excel—perfect for feeding your CRM, spreadsheets, or analysis pipeline.

***

### Who Gets the Most Out of This

Here's how different teams put Instagram Leads Generator - B2B & B2C Email Finder to work:

**Sales Development Reps** — Use it to turn Instagram niche keywords into a list of B2B and B2C prospects with emails, usernames, and bios. The outcome is a ready-to-import outreach shortlist with the exact profile link for quick validation.

**Influencer marketers** — Collect creator and business accounts tied to campaign niches, then export the dataset for outreach workflows. With fields like `is_verified`, `followers`, and `external_url`, they can prioritize partnerships faster.

**Recruiters and talent sourcers** — Build a searchable list of profiles relevant to a skill or industry keyword, then use the extracted email addresses to contact candidates. This helps reduce time spent on manual profile review while still keeping structured context like `full_name` and `biography`.

**Data analysts and researchers** — Run keyword-based discovery and export structured records for segmentation, cleaning, and enrichment. You get consistent fields such as follower counts and account-type flags that are easy to analyze.

**Developers and automation specialists** — Trigger runs through the Apify platform and feed results into downstream systems using the dataset export or API retrieval. The consistent output fields make it straightforward to map into pipelines for Instagram contact extraction and email finder for Instagram profiles workflows.

***

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

No coding needed. Here's how to run Instagram Leads Generator - B2B & B2C Email Finder from start to finish:

1. **Open** the actor on Apify — go to the Apify Console and open Instagram Leads Generator - B2B & B2C Email Finder: https://console.apify.com
2. **Enter your inputs** — fill in `keywords`, optionally set `country`, set `maxLeadsPerKeyword`, and choose `scrapeLeadsWithEmail` based on whether you want email-only results.
3. **Configure proxy settings** — use the proxy options available in Apify for reliability, especially for larger batches.
4. **Hit Run** and **watch the live log** — you’ll see progress as keywords are processed and profiles are enriched.
5. **View results** in the **Dataset** tab — each lead is stored with the profile fields and extracted `emails` (when available).
6. **Export** as **JSON, CSV, or Excel** — download directly from the dataset tab when you’re ready.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Instagram Leads Generator - B2B & B2C Email Finder plugs directly into your existing workflow.

Export formats are available from the Apify dataset tab: **JSON**, **CSV**, and **Excel**, so you can load results into a spreadsheet, BI tool, or outreach workflow quickly.

You can also use Apify’s **API access** to pull results programmatically (for app integrations and automation). If you use no-code automation, tools like **Zapier** or **Make** can help push leads into CRMs or email outreach lists, and Apify supports **webhooks** and **scheduled runs** for automation.

For deep integration details, refer to Apify docs: https://apify.com/docs/api

***

### Pricing & Free Trial

Instagram Leads Generator - B2B & B2C Email Finder runs on the Apify platform, which offers a **free tier** — no credit card required to get started. On free usage, the actor enforces a cap of **100 emails maximum per run**. Paid usage removes those result-limit restrictions.

Start for free at https://apify.com and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit friction | Built to run in batches with controlled pacing and concurrency |
| Proxy-based stability | Includes proxy support to improve scraping reliability |
| Unavailable profiles | Uses retries and skips profiles that can’t be enriched |
| Batch processing robustness | Enriches profiles in concurrent batches and returns only successful results |
| Data consistency | Pushes structured lead objects into the Apify dataset as results are ready |

**Limitations:** The actor works with publicly available Instagram profile information and focuses on extracting emails from published bio content. Private or login-gated profiles aren’t accessible in this workflow.

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

***

### Frequently Asked Questions

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

Yes. Apify provides a free tier so you can run Instagram Leads Generator - B2B & B2C Email Finder without immediately buying credits. On free usage, there is a cap of **100 emails maximum per run**.

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

No. The actor is designed to work using publicly accessible Instagram profile data, so you don’t need to provide login credentials.

#### How accurate is the data?

The accuracy depends on what the account owner has published in their profile bio. The actor extracts email addresses into the `emails` array from publicly available content, so the email values reflect what is visible on the profile.

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

You control volume using `maxLeadsPerKeyword` and also hit a global limit for free users. Paid users aren’t restricted by the free-tier global email cap.

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

Data freshness depends on when you run the actor. Each run generates a new dataset based on the publicly available profile content at that moment.

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

You should treat this as compliant data collection only if your use case follows the applicable laws and Instagram’s Terms of Service. The actor uses **publicly available data**, but you’re responsible for your storage, processing, and outreach practices.

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

Yes. You can download the dataset from Apify as JSON, CSV, or Excel. From there, you can import into Google Sheets or your reporting stack.

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

Yes. You can schedule runs via Apify’s scheduling capabilities so your Instagram lead generation stays consistent without manual triggering.

#### Can I access this via API?

Yes. You can retrieve results programmatically using Apify’s API (see https://apify.com/docs/api). This is useful for automation and integrating with your lead management system.

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

The actor uses retries and skips profiles that can’t be enriched successfully. You’ll still get any successful results that were already collected and pushed to the dataset, so runs degrade gracefully instead of failing everything at once.

***

### Need Help or Have a Request?

Got a question about Instagram Leads Generator - B2B & B2C Email Finder or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like batch CSV upload of keywords and webhook notifications when a run completes.

***

### Disclaimer & Responsible Use

*Instagram Leads Generator - B2B & B2C Email Finder is the fastest, most reliable way to collect email-ready Instagram leads — start your free run today.*

This actor collects **publicly available data** and does not access private profiles, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, and Instagram’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of niche keywords to search (e.g., 'marketing', 'fitness').

## `country` (type: `string`):

Select the target country for leads.

## `maxLeadsPerKeyword` (type: `integer`):

Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run.

## `scrapeLeadsWithEmail` (type: `boolean`):

If enabled, only returns profiles that have a public email address.

## Actor input object example

```json
{
  "keywords": [
    "marketing",
    "fitness"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": 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",
        "fitness"
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/mass-instagram-leads-generator").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",
        "fitness",
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/mass-instagram-leads-generator").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",
    "fitness"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20
}' |
apify call scraperoka/mass-instagram-leads-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Instagram Leads Generator",
        "description": "📈 Mass Instagram Leads Generator helps you find targeted Instagram leads at scale. Extract key profiles & insights fast for outreach, growth, and sales. 🚀 Save time, boost conversions, and expand your audience effortlessly.",
        "version": "1.1",
        "x-build-id": "PyZ0DnurPjAmCJZXy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~mass-instagram-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-mass-instagram-leads-generator",
                "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~mass-instagram-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-mass-instagram-leads-generator",
                "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~mass-instagram-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-mass-instagram-leads-generator",
                "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": "Search Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of niche keywords to search (e.g., 'marketing', 'fitness').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "India",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Brazil",
                            "Mexico",
                            "Japan",
                            "South Korea",
                            "China",
                            "Singapore",
                            "United Arab Emirates",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Switzerland",
                            "Belgium",
                            "Austria",
                            "Ireland",
                            "New Zealand",
                            "South Africa"
                        ],
                        "type": "string",
                        "description": "Select the target country for leads.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Max Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run.",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Only Leads with Email",
                        "type": "boolean",
                        "description": "If enabled, only returns profiles that have a public email address.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
