# Indeed Jobs Scraper (Cheap) (`data_api/indeed-jobs-scraper-cheap`) Actor

Pulls job listings from Indeed by keyword, location, or company name. Run multiple searches at once and get titles, salaries, apply links, and posting dates back as structured data.

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## Indeed Job Listings Scraper

![Indeed Job Listings Scraper](cover.jpg)

Searching Indeed by hand gets old fast. You click through page after page, copy out a title here and a pay range there, then start over for the next city. This scraper handles that part. Give it a keyword and a place, and it returns the role title, employer, pay range, location, how recently the job went up, and a direct apply link as structured data. Pass it a few keywords and a few cities at once and every combination lands in one dataset, ready to export.

### What you get

Every job card on the results page becomes one row with the same shape, so your columns stay predictable when you load them into a sheet or database. Anything the listing did not show comes back as `null` rather than dropping out. Each row carries:

- **The role** — `roleTitle`, `summaryText`, `employmentType`, `remoteFriendly`, `payRange`
- **The employer** — `employerName`, `employerRating`
- **Where and when** — `workLocation`, `listedDate`
- **How to apply** — `applyUrl`, `quickApply`
- **Tracking** — `postingId`, `collectedAt`

### Quick start

1. Open the input form and type a role into **Keyword** (or paste several into **Keywords**).
2. Set a **Place**, or leave it empty to search everywhere. Add more under **Places** if you want several cities at once.
3. Optionally narrow things with **Posted within**, **Employment type**, or **Remote only**, or point **Employer** at one company.
4. Press **Start**, then export the dataset as JSON, CSV, Excel, or XML once the run finishes.

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

### Use cases

- **Recruiters** checking what a rival is hiring for this week without paging through the site by hand.
- **Job-market analysts** watching how demand for a skill shifts from one city to the next.
- **Compensation teams** building a pay benchmark from the ranges employers actually posted.
- **Developers** wiring a feed of fresh listings into alerts or a job board.
- **Career coaches** pulling current openings for a client across a few target markets in one pass.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `keyword` | string | One of `keyword` or `employer` | A single role or search term, e.g. `backend developer`. Merged with `keywords` when both are set. |
| `keywords` | array of strings | Optional | A batch of search terms, one per line; each runs as its own search. |
| `employer` | string | One of `keyword` or `employer` | Limit results to a company's Indeed page. Switches to the `/cmp/{company}/jobs` route and skips the open search. |
| `place` | string | No | A city, state, country, or `Remote`. Leave empty to cover everywhere. |
| `places` | array of strings | No | Several areas to cover in one run, one per line. Merged with `place` when both are set. |
| `postedWithin` | string | No | Recency window: `any`, `last24h`, `last3days`, `last7days`, or `last14days`. Default `any`. |
| `employmentType` | string | No | Contract filter: `any`, `fulltime`, `parttime`, `contract`, `temporary`, or `internship`. Default `any`. |
| `remoteOnly` | boolean | No | Keep only remote or work-from-home roles. Default `false`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `120`; raise it if later pages return 502s. |

#### Example input

```json
{
    "keyword": "backend developer",
    "place": "Austin",
    "postedWithin": "last7days",
    "employmentType": "fulltime",
    "remoteOnly": false,
    "timeoutSeconds": 120
}
````

Run several searches across several cities in one go:

```json
{
    "keywords": ["backend developer", "ux designer", "marketing manager"],
    "places": ["Austin", "Remote", "Canada"],
    "postedWithin": "last3days"
}
```

Pull everything from a single company:

```json
{
    "employer": "Microsoft",
    "place": "Austin"
}
```

### Output

Each job card on the results page becomes one row, and every field is always present — values the listing did not carry come back as `null` so the dataset stays rectangular.

#### Example output

```json
{
    "postingId": "abc123def456",
    "roleTitle": "Senior Backend Developer",
    "employerName": "Acme Corp",
    "employerRating": 4.2,
    "workLocation": "Austin, TX",
    "payRange": "$130,000 - $160,000 a year",
    "employmentType": "full-time",
    "remoteFriendly": false,
    "listedDate": "2 days ago",
    "summaryText": "We are looking for a Senior Backend Developer to join our growing platform team...",
    "applyUrl": "https://www.indeed.com/viewjob?jk=abc123def456",
    "quickApply": true,
    "collectedAt": "2026-06-29T10:30:00+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `postingId` | string | Indeed's unique identifier for the listing. |
| `roleTitle` | string | Position title as written by the employer. |
| `employerName` | string | Name of the hiring company. |
| `employerRating` | number | Company star rating when shown, e.g. `3.8`. |
| `workLocation` | string | City, state, or country attached to the role. |
| `payRange` | string | Posted pay if listed, e.g. `$80,000-$120,000 a year`. |
| `employmentType` | string | Contract kind such as full-time or contract. |
| `remoteFriendly` | boolean | `true` when the listing reads as remote or work-from-home. |
| `listedDate` | string | Relative posting date, e.g. `3 days ago`. |
| `summaryText` | string | Short description shown on the results card. |
| `applyUrl` | string | Direct link to the job detail and apply page. |
| `quickApply` | boolean | `true` when Indeed's quick-apply flow is offered. |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured. |

### Tips for best results

- **Test with one keyword first.** Run a single search before a wide sweep so URL or location quirks show up early.
- **Combine keywords and places to cover a market.** Three keywords across three cities gives you nine searches in one dataset — useful for comparing the same role between markets.
- **Reach for `employer` for a single company.** Drop a company name in and the scraper reads its `/cmp` page instead of the open search.
- **Expect blanks on sparse cards.** Pay and rating are not on every listing; those fields return `null` and that is normal, not a failure.
- **Raise `timeoutSeconds` if later pages stall.** Push it toward 180 when you see repeated 502s deeper into a run.

### How can I use Indeed job data?

**How can I use the Indeed Job Listings Scraper to track hiring demand across cities?**
Put your target roles in `keywords` and your markets in `places`. The scraper runs every keyword-and-city pair and returns each listing's title, employer, pay range, and location in one dataset. Group the rows by `workLocation` to compare how demand for a skill differs from one city to the next.

**How do I scrape Indeed jobs from one specific company?**
Set `employer` to the company name. The scraper switches to that company's `/cmp` page and returns its current openings with titles, locations, pay, and apply links — handy for keeping tabs on a competitor's hiring or researching an employer before you apply.

**How can I build a salary benchmark from Indeed listings?**
Search a role across your markets and read the `payRange` field, which carries the pay an employer actually posted. Filter with `employmentType` and `postedWithin` to keep the sample current, then export to CSV or Excel to chart pay by city or contract type.

**How do I export Indeed job data for analysis?**
Every run writes to an Apify dataset you can download as JSON, CSV, Excel, or XML from the Storage tab. Each row follows the same schema, so it drops straight into a spreadsheet, a database, or a BI tool with no reshaping.

### Is it legal to scrape data?

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

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

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

### Support

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

# Actor input Schema

## `keyword` (type: `string`):

One role or search term to look up, for example 'backend developer'. To fire off several searches in a single run, use 'Keywords' below instead.

## `keywords` (type: `array`):

A batch of search terms, one per line. Every line becomes its own search. If 'Keyword' is also set, it is merged into this list.

## `employer` (type: `string`):

Limit results to a named company's Indeed page, for example 'Microsoft' or 'Netflix'. When set, the scraper switches to the /cmp/{company}/jobs route and skips the open keyword search.

## `place` (type: `string`):

A single city, state, country, or the word 'Remote'. Leave it empty to cover everywhere. For more than one area, fill in 'Places' below.

## `places` (type: `array`):

Several areas to cover in one run, one per line. Each line runs as its own search. A value in 'Place' is folded into this list when both are present.

## `postedWithin` (type: `string`):

Keep only listings published inside the chosen recency window.

## `employmentType` (type: `string`):

Narrow results to one kind of contract.

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

Turn on to keep only remote or work-from-home roles.

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

How long to wait on each request before giving up. Push it to 120-180 if later pages start returning 502 errors.

## Actor input object example

```json
{
  "keyword": "ux designer",
  "keywords": [
    "backend developer",
    "ux designer",
    "marketing manager"
  ],
  "employer": "Microsoft",
  "place": "Canada",
  "places": [
    "Austin",
    "Canada",
    "Remote"
  ],
  "postedWithin": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "timeoutSeconds": 120
}
```

# 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 = {
    "keyword": "backend developer",
    "place": "Austin",
    "postedWithin": "any",
    "employmentType": "any"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keyword": "backend developer",
    "place": "Austin",
    "postedWithin": "any",
    "employmentType": "any",
}

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

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

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

```

## CLI example

```bash
echo '{
  "keyword": "backend developer",
  "place": "Austin",
  "postedWithin": "any",
  "employmentType": "any"
}' |
apify call data_api/indeed-jobs-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper (Cheap)",
        "description": "Pulls job listings from Indeed by keyword, location, or company name. Run multiple searches at once and get titles, salaries, apply links, and posting dates back as structured data.",
        "version": "0.0",
        "x-build-id": "yhmjYcBGobtfh7F0h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~indeed-jobs-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-indeed-jobs-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/data_api~indeed-jobs-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-indeed-jobs-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/data_api~indeed-jobs-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-indeed-jobs-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "One role or search term to look up, for example 'backend developer'. To fire off several searches in a single run, use 'Keywords' below instead."
                    },
                    "keywords": {
                        "title": "Keywords (multiple)",
                        "type": "array",
                        "description": "A batch of search terms, one per line. Every line becomes its own search. If 'Keyword' is also set, it is merged into this list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "employer": {
                        "title": "Employer",
                        "type": "string",
                        "description": "Limit results to a named company's Indeed page, for example 'Microsoft' or 'Netflix'. When set, the scraper switches to the /cmp/{company}/jobs route and skips the open keyword search."
                    },
                    "place": {
                        "title": "Place",
                        "type": "string",
                        "description": "A single city, state, country, or the word 'Remote'. Leave it empty to cover everywhere. For more than one area, fill in 'Places' below."
                    },
                    "places": {
                        "title": "Places (multiple)",
                        "type": "array",
                        "description": "Several areas to cover in one run, one per line. Each line runs as its own search. A value in 'Place' is folded into this list when both are present.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "last24h",
                            "last3days",
                            "last7days",
                            "last14days"
                        ],
                        "type": "string",
                        "description": "Keep only listings published inside the chosen recency window.",
                        "default": "any"
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "enum": [
                            "any",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Narrow results to one kind of contract.",
                        "default": "any"
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Turn on to keep only remote or work-from-home roles.",
                        "default": false
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 30,
                        "maximum": 300,
                        "type": "integer",
                        "description": "How long to wait on each request before giving up. Push it to 120-180 if later pages start returning 502 errors.",
                        "default": 120
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
