# Levels.fyi Salary Scraper (`automation-lab/levels-fyi-salary-scraper`) Actor

Extract public Levels.fyi salary samples by company, role, level, location, base pay, stock, bonus, and total compensation.

- **URL**: https://apify.com/automation-lab/levels-fyi-salary-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.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

## Levels.fyi Salary Scraper

Extract structured compensation samples from public Levels.fyi salary pages.

Use this actor to collect salary benchmarks by company, role, level, location, experience, base pay, stock, bonus, and total compensation.

### What does Levels.fyi Salary Scraper do?

Levels.fyi Salary Scraper reads public company salary pages such as `https://www.levels.fyi/companies/google/salaries/software-engineer` and turns the embedded compensation records into clean dataset rows.

It is designed for compensation research, recruiting intelligence, salary benchmarking, and talent-market analysis.

The actor uses HTTP extraction from the page data already delivered to the browser. It does not require a login for public salary pages.

### Who is it for?

- 💼 Recruiters comparing offer competitiveness across target employers.
- 📊 Compensation analysts building pay bands from market signals.
- 🧑‍💼 HR and People Ops teams reviewing leveling and location trends.
- 🏢 Startup founders planning engineering salary budgets.
- 🔎 Researchers studying total compensation by level, role, and geography.
- 🧰 Data teams feeding salary records into BI dashboards or spreadsheets.

### Why use this Levels.fyi scraper?

Levels.fyi pages are useful, but manual copy-paste is slow and inconsistent.

This actor gives you repeatable exports with normalized fields:

- company and role context
- level and focus tag
- years of experience
- years at company
- offer date
- location identifiers
- base salary
- total compensation
- stock grant value
- bonus value
- level average compensation
- source URL and scrape timestamp

### Data you can extract

| Field | Description |
| --- | --- |
| `uuid` | Public sample identifier when present |
| `company` | Company name |
| `companySlug` | Levels.fyi company slug |
| `role` | Salary sample title |
| `jobFamily` | Job family shown on the page |
| `jobFamilySlug` | Job-family slug from the URL/page data |
| `level` | Company level, for example L3 or L5 |
| `focusTag` | Specialization tag when available |
| `location` | Location label |
| `dmaId` | Location DMA identifier when present |
| `countryId` | Country identifier when present |
| `yearsOfExperience` | Candidate experience at offer time |
| `yearsAtCompany` | Tenure at the company |
| `yearsAtLevel` | Tenure at level when present |
| `offerDate` | Offer/sample date |
| `baseSalary` | Base salary amount |
| `totalCompensation` | Total yearly compensation |
| `avgAnnualStockGrantValue` | Annualized stock/equity value |
| `avgAnnualBonusValue` | Annualized bonus value |
| `currency` | Currency code inferred from the page/sample |
| `gender` | Gender field if present in the public sample |
| `employmentType` | Employment type when present |
| `workArrangement` | Remote/hybrid/on-site signal when present |
| `levelSampleCount` | Number of samples in the level band |
| `levelAverageBaseSalary` | Average base salary for the level |
| `levelAverageStockGrant` | Average stock value for the level |
| `levelAverageBonus` | Average bonus value for the level |
| `levelAverageTotalCompensation` | Average total compensation for the level |
| `levelPageUrl` | Public level-specific page URL |
| `sourceUrl` | Salary page scraped |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Levels.fyi salary data?

The actor uses pay-per-event pricing:

- $0.005 start fee per run
- formula-derived tiered per-result pricing for each salary sample saved
- BRONZE per-result price: $0.0001 per salary sample (platform minimum adjustment above the formula floor)

You only pay for records produced. Use a small `maxSamplesPerPage` during testing, then increase it for production benchmarking.

### How to use this actor

1. Open the actor on Apify.
2. Add one or more public Levels.fyi salary URLs.
3. Optionally add company slugs and job-family slugs.
4. Set `maxSamplesPerPage`.
5. Run the actor.
6. Export results as JSON, CSV, Excel, or via the Apify API.

### Input options

#### Levels.fyi salary page URLs

Use `startUrls` when you already know exact pages.

Example:

```json
{
  "startUrls": [
    { "url": "https://www.levels.fyi/companies/google/salaries/software-engineer" }
  ],
  "maxSamplesPerPage": 50
}
````

#### Company and job-family slugs

Use slugs to generate URLs automatically.

```json
{
  "companySlugs": ["google", "meta", "microsoft"],
  "jobFamilySlugs": ["software-engineer", "product-manager"],
  "maxSamplesPerPage": 100
}
```

#### Raw sample JSON

Enable `includeRawSample` only if you need the original embedded object for custom mapping.

### Output example

```json
{
  "company": "Google",
  "role": "Software Engineer",
  "level": "L4",
  "location": "Los Angeles, CA",
  "yearsOfExperience": 14,
  "yearsAtCompany": 5,
  "baseSalary": 180000,
  "totalCompensation": 220000,
  "avgAnnualStockGrantValue": 40000,
  "avgAnnualBonusValue": 0,
  "currency": "USD",
  "sourceUrl": "https://www.levels.fyi/companies/google/salaries/software-engineer",
  "scrapedAt": "2026-05-26T00:00:00.000Z"
}
```

### Tips for better results

- Start with one URL and a low sample limit.
- Use public company salary pages, not login-only pages.
- Combine company slugs and job families for batch research.
- Keep `includeRawSample` disabled unless you need debugging details.
- Export CSV for spreadsheet review.
- Export JSON for data pipelines.

### Integrations

Use the dataset with:

- Google Sheets or Excel compensation models.
- Airtable recruiting research bases.
- BigQuery, Snowflake, or Postgres salary warehouses.
- HR analytics dashboards.
- Recruiting market intelligence workflows.
- Apify webhooks for scheduled refreshes.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/levels-fyi-salary-scraper').call({
  startUrls: [{ url: 'https://www.levels.fyi/companies/google/salaries/software-engineer' }],
  maxSamplesPerPage: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/levels-fyi-salary-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.levels.fyi/companies/google/salaries/software-engineer'}],
    'maxSamplesPerPage': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~levels-fyi-salary-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"companySlugs":["google"],"jobFamilySlugs":["software-engineer"],"maxSamplesPerPage":50}'
```

### MCP usage

Connect the actor through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/levels-fyi-salary-scraper`

Claude Code setup:

```bash
claude mcp add apify-levels-fyi-salary "https://mcp.apify.com/?tools=automation-lab/levels-fyi-salary-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-levels-fyi-salary": {
      "url": "https://mcp.apify.com/?tools=automation-lab/levels-fyi-salary-scraper"
    }
  }
}
```

Example prompts:

- "Scrape Google software engineer salary samples from Levels.fyi and summarize median total compensation."
- "Compare public Levels.fyi salary samples for Google and Microsoft software engineers."
- "Export Levels.fyi product manager salary records as CSV-ready data."

### Scheduling

Schedule daily, weekly, or monthly runs in Apify Console when you need fresh compensation data.

For salary benchmarking, monthly refreshes are often enough.

For recruiting campaigns, weekly refreshes can catch new samples sooner.

### Data quality notes

The actor extracts public user-submitted compensation samples. Treat them as market signals, not payroll-certified data.

Use filters and aggregation to reduce outlier impact.

Compare multiple companies, levels, and locations before making compensation decisions.

### FAQ

#### Is Levels.fyi Salary Scraper free to try?

You can run a small test with a low `maxSamplesPerPage` value to estimate output volume and cost before scaling up.

#### Can I scrape multiple companies in one run?

Yes. Add multiple company slugs and job-family slugs, or provide multiple exact salary page URLs.

### Troubleshooting

#### The actor returned no results

Check that the URL is a public salary page using the `/companies/{company}/salaries/{job-family}` pattern.

#### I received fewer records than expected

Levels.fyi may expose a limited number of public samples on a page. Increase `maxSamplesPerPage`, add more pages, or use more company/job-family combinations.

#### Some fields are null

Not every public sample includes every attribute. Null values mean the field was absent in the page data.

### Legality and responsible use

This actor extracts publicly available page data. You are responsible for using exported data in a way that complies with applicable laws, contracts, privacy rules, and Levels.fyi terms.

Do not use salary data to make discriminatory decisions.

Do not attempt to scrape private, login-only, or access-controlled data.

### Related scrapers

Other Automation Lab actors that may complement this workflow:

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/company-employee-scraper

### Changelog

#### 0.1

Initial actor for public Levels.fyi salary sample extraction.

### Support

If a public salary URL fails, include the input URL, run ID, and expected company/role in your support request.

### Summary

Levels.fyi Salary Scraper helps teams turn public compensation pages into structured salary datasets for benchmarking, recruiting, and workforce planning.

# Actor input Schema

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

Public Levels.fyi salary URLs such as https://www.levels.fyi/companies/google/salaries/software-engineer. You can combine these with company slugs below.

## `companySlugs` (type: `array`):

Levels.fyi company slugs to build salary URLs from, for example google, meta, microsoft, amazon, apple.

## `jobFamilySlugs` (type: `array`):

Role/job-family slugs to combine with each company slug. Defaults to software-engineer when omitted.

## `maxSamplesPerPage` (type: `integer`):

Maximum compensation sample records to save from each salary page.

## `includeRawSample` (type: `boolean`):

Adds the original embedded Levels.fyi sample object for debugging or custom downstream mapping. Keep disabled for cleaner exports.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.levels.fyi/companies/google/salaries/software-engineer"
    }
  ],
  "companySlugs": [
    "google"
  ],
  "jobFamilySlugs": [
    "software-engineer"
  ],
  "maxSamplesPerPage": 20,
  "includeRawSample": false
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.levels.fyi/companies/google/salaries/software-engineer"
        }
    ],
    "companySlugs": [
        "google"
    ],
    "jobFamilySlugs": [
        "software-engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/levels-fyi-salary-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 = {
    "startUrls": [{ "url": "https://www.levels.fyi/companies/google/salaries/software-engineer" }],
    "companySlugs": ["google"],
    "jobFamilySlugs": ["software-engineer"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/levels-fyi-salary-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 '{
  "startUrls": [
    {
      "url": "https://www.levels.fyi/companies/google/salaries/software-engineer"
    }
  ],
  "companySlugs": [
    "google"
  ],
  "jobFamilySlugs": [
    "software-engineer"
  ]
}' |
apify call automation-lab/levels-fyi-salary-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/levels-fyi-salary-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Levels.fyi Salary Scraper",
        "description": "Extract public Levels.fyi salary samples by company, role, level, location, base pay, stock, bonus, and total compensation.",
        "version": "0.1",
        "x-build-id": "m64fxnsHkDYYEGiYa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~levels-fyi-salary-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-levels-fyi-salary-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/automation-lab~levels-fyi-salary-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-levels-fyi-salary-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/automation-lab~levels-fyi-salary-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-levels-fyi-salary-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": {
                    "startUrls": {
                        "title": "Levels.fyi salary page URLs",
                        "type": "array",
                        "description": "Public Levels.fyi salary URLs such as https://www.levels.fyi/companies/google/salaries/software-engineer. You can combine these with company slugs below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "Levels.fyi company slugs to build salary URLs from, for example google, meta, microsoft, amazon, apple.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobFamilySlugs": {
                        "title": "Job family slugs",
                        "type": "array",
                        "description": "Role/job-family slugs to combine with each company slug. Defaults to software-engineer when omitted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSamplesPerPage": {
                        "title": "Maximum salary samples per page",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum compensation sample records to save from each salary page.",
                        "default": 20
                    },
                    "includeRawSample": {
                        "title": "Include raw sample JSON",
                        "type": "boolean",
                        "description": "Adds the original embedded Levels.fyi sample object for debugging or custom downstream mapping. Keep disabled for cleaner exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
