# UK Tyre Price & Fitment Monitor (`zhorex/tyre-price-monitor`) Actor

The whole priced tyre shelf for any UK fitment size: brand, pattern, fitted and mail-order price, EU label grades, noise, season, runflat, load and speed rating, shelf position and earliest fitting date. Delta mode returns only the lines that moved.

- **URL**: https://apify.com/zhorex/tyre-price-monitor.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 tyre shelf rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Tyre Price & Fitment Monitor — The Whole Shelf, By Size (2026)

One request returns the **entire priced shelf for a tyre fitment size**: every brand and pattern on offer with its **fitted price and mail-order price**, the fitting premium between them, EU label grades, exterior noise, season, runflat flag, load index, speed rating, shelf position and the earliest fitting date advertised.

Turn on delta mode and a daily schedule returns only the lines that **moved** — which is what a repricing desk actually reads.

No login. No API key. No browser. Clean JSON / CSV / Excel, billed per row you receive.

### How to use it

1. **Find your sizes.** Mode `size_index` returns all **782 fitment sizes** the retailer catalogues.
2. **Sweep the ones you sell.** Mode `size_sweep` with `205/55R16`, `195/65R15`, … — any common notation works (`205-55-16`, `205 55 16`).
3. **Schedule it with `deltaMode: true`** and you get a movement feed instead of last night's shelf again.

### What a row gives you

| Field | Why it matters |
|---|---|
| `fittedPrice` / `mailOrderPrice` / `fittingPremium` | Both published prices and the gap between them — the fitting premium is the number UK buyers compare and almost nobody publishes as a field |
| `brand`, `pattern`, `season` | Kumho / Ecowing ES31 / Summer — the line identity, not just a product title |
| `euFuelGrade`, `euWetGripGrade`, `noiseDb`, `noiseClass` | The EU label, parsed out of the page rather than left as an image |
| `runflat`, `loadIndex`, `speedRating` | The spec attributes that decide whether a tyre is even a substitute |
| `shelfPosition` | Where the line sits on the shelf — visibility, not just price |
| `earliestFittingDate` | The soonest fitting slot advertised for that tyre |
| `promotion` | The multi-buy offer attached to the line |

```json
{
    "retailer": "blackcircles",
    "size": "205-55-16",
    "sku": "37163882",
    "brand": "Kumho",
    "pattern": "Ecowing ES31",
    "season": "Summer",
    "fittedPrice": 69.99,
    "mailOrderPrice": 51.09,
    "fittingPremium": 18.90,
    "currency": "GBP",
    "euFuelGrade": "B",
    "euWetGripGrade": "B",
    "noiseDb": 70,
    "noiseClass": "B",
    "runflat": false,
    "loadIndex": 91,
    "speedRating": "V",
    "shelfPosition": 1,
    "earliestFittingDate": "2026-07-29",
    "promotion": "2tyre10-4tyre20",
    "scrapedAt": "2026-07-25T21:10:00Z"
}
````

### Delta mode — bills for movement, not for re-reading

| `changeType` | Meaning |
|---|---|
| `price_up` / `price_down` | Fitted price moved, with `priceChange` and `priceChangePct` |
| `promo_change` | The multi-buy promotion on the line changed |
| `rank_change` | Shelf position moved by three slots or more, with `positionChange` |
| `new` | Line appeared on this size's shelf |
| `withdrawn` | Line was on this shelf and is gone from a size this run swept |

Every change carries its previous values, so a row explains itself without a join. Unchanged lines are **not returned and not charged**, and a baseline run is billed at the ordinary row rate — starting a monitor should not cost more than running it.

```json
{
    "mode": "size_sweep",
    "sizes": ["205/55R16", "195/65R15", "225/45R17", "215/55R17"],
    "deltaMode": true,
    "deltaStateKey": "my-core-sizes"
}
```

### Who this is for

| Buyer | Job |
|---|---|
| **Independent fitters and tyre chains** | Reprice your core sizes against the market leader's actual fitted price, daily, without checking by hand |
| **Tyre brands and importers** | Where your patterns sit on the shelf, at what price, against which competitor, and when a rival discounts |
| **Mobile fitting and fleet services** | The fitted-vs-mail-order gap by size — that spread is the whole business case for mobile fitting |
| **Retail and automotive analysts** | Seasonal price movement and label-grade mix as a consumer-spend read |
| **Comparison and content sites** | A clean spec-plus-price feed with EU label data already parsed |

### Sizing your run

Rows = **sizes × postcodes**, one request each, roughly 20-25 distinct tyres per shelf.

| Setup | Requests | Rows | At $0.005/row |
|---|---|---|---|
| 5 core sizes, one-off | 5 | ~110 | $0.55 |
| 40 sizes, daily snapshot | 40/day | ~900/day | $4.50/day |
| 40 sizes, daily **with delta** | 40/day | only the movers | typically a small fraction |
| Full catalogue sweep (782 sizes) | 782 | ~17,000 | $85 |

A run is capped at 1,200 requests so a typo cannot launch a runaway sweep.

### Pricing

| Event | Price | What it is |
|---|---|---|
| `tyre-price-row` | **$0.005** | One tyre on one size's shelf, full spec and both prices |
| `price-change` | **$0.012** | One line that moved in delta mode, with its previous values |
| `size-record` | **$0.001** | One fitment size from the catalogue index |

Shelves that fail to fetch are pushed as error records with the reason and are **never charged**.

### Limitations, stated plainly

- **This is one UK retailer's shelf**, done properly — not a multi-retailer index. It is the market leader's online fitted-price shelf, which is what most UK repricing is benchmarked against, but it is one source and the `retailer` field says so on every row.
- **Postcodes do not change the fitting date.** Tested rather than assumed: London (SW1A1AA) and Edinburgh (EH11AA) returned identical dates. The postcode input exists to reproduce what a customer in an area is quoted; it is not sold as a per-area availability signal.
- **Promoted tyres are listed twice** by the source — the same SKU in the highlighted strip and in the main list, identical except position. They are collapsed to one row, so you are never billed twice for one tyre.
- **Paging parameters are ignored by the site.** Coverage scales by size, not by paging, and this Actor does not pretend otherwise.
- **No history before your first run.** Prices cannot be backfilled by anyone.
- **If the retailer ever refuses a run** (403/429), the run fails **loudly** with that reason and charges nothing for the refused shelves. A GB datacenter proxy group is the fix; residential is not required.

### FAQ

**Do I need a proxy?** Not from a normal IP — verified with no challenge and no rate limiting. See the note above for the 403 case.

**Why are there ~21 tyres per size and not 200?** That is the shelf the retailer actually shows for a fitment. Coverage grows by adding sizes, which is how the pricing scales too.

**Can I get winter and all-season?** They are on the same shelf; filter on `season`.

**Why is my first delta run large?** It is the baseline, and it is billed at the row rate. From the second run you only get movement.

### Other scrapers by Zhorex

- [DE/AT Pharmacy Price & Stock Monitor](https://apify.com/zhorex/pharmacy-price-monitor) — the same delta pattern on OTC pharmacy shelves
- [Hostelworld Rate & Availability Monitor](https://apify.com/zhorex/hostelworld-rate-monitor) — forward-dated accommodation rates
- [Resy Availability & Scarcity Monitor](https://apify.com/zhorex/resy-availability-monitor) — restaurant availability by date

### Legal

This Actor reads publicly visible commercial product data: tyre specifications, prices, promotions and shelf positions. It collects no personal data and performs no purchases. Respect the retailer's terms and applicable law in your jurisdiction, and use the data for analysis rather than redistribution.

# Actor input Schema

## `mode` (type: `string`):

'Sweep sizes' returns the full priced shelf for each fitment size you list — one request per size, no paging. 'Size index' returns every size the retailer catalogues (782 of them) so you can pick the ones you actually sell.

## `sizes` (type: `array`):

Fitment sizes in any common notation — 205/55R16, 205-55-16 or '205 55 16' all work. Each size is one request and returns that whole shelf (about 20-25 distinct tyres). Leave empty and it sweeps the five most common UK car fitments as a demo.

## `postcodes` (type: `array`):

Adds a postcode to each request. Tested honestly: the earliest fitting date came back IDENTICAL for London (SW1A1AA) and Edinburgh (EH11AA), so do not expect a per-area signal — this exists so you can reproduce exactly what a customer in a given area is quoted, and it multiplies your rows by the number of postcodes.

## `deltaMode` (type: `boolean`):

Turn this on for a repricing cron. The first run records a baseline (billed at the ordinary row rate, never the change rate); every later run returns and bills ONLY what moved — fitted price up or down with the delta, a promotion change, a shelf-position shift of three slots or more, and fitments withdrawn from a shelf they were on. Unchanged lines are never returned and never charged.

## `deltaStateKey` (type: `string`):

Names an independent delta stream so several monitors don't collide (e.g. 'my-core-sizes' vs 'winter-range'). Only used when Delta mode is on.

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

Not needed from a residential IP, where this was verified with no challenge and no rate limiting. If the retailer ever refuses your runs with a 403, the run says so explicitly (it does not return an empty shelf) and a GB DATACENTER proxy group is the fix — residential is not required.

## Actor input object example

```json
{
  "mode": "size_sweep",
  "sizes": [
    "205/55R16",
    "225/45R17",
    "215/55R17"
  ],
  "postcodes": [
    "SW1A1AA",
    "EH11AA"
  ],
  "deltaMode": false,
  "deltaStateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "mode": "size_sweep",
    "sizes": [
        "205/55R16",
        "195/65R15"
    ],
    "deltaStateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/tyre-price-monitor").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 = {
    "mode": "size_sweep",
    "sizes": [
        "205/55R16",
        "195/65R15",
    ],
    "deltaStateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/tyre-price-monitor").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 '{
  "mode": "size_sweep",
  "sizes": [
    "205/55R16",
    "195/65R15"
  ],
  "deltaStateKey": "default"
}' |
apify call zhorex/tyre-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zhorex/tyre-price-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Tyre Price & Fitment Monitor",
        "description": "The whole priced tyre shelf for any UK fitment size: brand, pattern, fitted and mail-order price, EU label grades, noise, season, runflat, load and speed rating, shelf position and earliest fitting date. Delta mode returns only the lines that moved.",
        "version": "0.1",
        "x-build-id": "ZHHzEDAegHIjX0Ll2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~tyre-price-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-tyre-price-monitor",
                "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/zhorex~tyre-price-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-tyre-price-monitor",
                "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/zhorex~tyre-price-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-tyre-price-monitor",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "size_sweep",
                            "size_index"
                        ],
                        "type": "string",
                        "description": "'Sweep sizes' returns the full priced shelf for each fitment size you list — one request per size, no paging. 'Size index' returns every size the retailer catalogues (782 of them) so you can pick the ones you actually sell.",
                        "default": "size_sweep"
                    },
                    "sizes": {
                        "title": "Tyre sizes",
                        "type": "array",
                        "description": "Fitment sizes in any common notation — 205/55R16, 205-55-16 or '205 55 16' all work. Each size is one request and returns that whole shelf (about 20-25 distinct tyres). Leave empty and it sweeps the five most common UK car fitments as a demo.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postcodes": {
                        "title": "Postcodes (optional)",
                        "type": "array",
                        "description": "Adds a postcode to each request. Tested honestly: the earliest fitting date came back IDENTICAL for London (SW1A1AA) and Edinburgh (EH11AA), so do not expect a per-area signal — this exists so you can reproduce exactly what a customer in a given area is quoted, and it multiplies your rows by the number of postcodes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deltaMode": {
                        "title": "Delta mode — only the lines that MOVED",
                        "type": "boolean",
                        "description": "Turn this on for a repricing cron. The first run records a baseline (billed at the ordinary row rate, never the change rate); every later run returns and bills ONLY what moved — fitted price up or down with the delta, a promotion change, a shelf-position shift of three slots or more, and fitments withdrawn from a shelf they were on. Unchanged lines are never returned and never charged.",
                        "default": false
                    },
                    "deltaStateKey": {
                        "title": "Delta stream name",
                        "type": "string",
                        "description": "Names an independent delta stream so several monitors don't collide (e.g. 'my-core-sizes' vs 'winter-range'). Only used when Delta mode is on.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Not needed from a residential IP, where this was verified with no challenge and no rate limiting. If the retailer ever refuses your runs with a 403, the run says so explicitly (it does not return an empty shelf) and a GB DATACENTER proxy group is the fix — residential is not required.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
