# Indeed Jobs Scraper - Listings, Salary & Company (`oriented_wallpaper/indeed-jobs-scraper`) Actor

Scrape Indeed job listings by title + location — job title, company, location, parsed salary (min/max/period), employment type, remote flag, posting date, job URL & apply link. Dedup, filters & a 0-100 job score. No login, no auto-apply. Export CSV/JSON/Excel.

- **URL**: https://apify.com/oriented\_wallpaper/indeed-jobs-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/oriented_wallpaper) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Jobs Scraper - Listings, Salary & Company

**This Indeed jobs scraper turns any job search into a clean, analysis-ready feed of job listings** — one row per job, with the title, company, location, a parsed salary (min / max / period), employment type, a remote flag, the posting date, the canonical job URL and the external apply link. Search Indeed by job title and location (or paste Indeed search URLs), filter down to the roles worth keeping, and export to CSV, JSON, or Excel.

Built for **job seekers, recruiters, job-board aggregators, and labor-market analysts** who want a spreadsheet of jobs — not a raw scrape. It reads only **public** listings: no login, no cookies, and it never auto-applies to anything.

---

### How to scrape Indeed jobs

You don't need an Indeed account, an API key, or any code:

1. Enter one or more **job titles / keywords** (e.g. `software engineer`, `registered nurse`) and a **location** (e.g. `Austin, TX`, or leave blank for the whole country), and pick the **country**.
2. The scraper pulls matching listings from Indeed via the proven [`misceres/indeed-scraper`](https://apify.com/misceres/indeed-scraper) engine.
3. Each listing is cleaned: the salary string is parsed into numbers, the employment type is normalized, a remote flag is derived, and tracking junk is stripped from the URL.
4. Duplicates are removed, your filters are applied, and every job gets a **0–100 job score** so the freshest, best-paid, most complete listings sort to the top.
5. You get a clean table to download as CSV, JSON, or Excel — or pull via API.

Need full control? Paste raw Indeed search-results URLs into **startUrls** and the actor scrapes those directly.

---

### What data you get

Every row is one job, best-scored first:

- **Job title and company** — exactly as listed on Indeed.
- **Location and a remote flag** — `isRemote` is derived from the title, location, and description.
- **Parsed salary** — `salaryMin`, `salaryMax`, and `salaryPeriod` (year / month / week / day / hour), plus the original `salaryRaw` string.
- **Employment type** — normalized to Full-time / Part-time / Contract / Temporary / Internship / etc.
- **Company rating and review count** — the employer's Indeed reputation (when "include company details" is on).
- **Posting date** — the relative `postedAt` text Indeed shows.
- **Job URL and apply link** — the clean canonical listing URL plus the external `applyUrl` when present.
- **A 0–100 job score** — blends salary presence, recency, description completeness, active/expired status, and company rating.

---

### Filters & options

Trim the scrape to only the jobs worth keeping — applied after scraping:

- **Only jobs with a salary** — drop listings with no pay info.
- **Minimum salary (annualized)** — keep only jobs at or above a yearly figure; hourly/weekly/monthly pay is annualized for a fair comparison.
- **Employment type** — keep only Full-time, Contract, etc.
- **Remote jobs only** — keep only listings that look remote.
- **Posted within N days** — keep only fresh listings.
- **Max jobs per search** — cap volume and cost per query.

#### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Job titles / keywords, one per line. |
| `location` | string | City / state / region, or blank for the whole country. |
| `country` | string | Indeed country domain (US, GB, CA, …). |
| `maxItemsPerSearch` | integer | Max listings per query. Default `100`. |
| `parseCompanyDetails` | boolean | Include employer rating + reviews. Default `true`. |
| `requireSalary` | boolean | Keep only jobs with a salary. Default `false`. |
| `minSalary` | integer | Minimum annualized salary (`0` = no filter). |
| `employmentType` | array | Keep only these employment types. |
| `remoteOnly` | boolean | Keep only remote-looking jobs. Default `false`. |
| `postedWithinDays` | integer | Keep only jobs posted within N days (`0` = no filter). |
| `startUrls` | array | Advanced: raw Indeed search URLs to scrape directly. |

**Example input:**

```json
{
  "searchQueries": ["software engineer", "backend developer"],
  "location": "Remote",
  "country": "US",
  "maxItemsPerSearch": 100,
  "requireSalary": true,
  "minSalary": 90000,
  "employmentType": ["Full-time"],
  "remoteOnly": true,
  "postedWithinDays": 7
}
````

#### JSON output sample

```json
{
  "job_score": 92,
  "jobTitle": "Senior Backend Engineer",
  "companyName": "Acme Corp",
  "location": "Austin, TX (Remote)",
  "isRemote": true,
  "salaryRaw": "$140,000 - $170,000 a year",
  "salaryMin": 140000,
  "salaryMax": 170000,
  "salaryPeriod": "year",
  "employmentType": "Full-time",
  "companyRating": 4.1,
  "companyReviews": 832,
  "postedAt": "2 days ago",
  "jobUrl": "https://www.indeed.com/viewjob?jk=abc123",
  "applyUrl": "https://acme.com/careers/apply/abc123",
  "companyLogoUrl": "https://...",
  "descriptionText": "We're hiring a backend engineer to…",
  "isExpired": false,
  "jobId": "abc123"
}
```

Results render as a clean, sortable table on the Output tab and export to CSV, JSON, or Excel.

***

### Use with AI agents & automation

This Indeed jobs scraper plugs straight into your stack. Use the Apify **MCP** server so AI agents (Claude, ChatGPT, Cursor) can pull fresh job listings as a tool call. Schedule runs and pipe results through **Make**, **n8n**, or **Zapier** to track new openings, populate a job board, or feed a hiring dashboard — or sync the dataset to **Google Sheets** for a live, always-fresh jobs list. Every run produces clean, flat JSON, so it drops into agentic workflows with no glue code.

***

### Pricing

**Pay-per-result — you're charged only for the cleaned job listings delivered after your filters.** Set `maxItemsPerSearch` and use the filters to keep cost predictable. See the Apify Store page for the current per-result price.

***

### FAQ

**Does this apply to jobs for me?** No. It only collects **public** job listings into a spreadsheet. It never logs in and never submits applications — you stay in control of where you apply.

**Do I need an Indeed account or API key?** No. Searching and scraping work with no login and no key.

**Will every job show a salary?** No — many Indeed listings hide pay. Use `requireSalary` to keep only the ones that show it, and the salary parser fills `salaryMin`/`salaryMax` whenever a figure is present.

**How does the remote filter work?** `isRemote` is inferred from the title, location, and description (remote / work from home / WFH / telecommute). `remoteOnly` keeps just those.

**Can I search multiple titles and locations?** Yes — pass several `searchQueries`; each is searched in your chosen location and country. For full control, paste raw Indeed search URLs into `startUrls`.

**Is scraping Indeed legal?** This collects **public** listings only. Indeed's terms restrict automated access and Indeed uses anti-bot defenses, so expect occasional partial runs. Use the data for personal/research/recruiting purposes and follow Indeed's terms and your local data-protection law.

**Can I export to CSV or Google Sheets?** Yes — export to CSV, JSON, or Excel from the Output tab, or sync the dataset to Google Sheets via Make, n8n, or Zapier.

***

### Other Flash Scrape scrapers

- [LinkedIn Profile + Email Leads](https://apify.com/oriented_wallpaper/linkedin-leads-scraper) — LinkedIn profile leads
- [Google Maps Leads Scraper](https://apify.com/oriented_wallpaper/google-maps-leads-opener) — Google Maps business leads
- [Yelp Leads Scraper](https://apify.com/oriented_wallpaper/yelp-leads-scraper) — Yelp business leads
- [Instagram Leads Scraper](https://apify.com/oriented_wallpaper/instagram-leads-scraper) — Instagram profile leads
- [TikTok Leads Scraper](https://apify.com/oriented_wallpaper/tiktok-leads-scraper) — TikTok creator leads
- [YouTube Leads Scraper](https://apify.com/oriented_wallpaper/youtube-leads-scraper) — YouTube creator leads

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles or keywords to search on Indeed — one per line. e.g. 'software engineer', 'registered nurse', 'data analyst'.

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

City, state or region to search in — e.g. 'Austin, TX', 'London', 'Remote'. Leave empty to search the whole country.

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

Indeed country domain to search.

## `maxItemsPerSearch` (type: `integer`):

Maximum number of job listings to scrape per search query.

## `parseCompanyDetails` (type: `boolean`):

Enrich each job with the employer's Indeed rating and review count (slightly slower).

## `requireSalary` (type: `boolean`):

Drop listings that don't show a salary.

## `minSalary` (type: `integer`):

Keep only jobs paying at least this much per year. Hourly/weekly/monthly pay is annualized for comparison (0 = no filter).

## `employmentType` (type: `array`):

Keep only these employment types (leave empty for all).

## `remoteOnly` (type: `boolean`):

Keep only jobs that look remote (detected from title, location and description).

## `postedWithinDays` (type: `integer`):

Keep only jobs posted within this many days (0 = no filter). Jobs with no visible date are kept.

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

Paste full Indeed search-results URLs to scrape directly instead of building them from the fields above. Overrides job titles / location.

## Actor input object example

```json
{
  "searchQueries": [
    "data analyst",
    "product manager"
  ],
  "location": "Austin, TX",
  "country": "US",
  "maxItemsPerSearch": 100,
  "parseCompanyDetails": true,
  "requireSalary": false,
  "minSalary": 0,
  "employmentType": [],
  "remoteOnly": false,
  "postedWithinDays": 0,
  "startUrls": []
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "software engineer"
    ],
    "location": "Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("oriented_wallpaper/indeed-jobs-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 = {
    "searchQueries": ["software engineer"],
    "location": "Austin, TX",
}

# Run the Actor and wait for it to finish
run = client.actor("oriented_wallpaper/indeed-jobs-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 '{
  "searchQueries": [
    "software engineer"
  ],
  "location": "Austin, TX"
}' |
apify call oriented_wallpaper/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper - Listings, Salary & Company",
        "description": "Scrape Indeed job listings by title + location — job title, company, location, parsed salary (min/max/period), employment type, remote flag, posting date, job URL & apply link. Dedup, filters & a 0-100 job score. No login, no auto-apply. Export CSV/JSON/Excel.",
        "version": "0.1",
        "x-build-id": "UxQhHsVeV2X2h0aJI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/oriented_wallpaper~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-oriented_wallpaper-indeed-jobs-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/oriented_wallpaper~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-oriented_wallpaper-indeed-jobs-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/oriented_wallpaper~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-oriented_wallpaper-indeed-jobs-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",
                "properties": {
                    "searchQueries": {
                        "title": "Job titles / keywords (what)",
                        "type": "array",
                        "description": "Job titles or keywords to search on Indeed — one per line. e.g. 'software engineer', 'registered nurse', 'data analyst'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (where)",
                        "type": "string",
                        "description": "City, state or region to search in — e.g. 'Austin, TX', 'London', 'Remote'. Leave empty to search the whole country."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "IE",
                            "IN",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "AE",
                            "SG",
                            "ZA",
                            "MA",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Indeed country domain to search.",
                        "default": "US"
                    },
                    "maxItemsPerSearch": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape per search query.",
                        "default": 100
                    },
                    "parseCompanyDetails": {
                        "title": "Include company rating & reviews",
                        "type": "boolean",
                        "description": "Enrich each job with the employer's Indeed rating and review count (slightly slower).",
                        "default": true
                    },
                    "requireSalary": {
                        "title": "Only jobs with a salary",
                        "type": "boolean",
                        "description": "Drop listings that don't show a salary.",
                        "default": false
                    },
                    "minSalary": {
                        "title": "Minimum salary (annualized)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs paying at least this much per year. Hourly/weekly/monthly pay is annualized for comparison (0 = no filter).",
                        "default": 0
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Keep only these employment types (leave empty for all).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Permanent",
                                "Apprenticeship"
                            ]
                        },
                        "default": []
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only jobs that look remote (detected from title, location and description).",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs posted within this many days (0 = no filter). Jobs with no visible date are kept.",
                        "default": 0
                    },
                    "startUrls": {
                        "title": "Indeed search URLs (advanced)",
                        "type": "array",
                        "description": "Paste full Indeed search-results URLs to scrape directly instead of building them from the fields above. Overrides job titles / location.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
