# LinkedIn Jobs Scraper - No Login, $1/1k (`datasiphon/linkedin-jobs-scraper`) Actor

Scrape LinkedIn job listings from the public jobs index. No login, no cookies, no account risk. Filter by keywords, location, date, job type, experience, and workplace. Optional full job descriptions.

- **URL**: https://apify.com/datasiphon/linkedin-jobs-scraper.md
- **Developed by:** [Kashif Ali](https://apify.com/datasiphon) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## LinkedIn Jobs Scraper — No Login, No Account Risk

**Scrape LinkedIn job listings at scale from the public jobs index. No login, no cookies, no account to get banned.** Filter by keywords, location, date, job type, experience level, and workplace type. Optionally pull each job's full description, seniority, employment type, function, industries, and applicant count.

### What does LinkedIn Jobs Scraper do?

This actor extracts job listings from **[LinkedIn's public jobs search](https://www.linkedin.com/jobs/search/)** — the same logged-out index you see in an incognito window. Because it never logs in, there is **no account at risk** and nothing for LinkedIn to ban. It runs as pure HTTP with a real browser TLS fingerprint, so it is fast and reliable.

Give it search filters or paste a LinkedIn jobs search URL, and it returns clean, structured job data ready for your dataset, CRM, or analytics pipeline. On the Apify platform you get scheduling, API access, exports (JSON/CSV/Excel), and residential proxy support out of the box.

### Why use this scraper?

- **No account risk** — public data only, no cookies, no login, no bans.
- **Structured filters** — keywords, location, date posted, job type, experience, workplace type. No need to hand-craft URLs (but you can).
- **Full job details** — optional one-extra-request enrichment per job for description and criteria.
- **Cheap** — public job data is the lowest-cost LinkedIn target. Built for high volume.
- **Clean output** — deduplicated by job ID, structured fields, ready to use.

Perfect for: job-market research, recruiting and sourcing, competitive hiring analysis, salary benchmarking, building job boards, and lead generation for recruiting agencies.

### How to use it

1. Enter **Keywords** (e.g., `python developer`) and a **Location** (e.g., `London`).
2. Optionally narrow with **Date Posted**, **Job Types**, **Experience Levels**, **Workplace Type**.
3. Set **Maximum Results** (LinkedIn caps each search at ~1000).
4. Leave **Scrape Full Job Details** on for descriptions and criteria, or turn it off for a faster, lighter run.
5. Click **Save & Start**. Results stream into the dataset.

Advanced: paste full LinkedIn jobs search URLs into **Search URLs** (build them in an incognito window, logged out) to override the structured filters.

### Input

| Field | Description |
|---|---|
| `keywords` | Job title or keywords |
| `location` | City, region, or country |
| `datePosted` | any / past_month / past_week / past_24h |
| `jobTypes` | full_time, part_time, contract, temporary, internship, volunteer |
| `experienceLevels` | internship, entry, associate, mid_senior, director, executive |
| `workplaceTypes` | on_site, remote, hybrid |
| `searchUrls` | Advanced: paste full LinkedIn jobs search URLs (overrides filters) |
| `maxResults` | Max jobs per search (≤1000) |
| `scrapeDetails` | Fetch each job's detail page (description + criteria) |
| `proxyConfiguration` | Residential proxies recommended for large runs |

### Output

```json
{
  "jobId": "4425526234",
  "title": "Python Developer",
  "company": "hackajob",
  "companyUrl": "https://uk.linkedin.com/company/hackajob",
  "location": "London, England, United Kingdom",
  "postedDate": "2026-06-08",
  "postedText": "2 weeks ago",
  "jobUrl": "https://www.linkedin.com/jobs/view/4425526234",
  "description": "We are looking for a Python Developer...",
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering and Information Technology",
  "industries": "Software Development",
  "applicants": "Over 200 applicants"
}
````

You can download the dataset as **JSON, CSV, Excel, or XML** from the Storage tab.

### Data fields

| Field | Description |
|---|---|
| `jobId` | LinkedIn job posting ID |
| `title` | Job title |
| `company` / `companyUrl` | Hiring company and its LinkedIn page |
| `location` | Job location |
| `postedDate` / `postedText` | ISO date and relative text |
| `jobUrl` | Direct link to the posting |
| `description` | Full job description (when details enabled) |
| `seniority` | Seniority level |
| `employmentType` | Full-time, contract, etc. |
| `jobFunction` | Job function |
| `industries` | Industry |
| `applicants` | Applicant count when shown |

### How much does it cost to scrape LinkedIn jobs?

Job listings are the cheapest LinkedIn data to scrape because they are fully public. Turn off **Scrape Full Job Details** for the lightest, fastest runs; turn it on when you need descriptions and criteria (one extra request per job).

### Tips

- **Use residential proxies** for large runs — LinkedIn rate-limits datacenter IPs.
- **LinkedIn caps each search at ~1000 results.** To pull more, split into narrower searches (by city, by date window, by job type) and run them as multiple `searchUrls`.
- **Details off = faster + cheaper.** Leave it off if you only need title, company, location, and link.

### FAQ

**Do I need a LinkedIn account?** No. This scrapes the public, logged-out jobs index. No login, no cookies.

**Is this legal?** It scrapes publicly available data. Courts have upheld scraping public LinkedIn data, but you are responsible for complying with applicable laws and LinkedIn's terms for your use case.

**Why am I getting fewer than 1000 results?** LinkedIn's public index caps each individual search. Split into narrower searches to get more coverage.

For bugs or feature requests, open an issue on the actor's Issues tab.

# Actor input Schema

## `keywords` (type: `string`):

Job title or keywords to search for, e.g. "python developer", "product manager".

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

City, region, or country, e.g. "London", "United States", "Remote".

## `datePosted` (type: `string`):

Only jobs posted within this window.

## `jobTypes` (type: `array`):

Filter by employment type.

## `experienceLevels` (type: `array`):

Filter by seniority.

## `workplaceTypes` (type: `array`):

On-site, remote, or hybrid.

## `searchUrls` (type: `array`):

Optional. Paste full LinkedIn jobs search URLs (built in an incognito window, logged out). Overrides the filters above. One search per URL.

## `maxResults` (type: `integer`):

Total jobs to collect across the whole run (deduplicated). With Expand Search on, the actor beats LinkedIn's ~1000-per-search cap by splitting into many narrow searches, so you can ask for far more than 1000.

## `expandSearch` (type: `boolean`):

LinkedIn's public index only returns ~1000 jobs per search. When on, the actor automatically splits your search across experience levels and job types you haven't pinned, then merges and deduplicates - surfacing far more jobs than a single search can. Turn off for one plain search.

## `scrapeDetails` (type: `boolean`):

Fetch each job's detail page for description, seniority, employment type, function, industries, and applicant count. Slower and one extra request per job, but far richer data.

## `minDelay` (type: `integer`):

Lower bound of the random delay between requests.

## `maxDelay` (type: `integer`):

Upper bound of the random delay between requests.

## `proxyConfiguration` (type: `object`):

LinkedIn rate-limits datacenter IPs. Residential proxies recommended for large runs.

## Actor input object example

```json
{
  "keywords": "python developer",
  "location": "United Kingdom",
  "datePosted": "any",
  "maxResults": 100,
  "expandSearch": true,
  "scrapeDetails": true,
  "minDelay": 1,
  "maxDelay": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Scraped LinkedIn job listings deduplicated by job ID

# 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 = {
    "keywords": "python developer",
    "location": "United Kingdom",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasiphon/linkedin-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": "python developer",
    "location": "United Kingdom",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datasiphon/linkedin-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": "python developer",
  "location": "United Kingdom",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datasiphon/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper - No Login, $1/1k",
        "description": "Scrape LinkedIn job listings from the public jobs index. No login, no cookies, no account risk. Filter by keywords, location, date, job type, experience, and workplace. Optional full job descriptions.",
        "version": "1.0",
        "x-build-id": "L2xbe9oTTtBYsrVxh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasiphon~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasiphon-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datasiphon~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datasiphon-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datasiphon~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datasiphon-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title or keywords to search for, e.g. \"python developer\", \"product manager\"."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or country, e.g. \"London\", \"United States\", \"Remote\"."
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "past_month",
                            "past_week",
                            "past_24h"
                        ],
                        "type": "string",
                        "description": "Only jobs posted within this window.",
                        "default": "any"
                    },
                    "jobTypes": {
                        "title": "Job Types",
                        "type": "array",
                        "description": "Filter by employment type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full_time",
                                "part_time",
                                "contract",
                                "temporary",
                                "internship",
                                "volunteer"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Volunteer"
                            ]
                        }
                    },
                    "experienceLevels": {
                        "title": "Experience Levels",
                        "type": "array",
                        "description": "Filter by seniority.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry",
                                "associate",
                                "mid_senior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-Senior",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "workplaceTypes": {
                        "title": "Workplace Type",
                        "type": "array",
                        "description": "On-site, remote, or hybrid.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "on_site",
                                "remote",
                                "hybrid"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        }
                    },
                    "searchUrls": {
                        "title": "Search URLs (advanced override)",
                        "type": "array",
                        "description": "Optional. Paste full LinkedIn jobs search URLs (built in an incognito window, logged out). Overrides the filters above. One search per URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Total jobs to collect across the whole run (deduplicated). With Expand Search on, the actor beats LinkedIn's ~1000-per-search cap by splitting into many narrow searches, so you can ask for far more than 1000.",
                        "default": 100
                    },
                    "expandSearch": {
                        "title": "Expand Search (get past LinkedIn's 1000 cap)",
                        "type": "boolean",
                        "description": "LinkedIn's public index only returns ~1000 jobs per search. When on, the actor automatically splits your search across experience levels and job types you haven't pinned, then merges and deduplicates - surfacing far more jobs than a single search can. Turn off for one plain search.",
                        "default": true
                    },
                    "scrapeDetails": {
                        "title": "Scrape Full Job Details",
                        "type": "boolean",
                        "description": "Fetch each job's detail page for description, seniority, employment type, function, industries, and applicant count. Slower and one extra request per job, but far richer data.",
                        "default": true
                    },
                    "minDelay": {
                        "title": "Min Delay (seconds)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Lower bound of the random delay between requests.",
                        "default": 1
                    },
                    "maxDelay": {
                        "title": "Max Delay (seconds)",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Upper bound of the random delay between requests.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "LinkedIn rate-limits datacenter IPs. Residential proxies recommended for large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
