# NHS Jobs Scraper (Cheap) (`data_api/nhs-jobs-scraper-cheap`) Actor

NHS Jobs Scraper that pulls vacancy listings from jobs.nhs.uk by keyword, location, and filter, so recruiters and analysts get clean structured job data without manual searching.

- **URL**: https://apify.com/data\_api/nhs-jobs-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## NHS Jobs Scraper

Searching jobs.nhs.uk by hand means clicking through page after page of results and copying out each role one cell at a time. This scraper does that part for you. Give it a search term such as "nurse" or "physiotherapist", add an area if you want one, and it walks the NHS Jobs results and returns every vacancy as a clean row: role title, employer, salary, location, contract, closing date, and a direct link to the advert. Run one search or queue dozens of term-and-area pairs in a single go.

![NHS Jobs Scraper](cover.jpg)

### What you get

Every vacancy comes back as one row with the same set of columns, so the results drop straight into a spreadsheet or database. Each row carries:

- **The role** — `roleTitle`, `employerName`, `workLocation`, `payRange`, `contractKind`, `workSchedule`
- **Dates and reference** — `postedDate`, `applyByDate`, `vacancyRef`, `listingUrl`
- **Search context** — `queryTerm` and `queryArea` so you can tell which search produced each row, plus a `collectedAt` timestamp

### Quick start

1. Click **Try for free** and open the input form.
2. Type your searches into **Search terms**, one per line (for example `midwife`).
3. Optional: add a matching **Search area** on the same line, then set a **Radius**, a salary band, or a contract filter.
4. Set **Results per search term** to cap how many jobs each search returns.
5. Hit **Start**, then download the results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Recruitment agencies** — track new NHS vacancies by role and region and feed them into your candidate pipeline
- **Job boards and aggregators** — keep a fresh feed of NHS listings without manual copy-paste
- **Workforce planning** — watch which trusts are hiring, for what, and at what salary over time
- **Salary benchmarking** — pull pay ranges across a role or band to compare against your own offers
- **Locum and bank staffing** — filter to Locum or Bank contracts and surface short-term openings fast
- **Career research** — gather every matching role in your area into one list instead of scrolling the site

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | One job search per line. Each line pairs with the area on the same row in `searchAreas`. Prefill `healthcare assistant`. |
| `searchAreas` | array of strings | No | One town, city, or postcode per line, matched by row to `searchTerms`. Leave empty to search the whole UK. |
| `searchRadius` | integer | No | How far from each area to look, in miles (5, 10, 20, 30, 50, or 100). Default `20`. |
| `employerFilter` | string | No | Limit results to a single employer or NHS Trust by name. |
| `contractKindFilter` | string | No | Keep only one contract type (Permanent, Locum, Bank, and so on). Default is all contracts. |
| `workScheduleFilter` | string | No | Keep only one work schedule (Full time, Part time, Flexible working, and so on). Default is all schedules. |
| `minSalary` | integer | No | Lowest annual salary to include. Default `0` for no lower bound. |
| `maxSalary` | integer | No | Highest annual salary to include. Default `0` for no upper bound. |
| `firstPage` | integer | No | Results page to start from, per search row. Default `1`. Use it to resume a stopped run. |
| `resultsLimit` | integer | No | Jobs to collect per search row. Default `50`; three terms at 50 gathers up to 150 jobs. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `45`. |

#### Example input

```json
{
    "searchTerms": ["healthcare assistant", "physiotherapist", "midwife"],
    "searchAreas": ["Leeds", "Bristol", "Glasgow"],
    "searchRadius": 20,
    "contractKindFilter": "Permanent",
    "workScheduleFilter": "full-time",
    "minSalary": 30000,
    "maxSalary": 55000,
    "firstPage": 1,
    "resultsLimit": 50,
    "timeoutSeconds": 45
}
````

### Output

Each vacancy is one row, and the columns are the same on every row. Fields with nothing to show come back as `null` so the dataset stays rectangular.

#### Example output

```json
{
    "roleTitle": "Band 5 Physiotherapist",
    "listingUrl": "https://www.jobs.nhs.uk/candidate/jobadvert/C9123-25-4567",
    "vacancyRef": "C9123-25-4567",
    "employerName": "Leeds Teaching Hospitals NHS Trust",
    "workLocation": "Leeds, LS1 3EX",
    "payRange": "£29,970 to £36,483 a year",
    "postedDate": "12 June 2026",
    "applyByDate": "30 June 2026",
    "contractKind": "Permanent",
    "workSchedule": "Full time",
    "queryTerm": "physiotherapist",
    "queryArea": "Leeds",
    "collectedAt": "2026-06-29T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `roleTitle` | string | Vacancy title as shown on NHS Jobs |
| `listingUrl` | string | Direct link to the full job advert |
| `vacancyRef` | string | NHS Jobs reference code from the advert link |
| `employerName` | string | Hiring organisation or NHS Trust |
| `workLocation` | string | Town, city, or postcode for the role |
| `payRange` | string | Salary text as printed on the listing |
| `postedDate` | string | When the advert went live |
| `applyByDate` | string | Application closing date |
| `contractKind` | string | Contract on offer, such as Permanent or Locum |
| `workSchedule` | string | Hours pattern, such as Full time or Part time |
| `queryTerm` | string | The search term that produced the row |
| `queryArea` | string | Area paired with the term; `null` when none was given |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |

### Tips for best results

- **Start with one search.** Run a single term against a single area first to confirm the output looks right, then scale up.
- **Match your rows.** Search terms and areas pair by line number, so keep them aligned. A term with no area on its row searches the whole UK.
- **Cap each search with `resultsLimit`.** Keep it low while you test, then raise it for the full pull. Remember the cap counts per search row, not per run.
- **Use the salary band to cut noise.** Set `minSalary` and `maxSalary` to focus on a specific pay bracket instead of wading through every result.
- **Resume long runs with `firstPage`.** If a run stops part way, set the starting page to pick up roughly where it left off.

### How can I use NHS Jobs data?

**How can I use the NHS Jobs Scraper to build a recruitment feed?**
Queue the roles you place for, like `nurse`, `healthcare assistant`, and `radiographer`, across the areas you cover. Set a sensible `resultsLimit` and run it on a schedule. Each run hands back every matching vacancy with the employer, salary, location, and a link to the advert, ready to load into your applicant tracking system.

**How can I scrape NHS job vacancies for salary benchmarking?**
Search a single role and read the `payRange` field across the results. Because every row carries the contract, schedule, and employer too, you can group the pay data by trust or by region and compare it against your own bands without opening a single advert by hand.

**How can I track which NHS Trusts are hiring in my region?**
Add your towns and postcodes to `searchAreas` and set a `searchRadius`. The scraper returns the `employerName` and `workLocation` on every vacancy, so you can count openings per trust, watch demand shift over weeks, and spot which employers are recruiting hardest near you.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchTerms` (type: `array`):

List your job searches one per line. The term on each line is matched against the area on the same line in Search areas, so line 1 here goes with line 1 there (e.g. nurse + London).

## `searchAreas` (type: `array`):

One town, city, or postcode per line, lined up with the search term on the matching row. Leave it empty to cover the whole UK for every term.

## `searchRadius` (type: `integer`):

How far out from each area to look, in miles. Pick one of 5, 10, 20, 30, 50, or 100. The same radius is used for every term and area row.

## `employerFilter` (type: `string`):

Restrict the results to one employer or NHS Trust by name.

## `contractKindFilter` (type: `string`):

Keep only roles on a given contract. Leave it on All to include every contract.

## `workScheduleFilter` (type: `string`):

Keep only roles with a given schedule. Leave it on All to include every schedule.

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

Lowest annual salary to include. Set it to 0 to drop the lower bound.

## `maxSalary` (type: `integer`):

Highest annual salary to include. Set it to 0 to drop the upper bound.

## `firstPage` (type: `integer`):

Which results page to start on. Applied to every search term and area row. Handy for picking up where an earlier run stopped.

## `resultsLimit` (type: `integer`):

How many jobs to pull for each search term and area row. With 3 terms and a value of 50, the run gathers up to 150 jobs in total.

## `timeoutSeconds` (type: `integer`):

How long to wait on each request before giving up.

## Actor input object example

```json
{
  "searchTerms": [
    "healthcare assistant",
    "physiotherapist",
    "midwife"
  ],
  "searchAreas": [
    "Leeds",
    "Bristol",
    "Glasgow"
  ],
  "searchRadius": 20,
  "employerFilter": "Guy's and St Thomas' NHS Foundation Trust",
  "contractKindFilter": "",
  "workScheduleFilter": "",
  "minSalary": 30000,
  "maxSalary": 55000,
  "firstPage": 1,
  "resultsLimit": 10,
  "timeoutSeconds": 45
}
```

# 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 = {
    "searchTerms": [
        "healthcare assistant"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/nhs-jobs-scraper-cheap").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 = { "searchTerms": ["healthcare assistant"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/nhs-jobs-scraper-cheap").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 '{
  "searchTerms": [
    "healthcare assistant"
  ]
}' |
apify call data_api/nhs-jobs-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHS Jobs Scraper (Cheap)",
        "description": "NHS Jobs Scraper that pulls vacancy listings from jobs.nhs.uk by keyword, location, and filter, so recruiters and analysts get clean structured job data without manual searching.",
        "version": "0.0",
        "x-build-id": "6fvVIT9l8VCoBdoz2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~nhs-jobs-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-nhs-jobs-scraper-cheap",
                "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/data_api~nhs-jobs-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-nhs-jobs-scraper-cheap",
                "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/data_api~nhs-jobs-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-nhs-jobs-scraper-cheap",
                "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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "List your job searches one per line. The term on each line is matched against the area on the same line in Search areas, so line 1 here goes with line 1 there (e.g. nurse + London).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchAreas": {
                        "title": "Search areas",
                        "type": "array",
                        "description": "One town, city, or postcode per line, lined up with the search term on the matching row. Leave it empty to cover the whole UK for every term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchRadius": {
                        "title": "Radius in miles",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How far out from each area to look, in miles. Pick one of 5, 10, 20, 30, 50, or 100. The same radius is used for every term and area row.",
                        "default": 20
                    },
                    "employerFilter": {
                        "title": "Employer name",
                        "type": "string",
                        "description": "Restrict the results to one employer or NHS Trust by name.",
                        "default": ""
                    },
                    "contractKindFilter": {
                        "title": "Contract",
                        "enum": [
                            "",
                            "Permanent",
                            "Fixed-Term",
                            "Apprenticeship",
                            "Voluntary",
                            "Locum",
                            "Training",
                            "Secondment",
                            "Honorary",
                            "Bank"
                        ],
                        "type": "string",
                        "description": "Keep only roles on a given contract. Leave it on All to include every contract.",
                        "default": ""
                    },
                    "workScheduleFilter": {
                        "title": "Work schedule",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "job-share",
                            "flexible-working",
                            "remote-working",
                            "compressed-hours",
                            "term-time-hours",
                            "annualised-hours"
                        ],
                        "type": "string",
                        "description": "Keep only roles with a given schedule. Leave it on All to include every schedule.",
                        "default": ""
                    },
                    "minSalary": {
                        "title": "Salary floor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest annual salary to include. Set it to 0 to drop the lower bound.",
                        "default": 0
                    },
                    "maxSalary": {
                        "title": "Salary ceiling",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest annual salary to include. Set it to 0 to drop the upper bound.",
                        "default": 0
                    },
                    "firstPage": {
                        "title": "First page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Which results page to start on. Applied to every search term and area row. Handy for picking up where an earlier run stopped.",
                        "default": 1
                    },
                    "resultsLimit": {
                        "title": "Results per search term",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many jobs to pull for each search term and area row. With 3 terms and a value of 50, the run gathers up to 150 jobs in total.",
                        "default": 10
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout in seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each request before giving up.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
