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

🚀 Extract emails fast with Indeed Email Scraper Fast Advanced And Cheapest! 📩 Advanced targeting + bulk export for B2B outreach, recruiting & lead gen. ✅ Quick, reliable, and cost-effective. Save time—boost results!

- **URL**: https://apify.com/scraperoka/indeed-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Jobs
- **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

### Indeed Email Scraper - Fast, Advanced and Cheapest 🎯
Manually collecting outreach emails from Indeed wastes hours you don't have. **Indeed Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Indeed based on your keywords and filters. This Indeed email scraper is ideal for marketers, recruiters, and growth teams looking for fast, relevant contact leads—often in thousands of records across a single run.

---

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

```json
{
  "network": "Indeed.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "https://example.com/job-posting",
  "email": "alex@gmail.com"
}
````

Output fields written to the dataset for each found email:

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network label for the record (always `Indeed.com`) |
| `keyword` | string | Which keyword/query you used for this lead |
| `title` | string | The title text associated with the extracted result |
| `description` | string | The text content the actor parsed to find emails |
| `url` | string | The link associated with the result where the email was found |
| `email` | string | The extracted email address |
| `error_message` | not present | No `error_message` field is pushed by the actor in dataset rows |

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

***

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

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

#### Fast results with a clear `maxEmails` stop point

You can control how many unique emails the run collects using `maxEmails`. The actor stops when your limit is reached, which helps you balance quality, coverage, and cost.

#### Targeted filters for cleaner lead lists

This Indeed email scraping software uses your provided `keywords`, optional `location`, and your `customDomains` (like `@gmail.com`, `@yahoo.com`) to focus results on emails that match your outreach strategy—exactly what you’d expect from an Indeed contact email extractor.

#### Resilient execution with progress resume

If a run is interrupted, it can resume from saved progress (keyword/domain cursor + already seen emails). That makes this advanced Indeed email scraping approach more reliable for long jobs and iterative lead-building.

#### De-duplicated emails across the run

The actor tracks `seen_emails` and only pushes new emails to the dataset. This helps you avoid wasting time on duplicates when you’re building an Indeed email list builder.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords/queries used to find relevant Indeed leads for email extraction |
| `location` | ⬜ | Filters results to a specific location (leave empty to search without a location filter) |
| `customDomains` | ⬜ | Limits results to emails matching the domains you provide (for example `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | ⬜ | Stops the run after collecting up to this many unique emails (helps control scraping time and cost) |

***

### Core Capabilities

#### Keyword-driven email extraction

Provide your `keywords` (e.g., job titles or roles) and the actor extracts email addresses found in publicly available web data associated with the search results. This is the backbone of an Indeed email finder workflow.

#### Flexible targeting with `location` and `customDomains`

Add a `location` when you want more localized leads, and use `customDomains` to focus on the email domains that match your outreach needs. This is how Indeed contact email extractor results get more usable for list building.

#### Unique email tracking (deduplication)

The actor keeps a `seen_emails` set and pushes only new emails into the dataset. The result is a cleaner dataset for outreach, analysis, and lead scoring.

#### Incremental dataset writes

Each time a new email is found, the actor pushes a row to the dataset immediately. This means you can review results as the run continues, not just at the end.

#### Run resilience with saved progress

The actor saves a cursor and previously seen emails, so you can continue without restarting from scratch. This helps when you’re running larger Indeed recruiter email scraper jobs.

***

### Who Gets the Most Out of This

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

**Growth teams and marketers** use it to scrape Indeed emails for outreach campaigns by starting broad with a few high-intent keywords, then narrowing with `customDomains` and `location` to build a cleaner lead list faster than manual research.

**Recruiters and talent sourcers** can use targeted keywords (like titles) to quickly assemble an Indeed email list builder for role-specific campaigns, then export the dataset to share with hiring managers or feed into their CRM.

**Sales development representatives** use this automated Indeed email scraping approach to turn role keywords into outreach-ready contacts, focusing on the email domains that tend to match their target prospects.

**Freelance researchers and analysts** benefit when they need structured datasets: the actor outputs consistent fields (`keyword`, `title`, `description`, `url`, `email`) so you can filter, deduplicate, and analyze contact patterns.

**Automation specialists (technical users)** can trigger runs via the Apify API and ingest dataset exports into their pipelines, using the dataset as a reliable upstream source for lead enrichment and downstream workflows.

***

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

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

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — set `keywords` (required) and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — if you want more reliable scraping, enable Apify Proxy in the run’s proxy configuration.
4. **Hit Run and watch the live log** — monitor progress and see emails being pushed incrementally.
5. **View results in the dataset tab** — each found email appears as a row in the dataset.
6. **Export as JSON, CSV, or Excel** — download straight from the Apify dataset UI.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Indeed Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow.

You can export results from the Apify dataset in JSON, CSV, or Excel. If you use tools like Zapier or Make, you can connect your run lifecycle to downstream actions and route leads to your CRM or spreadsheets.

For automation at scale, you can also trigger and retrieve results programmatically via the Apify API (see [apify.com/docs/api](https://apify.com/docs/api)). Webhooks and scheduled runs let you run the scraper automatically and keep your lead pipeline updated.

***

### Pricing & Free Trial

**Indeed Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Free tier availability and limits depend on your Apify account. For larger outreach lists, you can scale up on paid plans, and the actor will collect up to your requested `maxEmails` (with a free-tier cap applied for free users).

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Request reliability | Built-in resilience features help runs complete more consistently |
| Proxy support | Supports proxy routing for more reliable scraping |
| Progress continuity | Saves progress and resumes using stored cursor + previously seen emails |
| Controlled output size | Uses `maxEmails` to stop once your target is reached |
| Deduplication | Tracks `seen_emails` to avoid pushing duplicate email addresses |
| Incremental data writing | Pushes each newly found result to the dataset as it’s discovered |

Limitations: this actor extracts emails only from publicly available data included in its accessible sources; it cannot access login-gated or private content.

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 for getting started. Depending on your account plan, free runs may apply a result limit.

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

No. The actor extracts emails from publicly available web data without requiring you to log into Indeed.

#### How accurate is the data?

Accuracy depends on what’s publicly available in the sources it reads. The actor extracts email addresses and pushes them along with the associated `keyword`, `title`, `description`, and `url` so you can validate and filter.

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

You control this with `maxEmails`, which is the maximum number of unique emails the actor collects before stopping. If you’re on a free user plan, a free-tier cap may be applied.

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

The dataset reflects the moment the run executes and collects available information at runtime. If you need fresher results, run the actor again with the same inputs.

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

This actor works with **publicly available data** and does not require login-gated access, but it’s still your responsibility to ensure your use complies with GDPR, CCPA, platform terms, and any applicable laws where you operate.

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

Yes. You can export from the Apify dataset as JSON, CSV, or Excel. From there, you can import into Google Sheets or any other tool you use.

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

Yes. You can set up scheduled runs on Apify so the actor executes automatically on a recurring basis.

#### Can I access this via API?

Yes. Apify supports API-based actor runs, letting you programmatically trigger the actor and retrieve dataset results.

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

If issues occur while pushing data or during execution, the actor logs errors and continues its run flow where possible. The saved progress helps you resume rather than restarting from zero.

***

### Need Help or Have a Request?

Got a question about Indeed Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out to <dataforleads@gmail.com>. We’re happy to help with setup questions and we actively maintain this actor based on user feedback—ideas like webhook notifications on completion and expanded export workflows are especially welcome.

***

### Disclaimer & Responsible Use

*Indeed Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract outreach emails from publicly available data — start your free run today.*

This actor uses **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, platform ToS, and any applicable local regulations when using and storing results. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

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

List of custom email domains

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

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

## Actor input object example

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

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/indeed-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Extract emails fast with Indeed Email Scraper Fast Advanced And Cheapest! 📩 Advanced targeting + bulk export for B2B outreach, recruiting & lead gen. ✅ Quick, reliable, and cost-effective. Save time—boost results!",
        "version": "1.0",
        "x-build-id": "CgYcAaGA1eDelxGnI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~indeed-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-indeed-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~indeed-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-indeed-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~indeed-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-indeed-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
