# levels.fyi Salary Scraper — Tech Compensation Data (`memo23/levels-fyi-salary-scraper`) Actor

Scrape individual salary & total-compensation records from levels.fyi by company slug, company-salaries URL, or job-family URL. One flat row per submission: title, level, focus, years of experience, base, stock, bonus, total comp, location & demographics. JSON/CSV.

- **URL**: https://apify.com/memo23/levels-fyi-salary-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Jobs, AI, Agents
- **Stats:** 3 total users, 2 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.

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 💰

![How the levels.fyi Salary Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-levels-fyi.png)

Pull **real, individual salary and total-compensation records** from [levels.fyi](https://www.levels.fyi) — the community-sourced database that tech workers use to benchmark pay. Feed it a company slug (`google`, `meta`, `amazon`), a company-salaries URL, or a specific job-family URL, and get back one clean, flat row per submission: company, title, level, focus, years of experience, base / stock / bonus, total comp, location, work arrangement and self-reported demographics.

No login, no browser automation, no manual copy-paste from tables — just structured JSON/CSV you can drop straight into a spreadsheet, a comp model, or a dashboard.

---

### 💡 Why use this scraper

- **Individual records, not just averages.** Most levels.fyi views show medians. This actor harvests the underlying per-submission samples — the raw data points behind the charts.
- **Benchmark compensation** across companies, levels and locations for offer negotiation, comp-band design or market research.
- **Whole-company sweeps.** Give it just `google` and it walks every job family (Software Engineer, Product Manager, Data Scientist, Sales, and 50+ more) automatically.
- **Rich per-row detail** — base salary, average annual stock, bonus, total comp, first-year figures, focus tag (e.g. Machine Learning), years of experience / at company / at level, work arrangement, and demographics when the submitter shared them.
- **Fast & reliable** — pure HTTP over residential IPs against the embedded page data; typical runs finish in seconds.

---

### 📋 What you can scrape

| Input | Example | What you get |
|-------|---------|--------------|
| **Company slug** | `google` | Every job family on Google's salaries page → all individual records |
| **Company-salaries URL** | `https://www.levels.fyi/companies/meta/salaries` | Same as above, from a pasted URL |
| **Job-family URL** | `https://www.levels.fyi/companies/amazon/salaries/software-engineer` | Just that one role's individual records |
| **Job-family filter** | `["software-engineer", "product-manager"]` | Restrict a company sweep to specific roles |

---

### 🔧 Input

| Field | Type | Description |
|-------|------|-------------|
| `companySlugs` | array | Company slugs, e.g. `["google", "meta", "amazon"]`. Each expands to every job family on that company's salaries page. |
| `startUrls` | array | Company-salaries URLs and/or specific job-family salary URLs. Auto-classified. |
| `jobFamilies` | array | Optional filter — only scrape these job-family slugs (e.g. `software-engineer`, `data-scientist`). Empty = all. |
| `maxItems` | integer | Hard cap on total rows for the run. |
| `maxItemsPerCompany` | integer | Cap records harvested per company. |
| `maxConcurrency` | integer | Parallel requests (default 6). |
| `proxy` | object | Free-tier proxy config (defaults to Apify Residential, US). Paid runs use a built-in US residential pool. |

#### Example input

```json
{
  "companySlugs": ["google", "meta"],
  "jobFamilies": ["software-engineer", "product-manager"],
  "maxItems": 2000
}
````

***

### ⚙️ How it works

1. **Company page** — for each company slug / URL, the actor loads `/companies/{slug}/salaries` and reads the embedded page data to enumerate every job family listed for that company.
2. **Job-family pages** — it then visits each `/companies/{slug}/salaries/{jobFamily}` page and extracts the individual salary submissions embedded in the page's data payload (grouped by company level).
3. **Flat rows** — every submission becomes one dataset row with a stable `uuid`, so re-runs and multi-family sweeps deduplicate cleanly.

All requests go through US residential proxies with automatic session rotation and retries on rate-limits, so runs stay reliable at scale.

***

### 📤 Output

Each row is one individual compensation submission:

```json
{
  "rowType": "salary",
  "uuid": "6e828129-7eb5-400f-8c56-85f9c6379956",
  "company": "Google",
  "companySlug": "google",
  "title": "Software Engineer",
  "jobFamily": "Software Engineer",
  "jobFamilySlug": "software-engineer",
  "level": "L3",
  "levelName": "L3",
  "focusTag": "Full Stack",
  "yearsOfExperience": 0,
  "yearsAtCompany": 0,
  "yearsAtLevel": null,
  "offerDate": "2026-06-07T05:33:59.048Z",
  "location": "Pittsburgh, PA",
  "countryId": 254,
  "dmaId": 508,
  "workArrangement": "hybrid",
  "compPerspective": "offer",
  "employmentType": "full_time",
  "baseSalary": 139000,
  "totalCompensation": 159000,
  "avgAnnualStockGrantValue": 20000,
  "avgAnnualBonusValue": 0,
  "gender": "female",
  "ethnicity": null,
  "education": null,
  "sourceUrl": "https://www.levels.fyi/companies/google/salaries/software-engineer",
  "scrapedAt": "2026-07-06T03:19:23.279Z"
}
```

#### Key output fields

| Field | Meaning |
|-------|---------|
| `uuid` | Stable levels.fyi submission id (dedup key) |
| `company` / `title` / `level` | Company, role and company-native level (L3, E5, …) |
| `focusTag` | Specialization (e.g. Machine Learning, Full Stack) |
| `yearsOfExperience` / `yearsAtCompany` / `yearsAtLevel` | Experience context |
| `baseSalary` / `avgAnnualStockGrantValue` / `avgAnnualBonusValue` | Comp breakdown |
| `totalCompensation` | Headline total comp |
| `firstYearTotalCompensation` | First-year total (where reported) |
| `location` / `workArrangement` / `compPerspective` | Where, how and offer-vs-current |
| `gender` / `ethnicity` / `education` | Self-reported demographics (when shared) |
| `offerDate` | When the offer/submission was dated |

***

### ❓ FAQ

**Are these individual data points or averages?**
Individual submissions. The actor pulls the underlying per-record samples behind levels.fyi's charts, so you can slice and aggregate them yourself.

**Which companies are supported?**
Any company on levels.fyi. Use the slug from the URL — `https://www.levels.fyi/companies/**stripe**/salaries` → `stripe`.

**Which job families can I scrape?**
Whatever the company page lists — Software Engineer, Product Manager, Software Engineering Manager, Data Scientist, Hardware Engineer, Sales, Recruiter, Technical Program Manager and dozens more. Leave `jobFamilies` empty to grab them all.

**Is the money in USD?**
Amounts are the values levels.fyi stores for each record. For US roles that is USD. International records carry their own currency where levels.fyi provides it.

**How much data can I get per company?**
levels.fyi surfaces a bounded set of recent sample records per level, so expect dozens to a few hundred individual records per company depending on how many families and levels it has.

***

### 🛟 Support

Run into a company that won't parse, a field you need added, or a schema question? Open an issue on the actor's Issues tab with the input you used — most requests are quick fixes.

***

### ⚠️ Disclaimer

This actor collects **publicly available** compensation data from levels.fyi for research, benchmarking and analytics. It does not access any login-gated content and stores no personal-account data. Individual submissions on levels.fyi are self-reported and anonymized by the source. You are responsible for using the scraped data in compliance with levels.fyi's Terms of Service and all applicable laws (including data-protection regulations). This actor is not affiliated with, endorsed by, or sponsored by levels.fyi.

***

### 🔎 SEO Keywords

levels.fyi scraper, levels fyi salary scraper, tech salary data, total compensation scraper, tech comp benchmarking, software engineer salary data, FAANG salary scraper, compensation dataset, salary benchmarking API, levels.fyi API, stock and bonus data, tech pay data, salary negotiation data, comp band research, levels fyi companies salaries.

# Actor input Schema

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

levels.fyi company slugs, e.g. `google`, `meta`, `amazon`, `microsoft`. Each expands to every job family on that company's salaries page (unless you filter with Job families below).

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

Company-salaries URLs (`https://www.levels.fyi/companies/{company}/salaries`) and/or specific job-family salary URLs (`https://www.levels.fyi/companies/{company}/salaries/software-engineer`). Auto-classified.

## `jobFamilies` (type: `array`):

Optional. Only scrape these job-family slugs on each company, e.g. `software-engineer`, `product-manager`, `data-scientist`, `software-engineering-manager`. Leave empty to scrape every job family the company page lists.

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

Hard cap on rows across the entire run. Each row is one paid `salary` event. Free-tier users are additionally capped at 100.

## `maxItemsPerCompany` (type: `integer`):

Cap the number of salary records harvested per company (across all its job families). Default 100000 (effectively unlimited).

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

Parallel HTTP requests across job-family pages. Default 6.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh residential IP. Default 12.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "companySlugs": [
    "google"
  ],
  "startUrls": [],
  "jobFamilies": [],
  "maxItems": 100000,
  "maxItemsPerCompany": 100000,
  "maxConcurrency": 6,
  "maxRequestRetries": 12
}
```

# 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 = {
    "companySlugs": [
        "google"
    ],
    "startUrls": [],
    "jobFamilies": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "companySlugs": ["google"],
    "startUrls": [],
    "jobFamilies": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "companySlugs": [
    "google"
  ],
  "startUrls": [],
  "jobFamilies": []
}' |
apify call memo23/levels-fyi-salary-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "levels.fyi Salary Scraper — Tech Compensation Data",
        "description": "Scrape individual salary & total-compensation records from levels.fyi by company slug, company-salaries URL, or job-family URL. One flat row per submission: title, level, focus, years of experience, base, stock, bonus, total comp, location & demographics. JSON/CSV.",
        "version": "0.1",
        "x-build-id": "R99sSjiRgFi6TlBHh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~levels-fyi-salary-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~levels-fyi-salary-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~levels-fyi-salary-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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": {
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "levels.fyi company slugs, e.g. `google`, `meta`, `amazon`, `microsoft`. Each expands to every job family on that company's salaries page (unless you filter with Job families below).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "levels.fyi URLs",
                        "type": "array",
                        "description": "Company-salaries URLs (`https://www.levels.fyi/companies/{company}/salaries`) and/or specific job-family salary URLs (`https://www.levels.fyi/companies/{company}/salaries/software-engineer`). Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobFamilies": {
                        "title": "Job families (filter)",
                        "type": "array",
                        "description": "Optional. Only scrape these job-family slugs on each company, e.g. `software-engineer`, `product-manager`, `data-scientist`, `software-engineering-manager`. Leave empty to scrape every job family the company page lists.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `salary` event. Free-tier users are additionally capped at 100.",
                        "default": 100000
                    },
                    "maxItemsPerCompany": {
                        "title": "Max records per company",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap the number of salary records harvested per company (across all its job families). Default 100000 (effectively unlimited).",
                        "default": 100000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests across job-family pages. Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh residential IP. Default 12.",
                        "default": 12
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
