# Job Postings Scraper — Greenhouse, Lever, Ashby + 7 More ATSs (`leohryndev/ats-job-postings-scraper`) Actor

Scrape job postings from any company career board on 10 ATS platforms — Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, Breezy, BambooHR, Teamtailor, Personio — via official public feeds. One normalized format, remote detection, and a new-jobs-only monitoring mode.

- **URL**: https://apify.com/leohryndev/ats-job-postings-scraper.md
- **Developed by:** [Leo Hryn](https://apify.com/leohryndev) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job postings

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

## Job Postings Scraper — Greenhouse, Lever, Ashby, Workable, BambooHR, Breezy, Teamtailor + more

Scrape **job postings from any company career board** running on the ten most popular ATS platforms — **Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, BambooHR, Breezy HR, Teamtailor, and Personio** — in one Actor, with one normalized output format. Paste board URLs, get clean JSON jobs.

Because it reads each ATS's **official public job-board feed** (no HTML scraping, no browser, no proxies), it's fast, extremely reliable, and cheap: **$1 per 1,000 job postings**, charged only for what's returned.

### What you get

One normalized row per job posting:

```json
{
    "ats": "ashby",
    "company": "openai",
    "jobId": "e94b...",
    "title": "Technical Program Manager, Compute Infrastructure",
    "url": "https://jobs.ashbyhq.com/openai/e94b...",
    "location": "San Francisco",
    "isRemote": false,
    "department": "Program Management",
    "employmentType": "FullTime",
    "compensation": "$220K – $280K",
    "publishedAt": "2026-06-30T18:41:32.000Z",
    "descriptionText": "OpenAI's compute infrastructure team...",
    "scrapedAt": "2026-07-12T21:04:11.000Z"
}
````

(Compensation appears where the ATS exposes it — Ashby and Lever boards often include salary ranges.)

### Supported ATS platforms

| ATS | Board URL shape | Data source |
|---|---|---|
| **Greenhouse** | `boards.greenhouse.io/⟨slug⟩` | Official job board API (full descriptions, departments, offices) |
| **Lever** | `jobs.lever.co/⟨slug⟩` | Official postings API (categories, commitment, salary where posted) |
| **Ashby** | `jobs.ashbyhq.com/⟨slug⟩` | Official posting API (compensation ranges, remote flags) |
| **Workable** | `apply.workable.com/⟨slug⟩` | Official accounts API (locations, departments) |
| **Recruitee** | `⟨slug⟩.recruitee.com` | Official offers API (tags, career site content) |
| **SmartRecruiters** | `careers.smartrecruiters.com/⟨Slug⟩` | Official postings API, paginated (industry, function) |
| **Breezy HR** | `⟨slug⟩.breezy.hr` | Official positions JSON (type, experience) |
| **BambooHR** | `⟨slug⟩.bamboohr.com/careers` | Official careers list + detail endpoints |
| **Teamtailor** | `⟨slug⟩.teamtailor.com` | Official jobs JSON feed |
| **Personio** | `⟨slug⟩.jobs.personio.de` | Official XML job feed (converted to the same JSON schema) |

Every platform above exposes these feeds publicly to power the company's own careers page — this Actor just reads them all and speaks one schema.

### Monitoring mode: only NEW jobs since the last run

Turn on **`newJobsOnly`** and the Actor remembers every posting it has seen (per `dedupKey`) and returns only newly published ones. Schedule it daily and you have a **new-jobs alert pipeline**: pipe fresh postings to Slack, email, Airtable, or your CRM via the Apify integrations.

### Who uses this

- **Recruiters & sourcers** — watch competitor/target-company boards; be first on new openings.
- **Job boards & aggregators** — normalized multi-ATS ingestion without maintaining ten integrations.
- **B2B lead generation** — hiring is a buying signal: companies hiring "Head of Sales" buy sales tools; hiring "DevOps" buy infra. Filter by title keywords across hundreds of boards.
- **Market & talent intelligence** — track hiring velocity, remote share, salary ranges by company or sector.
- **Job seekers** — one scheduled run watching your dream companies beats refreshing six career pages.

### Input

- **companies** — board URLs in any supported shape (`boards.greenhouse.io/stripe`, `jobs.lever.co/spotify`, `jobs.ashbyhq.com/openai`, `apply.workable.com/company`, `company.recruitee.com`, `careers.smartrecruiters.com/Company`, `company.bamboohr.com/careers`, `company.breezy.hr`, `company.teamtailor.com`, `company.jobs.personio.de`) or explicit `ats:slug` pairs.
- **Filters** — `titleIncludes` / `titleExcludes` / `locationIncludes` / `remoteOnly`.
- **Monitoring** — `newJobsOnly` + `dedupKey`.
- **Volume** — `maxJobsPerCompany`, `maxItems`; descriptions on/off + max length.

### Why this beats single-ATS scrapers

- **10 ATSs, one schema** — mix Greenhouse, Ashby, BambooHR and Teamtailor boards in one run; downstream code sees identical fields.
- **Official feeds, zero breakage** — these JSON endpoints are the same ones powering the companies' own career pages.
- **Remote detection + salary where available + full descriptions.**
- **Built-in change detection** (`newJobsOnly`) — most alternatives return everything every time and leave dedup to you.
- **Honest pricing** — pay per posting returned; a board with no matches costs you nothing.

### Scheduling & integrations

Run on a schedule from the Console; trigger via API/SDKs; pipe to Slack/Sheets/Airtable with Apify integrations or n8n/Make/Zapier; call it as an **MCP tool** from AI agents ("which of these 40 companies posted new engineering roles this week?").

### FAQ

**Is this allowed?** Yes. The Actor reads the public job-board JSON feeds each ATS officially exposes for embedding jobs — the same data shown on public career pages. No login, no personal data.

**A company's board returns "not found"?** Check the slug: it's the identifier in the board URL (e.g. `boards.greenhouse.io/⟨slug⟩`). Companies occasionally migrate ATSs — the summary output lists per-company results so failures are visible.

**Which ATS is a company on?** Open their careers page and check the job links' domain. Or just try `greenhouse:slug`, `lever:slug`, etc. — failures are free. (Or use our [Company Hiring Signals](https://apify.com/leohryndev) Actor, which auto-discovers a company's job board from just its name or domain.)

**Does it include salary data?** Where the ATS exposes it: Ashby boards very often include compensation ranges, Lever sometimes, Greenhouse occasionally in the description text. The `compensation` field is populated whenever the feed provides it.

**Can I get the postings as a spreadsheet?** Yes — every run's dataset exports as CSV, Excel, JSON, or feeds Google Sheets directly via the Apify integration. "Careers page to spreadsheet" is a one-click export.

**How is this different from a LinkedIn jobs scraper?** LinkedIn shows what companies *pay to promote*; ATS boards show *everything they're actually hiring for*, hours after it's posted, with clean structured fields — and scraping official public feeds doesn't fight anti-bot systems, so runs never break.

***

*More data tools from this developer: [apify.com/leohryndev](https://apify.com/leohryndev) — company hiring analytics, AI-search brand monitoring, Bluesky & Telegram data.*

*Keywords: job scraper, Greenhouse jobs API, Lever jobs scraper, Ashby jobs API, Workable scraper, Recruitee API, SmartRecruiters postings, BambooHR careers scraper, Breezy HR jobs API, Teamtailor jobs feed, Personio XML feed, ATS scraper, job postings JSON, careers page scraper, hiring signals, recruiting data, job board aggregator, new job alerts.*

# Actor input Schema

## `companies` (type: `array`):

One per line: a job-board URL from any supported ATS — `boards.greenhouse.io/stripe`, `jobs.lever.co/netflix`, `jobs.ashbyhq.com/openai`, `apply.workable.com/company`, `company.recruitee.com`, `careers.smartrecruiters.com/Company`, `company.bamboohr.com/careers`, `company.breezy.hr`, `company.teamtailor.com`, `company.jobs.personio.de` — or an explicit pair like `greenhouse:stripe` or `breezy:embraer`.

## `titleIncludes` (type: `array`):

Only keep jobs whose title contains at least one of these terms (case-insensitive), e.g. `engineer`, `sales`.

## `titleExcludes` (type: `array`):

Drop jobs whose title contains any of these terms (case-insensitive), e.g. `intern`, `staff`.

## `locationIncludes` (type: `array`):

Only keep jobs whose location contains at least one of these, e.g. `london`, `spain`, `remote`.

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

Keep only postings detected as remote.

## `newJobsOnly` (type: `boolean`):

Remember which postings were already seen (per dedup key) and return only newly published ones. Perfect for scheduled monitoring + alerts.

## `dedupKey` (type: `string`):

Namespace for the 'new jobs only' memory. Use a different key per watchlist/schedule.

## `includeDescription` (type: `boolean`):

Include the plain-text job description (where the ATS provides it in the board feed).

## `descriptionMaxLength` (type: `integer`):

Truncate description text to this many characters.

## `maxJobsPerCompany` (type: `integer`):

0 = unlimited.

## `maxItems` (type: `integer`):

0 = unlimited. You are only charged for job postings actually returned.

## `maxConcurrency` (type: `integer`):

Companies processed in parallel.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/openai"
  ],
  "remoteOnly": false,
  "newJobsOnly": false,
  "dedupKey": "default",
  "includeDescription": true,
  "descriptionMaxLength": 5000,
  "maxJobsPerCompany": 0,
  "maxItems": 0,
  "maxConcurrency": 4
}
```

# 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 = {
    "companies": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/openai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leohryndev/ats-job-postings-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 = { "companies": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/openai",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("leohryndev/ats-job-postings-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 '{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/openai"
  ]
}' |
apify call leohryndev/ats-job-postings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Postings Scraper — Greenhouse, Lever, Ashby + 7 More ATSs",
        "description": "Scrape job postings from any company career board on 10 ATS platforms — Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, Breezy, BambooHR, Teamtailor, Personio — via official public feeds. One normalized format, remote detection, and a new-jobs-only monitoring mode.",
        "version": "1.0",
        "x-build-id": "9Csy7wXaGmrrXXvaG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leohryndev~ats-job-postings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leohryndev-ats-job-postings-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/leohryndev~ats-job-postings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-leohryndev-ats-job-postings-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/leohryndev~ats-job-postings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-leohryndev-ats-job-postings-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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Company job boards",
                        "minItems": 1,
                        "type": "array",
                        "description": "One per line: a job-board URL from any supported ATS — `boards.greenhouse.io/stripe`, `jobs.lever.co/netflix`, `jobs.ashbyhq.com/openai`, `apply.workable.com/company`, `company.recruitee.com`, `careers.smartrecruiters.com/Company`, `company.bamboohr.com/careers`, `company.breezy.hr`, `company.teamtailor.com`, `company.jobs.personio.de` — or an explicit pair like `greenhouse:stripe` or `breezy:embraer`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "titleIncludes": {
                        "title": "Title must contain (any of)",
                        "type": "array",
                        "description": "Only keep jobs whose title contains at least one of these terms (case-insensitive), e.g. `engineer`, `sales`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "titleExcludes": {
                        "title": "Title must NOT contain",
                        "type": "array",
                        "description": "Drop jobs whose title contains any of these terms (case-insensitive), e.g. `intern`, `staff`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationIncludes": {
                        "title": "Location must contain (any of)",
                        "type": "array",
                        "description": "Only keep jobs whose location contains at least one of these, e.g. `london`, `spain`, `remote`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only postings detected as remote.",
                        "default": false
                    },
                    "newJobsOnly": {
                        "title": "Only NEW jobs since the last run",
                        "type": "boolean",
                        "description": "Remember which postings were already seen (per dedup key) and return only newly published ones. Perfect for scheduled monitoring + alerts.",
                        "default": false
                    },
                    "dedupKey": {
                        "title": "Dedup key",
                        "type": "string",
                        "description": "Namespace for the 'new jobs only' memory. Use a different key per watchlist/schedule.",
                        "default": "default"
                    },
                    "includeDescription": {
                        "title": "Include job description text",
                        "type": "boolean",
                        "description": "Include the plain-text job description (where the ATS provides it in the board feed).",
                        "default": true
                    },
                    "descriptionMaxLength": {
                        "title": "Description max length",
                        "minimum": 100,
                        "type": "integer",
                        "description": "Truncate description text to this many characters.",
                        "default": 5000
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = unlimited.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = unlimited. You are only charged for job postings actually returned.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Companies processed in parallel.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
