# Gumroad Email Scraper (`scraperoka/gumroad-email-scraper`) Actor

📧 Gumroad Email Scraper extracts emails from Gumroad listings fast and accurately. Perfect for lead gen, B2B outreach, market research & customer discovery. 🚀 Save time, target the right audiences, and boost conversions.

- **URL**: https://apify.com/scraperoka/gumroad-email-scraper.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 🎯
Manually visiting Instagram profiles to collect contact emails wastes hours you don’t have. **Instagram Email Scraper** is a fast way to scrape emails from Instagram bios and posts related to your keywords. This Instagram email scraper and Instagram contact email finder helps marketers, recruiters, and growth teams build outreach lists with thousands of records in minutes.

### What You Get: Sample Output
Here's a sample record from a single run:

```json
{
  "network": "Instagram.com",
  "keyword": "founder",
  "title": "Marketing & Founder — Studio",
  "description": "We help brands grow. Contact: hello@gmail.com",
  "url": "https://example.com/some-public-profile",
  "email": "hello@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network so you can filter results cleanly |
| `keyword` | string | Which keyword helped surface this contact (useful for reporting and list segmentation) |
| `title` | string | The title of the matched public page/profile result to give context |
| `description` | string | The surrounding text where the email was detected (great for manual validation) |
| `url` | string | The link associated with the match so you can trace and verify quickly |
| `email` | string | The extracted email address you can use for outreach |
| `proxyGroups` | array | Proxy configuration info associated with the run (helpful for debugging reliability) |

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

### Why Instagram Email Scraper?

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

#### Keyword-led email targeting

You control what gets searched by providing `keywords` and optional `customDomains`, so this Instagram influencer email scraper focuses on the contacts that match your outreach needs (for example, specific email domains).

#### Built for bulk list building

With `maxEmails` as a cap and a stop condition once the limit is reached, this automated Instagram email scraping workflow is designed for building lead lists at scale in a single run.

#### Resilient scraping with fallbacks

If pages return no results or requests fail, the actor includes retry and fallback logic to improve the chances of producing output even when conditions change.

#### Deduplication across the run

The actor tracks seen emails and avoids pushing duplicates, so you get a cleaner Instagram email list scraper dataset without rework.

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for when looking for relevant Instagram contacts |
| `location` | ⬜ | Location to filter search results (leave empty for no location filter) |
| `platform` | ⬜ | Selects the platform to use (this actor supports `Instagram`) |
| `customDomains` | ⬜ | Limits extracted emails to the domains you specify (example: `@gmail.com`) |
| `maxEmails` | ⬜ | Maximum number of emails to collect; the run stops once the limit is reached |
| `engine` | ⬜ | Chooses the scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run |

### Core Capabilities

#### Instagram bio & post email extraction

Instagram Email Scraper extracts emails from Instagram bios and posts related to your provided `keywords`, then filters them by `customDomains` if you set those domains.

#### Flexible input filters for better results

You can steer results using `keywords`, optionally narrow by `location`, and focus on the domains that matter to you using `customDomains`. This makes the Instagram profile email extraction output more relevant for outreach.

#### Stop at your target volume

Set `maxEmails` to cap the run once you’ve collected enough contacts. This gives you predictable output sizing for campaigns, audits, and influencer lead generation email scraper workflows.

#### Resilience for real-world runs

The actor includes retries and fallbacks when results are sparse or requests fail, helping keep your Instagram email finder software runs productive instead of brittle.

#### Structured dataset output as it goes

Every discovered email is pushed as a JSON object to the dataset with fields like `network`, `keyword`, `title`, `description`, `url`, and `email`, so you can start analyzing immediately.

### Who Gets the Most Out of This

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

**Influencer Marketing Managers** — Use it to build an outreach-ready list of creator contacts by selecting tight `keywords` and domain filters, then quickly export the dataset for campaign planning and follow-ups. You save time finding leads and focus on validating and sequencing your outreach.

**Sales Development Representatives** — Feed in keywords tied to your ICP and capture matching emails into a clean list for follow-up campaigns. This Instagram contact email finder workflow turns public Instagram content into structured leads without manual copying.

**Freelance Researchers & Data Analysts** — Use the structured fields (`title`, `description`, `url`, `email`) to create datasets for analysis and reporting. Because output is deduplicated within a run, it’s easier to measure coverage and match quality.

**Automation Specialists & Developers** — Integrate this Instagram email extraction tool into broader pipelines by pulling dataset results via the Apify API and scheduling recurring runs. This is especially useful when you need repeatable automated Instagram email scraping.

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

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

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open Instagram Email Scraper.
2. **Enter your inputs** — set `keywords` (required), then optionally add `location`, `customDomains`, `maxEmails`, and `engine`.
3. **Configure proxy settings** — use `proxyConfiguration` to choose how you want proxies handled for the run.
4. **Hit Run and watch the live log** — monitor progress and see when new emails are found.
5. **View results in the dataset tab** — every extracted email is pushed with fields like `email`, `url`, and `description`.
6. **Export as JSON, CSV, or Excel** — download in the format that matches your workflow.

The whole process takes under 5 minutes to set up.

### Integrations & Export Options

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

You can export from the Apify dataset tab in common formats like **JSON**, **CSV**, or **Excel** for quick import into your tools. If you rely on spreadsheets or CRMs, you can also connect the dataset using Apify’s native integrations or no-code automation through Zapier/Make.

For programmatic use, you can access results via the **Apify API** (see [apify.com/docs/api](https://apify.com/docs/api)). If you want automation after completion, use **webhooks** to trigger downstream actions, or schedule runs to keep your Instagram influencer email scraper lists refreshed automatically.

### Pricing & Free Trial

Instagram Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can test with several runs using platform credits, then scale as needed.

For real scraping at scale, pricing is generally **pay-as-you-go** based on Apify platform compute (CU), and you’ll want to check the current pricing details on Apify’s pricing page before committing. Start for free at [apify.com](https://apify.com) and scale when you're ready.

### Reliability & Performance

| What We Handle | How |
|---|---|
| Sparse results | Retries and fallbacks help keep runs productive |
| Duplicate emails | Deduplication prevents pushing the same email multiple times in one run |
| Output integrity | Each pushed record includes consistent fields (`network`, `keyword`, `url`, `email`, etc.) |
| Large jobs | You control run size with `maxEmails` so you can balance coverage and speed |
| Proxy support | Built-in proxy configuration helps with reliable scraping |

Limitations: the actor is designed for extracting emails from **publicly available data** on Instagram-related pages. Results depend on what contacts are actually published and on your `keywords` and `customDomains`.

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

### Frequently Asked Questions

#### Is there a free plan or trial for Instagram Email Scraper?

Yes. Apify provides a free tier that you can use to run Instagram Email Scraper and test results. The exact amount you can run depends on the current free-tier credits in your Apify account.

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

No. Instagram Email Scraper is built to work with publicly available pages and content. It does not require an Instagram login to run.

#### How accurate is the data extracted by Instagram Email Scraper?

It’s as accurate as what’s publicly published. The actor extracts email addresses from publicly available sources it encounters using your `keywords` and then filters by your `customDomains` when provided.

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

You control this with `maxEmails`. The scraper stops once it reaches your requested limit, and setting a higher cap allows more potential results (though it doesn’t guarantee you’ll hit the maximum).

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

Data freshness matches when you run the actor. Each run collects contacts at runtime, so if you need updated leads, schedule new runs or re-run with updated inputs.

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

This actor works with **publicly available data**; however, compliance depends on how you store, process, and use the collected information. Make sure your use aligns with GDPR, CCPA, applicable spam regulations, and Instagram’s Terms of Service.

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

Yes. You can export your dataset from the Apify dashboard (JSON, CSV, or Excel). If you want Google Sheets specifically, you can connect it via Apify’s native integrations or an automation tool like Zapier/Make.

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

Yes. You can schedule actor runs so your Instagram email extraction stays updated automatically. Use the Apify scheduling features to trigger runs on a cron-like schedule.

#### Can I access Instagram Email Scraper via API?

Yes. You can pull dataset results programmatically using the Apify API. This is useful for integrating an Instagram email finder software into your existing pipelines.

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

If something fails, the actor’s dataset writes remain incremental as it pushes results during the run. The actor also includes retry and fallback behavior to reduce the chance of complete failure during sparse-result conditions.

### Need Help or Have a Request?

Got a question about Instagram Email Scraper or want a new feature added? Email us at <dataforleads@gmail.com>. We’re actively maintaining the actor and love feedback from marketers and analysts using it in real campaigns. If you’d like improvements like batch CSV upload or a webhook on completion, tell us what you need.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

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

Select platform.

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

List of custom email domains

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

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

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Configure proxies for this Actor.

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/gumroad-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/gumroad-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/gumroad-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumroad Email Scraper",
        "description": "📧 Gumroad Email Scraper extracts emails from Gumroad listings fast and accurately. Perfect for lead gen, B2B outreach, market research & customer discovery. 🚀 Save time, target the right audiences, and boost conversions.",
        "version": "0.0",
        "x-build-id": "0KCp5PinKcP3qoBxU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~gumroad-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-gumroad-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~gumroad-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-gumroad-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~gumroad-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-gumroad-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Instagram"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instagram"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
