# UK Jobs Aggregator (`crawlerbros/uk-jobs-aggregator`) Actor

Aggregate UK and EU job listings from RemoteOK, Arbeitnow, Reed.co.uk, and Adzuna (optional API key for extra countries). Filter by role, location, country, employment type, date posted, and salary. Enriched output with structured salary plus company logo, website, size, and socials.

- **URL**: https://apify.com/crawlerbros/uk-jobs-aggregator.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## UK Jobs Aggregator

Search jobs across multiple boards in one call. Aggregates from RemoteOK, Arbeitnow (Germany / EU), Reed.co.uk (UK), and optionally Adzuna (any country with a free API key). HTTP-only — no proxy, no browser, no login.

### What it does

You provide a job role keyword and a country; the actor queries every applicable source in parallel, normalises every posting to a single shape, optionally drops cross-board duplicates, and emits one record per unique job.

**Active sources by country:**

| Source | Type | UK | DE | Remote |
|---|---|---|---|---|
| RemoteOK | Public JSON API | always | always | always |
| Arbeitnow | Public JSON API | always | always | always |
| Reed.co.uk | HTML scrape (card DOM) | ✅ | – | – |
| Adzuna | Optional API key | ✅ (with key) | ✅ (with key) | ✅ (with key) |

**Sources NOT included** (require residential proxy or auth that conflicts with the HTTP-only design):

- *GOV.UK Find a Job* — DWP's WAF blocks datacenter IPs with a generic error page. Re-enable would need a residential proxy.
- *Indeed (any region)* — heavy anti-bot, blocks datacenter IPs.
- *TotalJobs / CV-Library / CWJobs* — anti-bot.
- *USAJobs* — requires a free dev API key (not currently exposed as input). For US coverage, supply Adzuna keys.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `jobRole` | string (required) | `software engineer` | Free-text role keyword. |
| `location` | string | `London` | City / region. UK boards use it; remote-only sources ignore it. |
| `country` | enum: `UK` / `DE` / `Remote` | `UK` | Determines country-specific boards. RemoteOK + Arbeitnow always run regardless. |
| `maxResults` | integer | `50` (1–1000) | Hard cap on records emitted across all sources. |
| `minSalary` | integer (optional) | – | Drop postings whose `salary_max` is below this threshold. Postings with no salary are kept. |
| `jobType` | enum: `All` / `Permanent` / `Contract` / `Temporary` / `PartTime` | `All` | Employment-type filter. |
| `datePosted` | enum: `Any` / `Today` / `LastThreeDays` / `LastWeek` / `LastTwoWeeks` | `Any` | Recency filter — drop postings older than the chosen window. Postings without a `date_posted` are kept. |
| `removeDuplicates` | boolean | `true` | Collapse duplicates across boards by (title, company, locality). |
| `adzunaAppId` | string (Secret, optional) | – | Adzuna app ID — sign up free at https://developer.adzuna.com/ |
| `adzunaAppKey` | string (Secret, optional) | – | Companion to `adzunaAppId`. Both required to enable Adzuna. |

#### Example input

```json
{
  "jobRole": "software engineer",
  "location": "London",
  "country": "UK",
  "maxResults": 100,
  "minSalary": 40000,
  "jobType": "Permanent",
  "removeDuplicates": true
}
````

### Output

One record per unique job. Empty fields are omitted (no nulls).

```json
{
  "title": "Junior Software Engineer",
  "company": "TechCorp Ltd",
  "location": "London, Greater London",
  "salary_min": 30000,
  "salary_max": 40000,
  "salary_average": 35000,
  "salary_currency": "GBP",
  "salary_period": "year",
  "employment_type": "FULL_TIME",
  "description": "Build great products with a small distributed team.",
  "url": "https://www.reed.co.uk/jobs/junior-software-engineer/12345",
  "job_id": "12345",
  "date_posted": "2024-12-15",
  "isRemote": false,
  "source": "reed.co.uk",
  "country": "UK",
  "companyLogo": "https://cdn.example.com/logos/techcorp.png",
  "companyWebsite": "https://techcorp.example.com",
  "companyDescription": "TechCorp builds developer tools used by 50,000+ teams.",
  "companySize": "51-200",
  "companySocialLinks": {"linkedin": "techcorp", "twitter": "techcorp"},
  "scrapedAt": "2024-12-16T14:23:11+00:00"
}
```

#### Output fields

- **`title`** — job title.
- **`company`** — hiring company.
- **`location`** — city / region as reported by the source (may include country).
- **`salary_min`** / **`salary_max`** / **`salary_currency`** / **`salary_period`** — parsed pay range. `salary_period` is one of `hour` / `day` / `week` / `month` / `year`. Currency is `GBP` / `USD` / `EUR` / etc. All four are absent when the source doesn't publish salary.
- **`salary_average`** — derived: mean of `salary_min` and `salary_max` when both are present. Useful for sorting/filtering across postings that report a range.
- **`salary_raw`** — original salary string (GOV.UK only — others only ship structured salary).
- **`employment_type`** — e.g. `Permanent`, `Contract`, `Full Time`. Source-specific casing preserved.
- **`description`** — opening snippet of the job description (truncated at 2000 chars).
- **`url`** — direct link to the posting.
- **`job_id`** — source-specific stable ID.
- **`date_posted`** — ISO date (`YYYY-MM-DD`) when the source published the listing.
- **`isRemote`** — `true` when the location string contains "remote" or the source flags the role as remote.
- **`source`** — `remoteok.com`, `arbeitnow.com`, `reed.co.uk`, `findajob.dwp.gov.uk`, or `adzuna.com`.
- **`country`** — `UK`, `DE`, `Remote`, or whatever country code Adzuna was queried with.
- **Company enrichment** (when source ships JSON-LD `hiringOrganization`): `companyLogo`, `companyWebsite`, `companyDescription`, `companySize`, `companySocialLinks` (flat dict of `{platform: handle}`). Fields are omitted per posting when the underlying source doesn't expose them.
- **`scrapedAt`** — ISO-8601 timestamp.

### FAQ

**Does it need a proxy?**
No. All five sources are public and accessible from Apify's datacenter IPs without proxy.

**Why only 3 country options?**
Indeed and TotalJobs aggressively block datacenter IPs without residential proxy — to keep this actor reliable and cheap, we restrict to sources that work directly. To cover the US, France, Australia, etc., supply Adzuna API keys (free 250 calls/month at developer.adzuna.com).

**How does deduplication work?**
Records are grouped by `(title, company, location's first comma-segment)`, all lowercased. The first occurrence wins. Disable with `removeDuplicates: false` if you'd rather see every source's listing.

**RemoteOK shows `0` for unknown salary — does the actor filter those out?**
Yes. Both `salary_min: 0` and `salary_max: 0` are treated as "not provided" and the salary fields are omitted from the record entirely.

**Can I filter by salary?**
Set `minSalary` to a number. Postings with a parsed `salary_max` below that threshold are dropped. Postings without salary information are kept (you can't filter on data that isn't there).

**Why is `description` capped at 2000 characters?**
Aggregator boards typically only ship the first paragraph or two as a snippet anyway, and 2000 chars is plenty for screening. Combine the `url` field with a downstream actor for full-page descriptions.

**Is the search exact-match?**
No — the role keyword is matched loosely (case-insensitive substring against title, tags, and description start). RemoteOK and Arbeitnow return wide result sets; the keyword filter lets you target your role within the firehose.

# Actor input Schema

## `jobRole` (type: `string`):

What kind of job to search for. Free-text — passed verbatim to each source's search API.

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

City or region. UK boards interpret this as a UK city; remote-only boards (RemoteOK) ignore it.

## `country` (type: `string`):

Determines which country-specific boards are queried (RemoteOK and Arbeitnow run on every search regardless of country). For US results, supply Adzuna keys below.

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

Hard cap on the total number of unique job records emitted across all sources.

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

Drop jobs whose parsed `salary_max` is below this threshold. Jobs with no salary info are kept regardless. Currency follows the source (GBP for UK, USD for US, EUR for DE).

## `jobType` (type: `string`):

Filter by employment type. "All" disables the filter (default).

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

Recency filter. Jobs without a parseable date are kept regardless.

## `removeDuplicates` (type: `boolean`):

Drop near-duplicate postings across boards (same title + company + location).

## `adzunaAppId` (type: `string`):

Optional. Sign up at https://developer.adzuna.com/ for free 250 calls/month. With both `adzunaAppId` and `adzunaAppKey` set, Adzuna is added as a 6th source covering UK / US / many other countries.

## `adzunaAppKey` (type: `string`):

Companion to `adzunaAppId`. Both must be set to enable Adzuna.

## Actor input object example

```json
{
  "jobRole": "software engineer",
  "location": "London",
  "country": "UK",
  "maxResults": 50,
  "jobType": "All",
  "datePosted": "Any",
  "removeDuplicates": true
}
```

# 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 = {
    "jobRole": "software engineer",
    "location": "London",
    "country": "UK",
    "maxResults": 50,
    "jobType": "All"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/uk-jobs-aggregator").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 = {
    "jobRole": "software engineer",
    "location": "London",
    "country": "UK",
    "maxResults": 50,
    "jobType": "All",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/uk-jobs-aggregator").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 '{
  "jobRole": "software engineer",
  "location": "London",
  "country": "UK",
  "maxResults": 50,
  "jobType": "All"
}' |
apify call crawlerbros/uk-jobs-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Jobs Aggregator",
        "description": "Aggregate UK and EU job listings from RemoteOK, Arbeitnow, Reed.co.uk, and Adzuna (optional API key for extra countries). Filter by role, location, country, employment type, date posted, and salary. Enriched output with structured salary plus company logo, website, size, and socials.",
        "version": "0.1",
        "x-build-id": "zN9doH2efcdclq5OR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~uk-jobs-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-uk-jobs-aggregator",
                "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/crawlerbros~uk-jobs-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-uk-jobs-aggregator",
                "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/crawlerbros~uk-jobs-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-uk-jobs-aggregator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "jobRole"
                ],
                "properties": {
                    "jobRole": {
                        "title": "Job role / keyword",
                        "type": "string",
                        "description": "What kind of job to search for. Free-text — passed verbatim to each source's search API."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region. UK boards interpret this as a UK city; remote-only boards (RemoteOK) ignore it."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "UK",
                            "DE",
                            "Remote"
                        ],
                        "type": "string",
                        "description": "Determines which country-specific boards are queried (RemoteOK and Arbeitnow run on every search regardless of country). For US results, supply Adzuna keys below.",
                        "default": "UK"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the total number of unique job records emitted across all sources.",
                        "default": 50
                    },
                    "minSalary": {
                        "title": "Minimum salary (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop jobs whose parsed `salary_max` is below this threshold. Jobs with no salary info are kept regardless. Currency follows the source (GBP for UK, USD for US, EUR for DE)."
                    },
                    "jobType": {
                        "title": "Employment type",
                        "enum": [
                            "All",
                            "Permanent",
                            "Contract",
                            "Temporary",
                            "PartTime"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. \"All\" disables the filter (default).",
                        "default": "All"
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "Any",
                            "Today",
                            "LastThreeDays",
                            "LastWeek",
                            "LastTwoWeeks"
                        ],
                        "type": "string",
                        "description": "Recency filter. Jobs without a parseable date are kept regardless.",
                        "default": "Any"
                    },
                    "removeDuplicates": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "Drop near-duplicate postings across boards (same title + company + location).",
                        "default": true
                    },
                    "adzunaAppId": {
                        "title": "Adzuna App ID (optional)",
                        "type": "string",
                        "description": "Optional. Sign up at https://developer.adzuna.com/ for free 250 calls/month. With both `adzunaAppId` and `adzunaAppKey` set, Adzuna is added as a 6th source covering UK / US / many other countries."
                    },
                    "adzunaAppKey": {
                        "title": "Adzuna App Key (optional)",
                        "type": "string",
                        "description": "Companion to `adzunaAppId`. Both must be set to enable Adzuna."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
