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

📧 Email Scraper extracts verified email addresses from public web profiles with smart parsing & deduping. 🚀 Perfect for B2B lead gen, outreach, recruiting & market research. ⚡ Fast, accurate, and easy to use.

- **URL**: https://apify.com/scraperoka/instagram-profile-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **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 Profile Email Scraper ⚡

Manually visiting hundreds of Instagram profiles to collect emails wastes hours you don't have. **Instagram Profile Email Scraper** is the direct solution—an Instagram email extractor for bulk Instagram profile email scraper workflows that delivers contact emails from publicly available bios. Ideal for marketers, recruiters, and growth teams who want scrape Instagram user emails at scale, with thousands of records possible in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "url": "https://www.instagram.com/authenticdigitalmarketing",
  "username": "authenticdigitalmarketing",
  "user_id": "1234567890",
  "success": true,
  "emails": ["hello@authenticdigitalmarketing.com", "partnerships@authenticdigitalmarketing.com"],
  "biography": "📩 hello@authenticdigitalmarketing.com | DM for collabs | Marketing & growth",
  "full_name": "Authentic Digital Marketing",
  "followers_count": 48200,
  "following_count": 612,
  "is_verified": false,
  "is_business_account": true,
  "is_professional_account": false,
  "profile_pic_url": "https://example.com/pic.jpg",
  "profile_pic_url_hd": "https://example.com/pic_hd.jpg",
  "used_proxy_type": "user-selected"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The normalized Instagram profile URL for the account you provided |
| `username` | string | The handle used to identify the Instagram profile you scraped |
| `user_id` | string | The profile’s internal user identifier (useful for deduping) |
| `success` | boolean | Whether this profile was scraped successfully |
| `emails` | array | All email addresses detected in publicly available profile text |
| `biography` | string | The bio text the actor parsed to extract emails |
| `full_name` | string | The display name shown on the profile |
| `followers_count` | number | Audience size signal for lead scoring |
| `following_count` | number | Additional context for outreach targeting |
| `is_verified` | boolean | Whether the account shows as verified |
| `is_business_account` | boolean | Whether the account is a business account |
| `is_professional_account` | boolean | Whether the account is a professional account |
| `profile_pic_url` | string | Profile picture URL (handy for CRM previews) |
| `profile_pic_url_hd` | string | Higher-quality profile picture URL |
| `used_proxy_type` | string | Indicates whether the run used the initial proxy choice or a fallback |
| `error_message` | string | Populated when a profile fails to fetch or parse |

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

***

### Why Instagram Profile Email Scraper?

There are a lot of ways to pull data from Instagram — here’s what sets **Instagram Profile Email Scraper** apart for email extraction and Instagram profile email search use cases.

#### Focused email harvesting from profile text

This Instagram profile email scraper concentrates on finding email addresses in publicly available profile text (from the bio), producing a clean `emails` array that’s ready for outreach workflows.

#### Flexible inputs for real workflows

You can pass Instagram profile URLs or plain usernames in `startUrls`, making it easy to scale from a small test list to automated Instagram leads email scraper runs.

#### Resilient fetching with fallbacks

If an Instagram request is rejected via the selected proxy, the actor is designed to fall back to a different proxy approach so your bulk run can keep moving instead of failing completely.

#### Structured output built for analysis and CRM import

Every profile result is written to the dataset with consistent fields like `username`, `user_id`, `emails`, and account metadata such as `followers_count` and `is_business_account`—ideal for analysts and growth teams using Instagram email harvesting software.

***

### Configuring Your Run

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

```json
{
  "startUrls": [
    { "url": "https://www.instagram.com/authenticdigitalmarketing/" },
    { "url": "marketingagency" }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | A list of Instagram profile URLs or usernames you want to scrape for email extraction |
| `proxyConfiguration` | ⬜ | Proxy settings for the run, including fallback behavior if a selected proxy is rejected |
| ↳ `proxy support` | ⬜ | Enables routing through Apify Proxy for improved reliability |

***

### Core Capabilities

#### Bulk profile processing

Instagram Profile Email Scraper takes your list of profile URLs or usernames and processes them in batches, so you can scrape Instagram user emails at scale instead of one profile at a time.

#### Email extraction with a clean `emails` array

It extracts email addresses from the profile bio text using pattern matching and returns them as a structured `emails` array, making it a practical Instagram contact email finder for outreach teams.

#### Resilience and retries for smoother runs

The actor is designed with retries and fallback behavior. This helps keep automated Instagram email scraping runs stable when some profile requests fail.

#### Rich, analysis-ready profile metadata

In addition to emails, it returns fields like `full_name`, `user_id`, `followers_count`, `following_count`, and verification/account-type flags—useful for lead scoring and segmentation.

#### Real-time dataset writing

Each profile result is pushed to the Apify dataset as it completes. That means you can review results immediately and continue working with partial outputs if needed.

***

### Who Gets the Most Out of This

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

**Sales Development Reps** — Paste a list of Instagram usernames, run the actor, and quickly build a lead list with `emails` plus `followers_count` context for smarter prioritization.

**Influencer Marketing Managers** — Use Instagram profile email search to shortlist creators and brands, then export the dataset to move from discovery to outreach with verified metadata like `is_verified` and business/professional account flags.

**Freelance Researchers** — Run the Instagram email extractor on client-provided handle lists and deliver structured datasets (user IDs, bios, and extracted emails) without writing custom code.

**Automation & Integration Specialists** — Trigger runs via Apify workflows and pass the resulting dataset into your downstream tooling, making Instagram DM email scraper-style contact enrichment part of an automated pipeline.

**Data Analysts** — Combine extracted `emails` with profile signals (`followers_count`, `following_count`, account-type flags) to study correlation and optimize targeting strategies.

***

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

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

1. **Open** the actor on Apify — use the actor’s page at [console.apify.com](https://console.apify.com).
2. **Enter** your inputs using `startUrls` (Instagram profile URLs or usernames) from the configuration table above.
3. **Configure** `proxyConfiguration` if you want proxy support for reliability (especially for larger lists).
4. **Hit** Run and **watch** the live log as each profile is processed.
5. **View** results in the dataset tab as records are written profile-by-profile.
6. **Export** as JSON, CSV, or Excel from the Apify dashboard for use in your CRM or analysis.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

Export formats include JSON, CSV, and Excel directly from the Apify dataset tab, so you can move quickly into spreadsheets and data pipelines. You can also use the Apify API to pull results programmatically for Instagram username to email scraper automations in your own systems via [apify.com/docs/api](https://apify.com/docs/api).

For connecting to other tools, you can use webhooks and no-code automation (such as Zapier or Make) to push results to CRMs, Slack, or other endpoints as soon as a run completes. If you need ongoing enrichment, you can schedule runs on a recurring basis inside Apify.

***

### Pricing & Free Trial

Instagram Profile Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier includes $5 platform credits on sign-up, enough for several test runs.

After that, you can run on pay-as-you-go pricing billed per Actor compute unit (CU), and plan scaling for higher-volume Instagram leads email scraper workflows using Apify’s subscription plans. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit style failures | Includes retries and controlled pacing across batches |
| Proxy rejection scenarios | Falls back to an alternate proxy approach when the initial proxy is rejected |
| Parsing failures | Produces `success: false` records with an `error_message` when profile data can’t be parsed |
| Data freshness | Returns emails and bio-derived text from the time the profile is fetched |
| Scale in one run | Processes inputs in batches to support larger lists |
| Output consistency | Writes structured fields like `username`, `emails`, and account metadata for every processed item |

Limitations: Private Instagram accounts and login-gated content are not accessible. If a profile bio contains no email addresses, `emails` will be empty even when `success` is true.

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 with platform credits so you can test Instagram Profile Email Scraper before scaling up.

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

No. This actor works on publicly accessible Instagram profile data without requiring an Instagram login.

#### How accurate is the data?

Accuracy depends on what the profile owner has published. The actor extracts emails from publicly available profile text and returns matches in the `emails` array (it does not invent or guess emails).

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

You can process lists of multiple Instagram profile URLs or usernames provided in `startUrls`. Practically, the output size is determined by your input list length and the run’s execution capacity on Apify.

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

Data is as fresh as each profile fetch at the time the actor runs. If you need newer emails, rerun the actor with updated `startUrls`.

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

This actor accesses **publicly available data** only. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any local regulations when using or storing extracted contact information.

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

Yes. You can export your dataset from the Apify dashboard, including JSON, CSV, and Excel formats. From there, you can import into tools like spreadsheets.

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

Yes. You can use Apify’s scheduling capabilities to run Instagram Profile Email Scraper automatically on a recurring basis.

#### Can I access this via API?

Yes. You can retrieve run results programmatically using the Apify API. Refer to [apify.com/docs/api](https://apify.com/docs/api) for details.

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

Errors are captured at the profile level. Failed items are pushed with `success: false` and an `error_message` so you can see which profiles succeeded and which ones need another attempt.

***

### Need Help or Have a Request?

Got a question about Instagram Profile Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. This actor is actively maintained based on user feedback, and we’re happy to discuss improvements like batch CSV upload or webhook notifications on completion.

***

### Disclaimer & Responsible Use

*Instagram Profile Email Scraper is the fastest, most reliable way to extract profile emails from public bios — start your free run today.*

This actor collects **publicly available data** only. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for GDPR/CCPA compliance and for following Instagram’s Terms of Service when using or storing extracted information. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `startUrls` (type: `array`):

Enter one or more Instagram profile URLs (e.g., https://www.instagram.com/username) or just usernames (e.g., username).

## `proxyConfiguration` (type: `object`):

Select proxies to be used by the scraper. If the selected proxy is rejected by Instagram, a residential proxy will be used as a fallback.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.instagram.com/authenticdigitalmarketing/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.instagram.com/authenticdigitalmarketing/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/instagram-profile-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 = {
    "startUrls": [{ "url": "https://www.instagram.com/authenticdigitalmarketing/" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/instagram-profile-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 '{
  "startUrls": [
    {
      "url": "https://www.instagram.com/authenticdigitalmarketing/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/instagram-profile-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Profile Email Scraper",
        "description": "📧 Email Scraper extracts verified email addresses from public web profiles with smart parsing & deduping. 🚀 Perfect for B2B lead gen, outreach, recruiting & market research. ⚡ Fast, accurate, and easy to use.",
        "version": "0.1",
        "x-build-id": "i6meoLZbEcNpj0tAg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~instagram-profile-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-instagram-profile-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-profile-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-instagram-profile-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-profile-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-instagram-profile-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Instagram Profile URLs or Usernames",
                        "type": "array",
                        "description": "Enter one or more Instagram profile URLs (e.g., https://www.instagram.com/username) or just usernames (e.g., username).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the scraper. If the selected proxy is rejected by Instagram, a residential proxy will be used as a fallback."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
