# Eastern Europe Car Auction Watcher (`mai_amm/eastern-europe-car-auction-watcher`) Actor

Monitor public Eastern and Central European vehicle auction listings, detect new lots, and score auction risk, urgency, and deal potential.

- **URL**: https://apify.com/mai\_amm/eastern-europe-car-auction-watcher.md
- **Developed by:** [wiseld\_squid](https://apify.com/mai_amm) (community)
- **Categories:** SEO tools, Real estate, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.

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

## Eastern Europe Car Auction Watcher

Eastern Europe Car Auction Watcher monitors public vehicle auction listings across Central and Eastern Europe-adjacent auction sources and turns raw lot pages into structured dealer intelligence.

The Actor is built for used-car dealers, exporters, rebuilders, fleet buyers, brokers, and auction analysts who need to spot fresh lots, damaged vehicles, urgent auctions, and high-potential resale candidates before competitors.

### What It Does

- Crawls public car auction listing pages
- Extracts lot title, source, lot ID, country, registration date, mileage, auction type, time remaining, images, and detail metadata
- Opens detail pages when enabled
- Scores each vehicle with `riskScore`, `dealScore`, and `urgencyScore`
- Classifies visible damage and risk signals from public text
- Tracks previous runs and marks lots as `new`, `changed`, or `unchanged`
- Supports preview mode capped at 50 redacted dataset rows and full paid dataset mode

### Supported Sources

The MVP supports:

- `webautobid` public auction listings

The input also supports custom `startUrls`, so additional public auction/listing pages can be tested without code changes.

### Example Input

```json
{
  "accessMode": "preview",
  "sources": ["webautobid"],
  "countries": [],
  "makes": [],
  "maxItems": 50,
  "freePreviewLimit": 50,
  "maxPagesPerSource": 6,
  "includeDetails": true,
  "includeImages": true,
  "monitoring": true
}
````

### Preview And Full Mode

`preview` mode is for evaluation. It writes up to 50 redacted auction rows to the default dataset so they appear in the normal Apify Results tab. It also stores the same rows in the `PREVIEW` key-value-store record for convenience.

`full` mode writes complete rows to the default dataset using `Actor.pushData()`. It is intended for paid Apify usage and can be combined with filters such as `countries`, `makes`, `keywords`, `minDealScore`, and `minRiskScore`.

### Output Fields

Each lot can include:

- `source`
- `lotId`
- `title`
- `url`
- `make`
- `model`
- `variant`
- `year`
- `firstRegistration`
- `mileageKm`
- `country`
- `countryCode`
- `auctionType`
- `timeRemaining`
- `auctionEndsAt`
- `fuelType`
- `bodyType`
- `transmission`
- `imageCount`
- `damageCategory`
- `riskScore`
- `riskSignals`
- `dealScore`
- `dealSignals`
- `urgencyScore`
- `recommendation`
- `firstSeenAt`
- `lastSeenAt`
- `monitoringStatus`
- `isNewLot`

### Example Output

```json
{
  "source": "webautobid",
  "lotId": "22899732",
  "title": "BMW IX3 80KWH AUTO",
  "make": "BMW",
  "model": "BMW IX3 80KWH AUTO",
  "year": 2021,
  "firstRegistration": "2021-09-21",
  "mileageKm": 58587,
  "country": "Belgium",
  "auctionType": "Target auction, standard",
  "timeRemaining": "0 - 12:41:44",
  "damageCategory": "none_detected",
  "riskScore": 10,
  "dealScore": 87,
  "urgencyScore": 80,
  "recommendation": "High-priority watch. Validate fees and set bid ceiling before auction close.",
  "monitoringStatus": "new"
}
```

### Scoring

Risk scoring is heuristic. It looks for visible public signals such as accident language, front/rear/side damage, mechanical defects, flood/water damage, electric battery issues, blind auctions, and high mileage.

Deal scoring is also heuristic. It rewards stronger resale makes, recent model years, moderate mileage, in-demand powertrains, CEE locations, and urgent auctions. High risk reduces the deal score.

Urgency scoring is based on public time remaining.

### Previous-Run Monitoring

When `monitoring` is enabled, the Actor stores lot state in the named key-value store. Future runs compare lot signatures and mark each row as:

- `new`
- `changed`
- `unchanged`

### Suggested Schedule

- Every 2-6 hours for active buyers
- Daily for market research
- Weekly for broad stock-flow analysis

### Limitations

- Some auction platforms require login; this Actor only extracts public data.
- Public listings may hide VIN, final bid, seller identity, or full damage reports.
- Scores are heuristic and should not replace inspection, history checks, transport cost calculation, or repair estimates.
- Source websites may change HTML structure or block requests.
- Auction fees, VAT, import tax, and transport costs are not calculated automatically in this MVP.

### Local Run

```bash
npm install
apify run --input-file INPUT.example.json
```

### Push To Apify

```bash
apify login
apify push
```

# Actor input Schema

## `accessMode` (type: `string`):

Preview mode writes up to 50 redacted auction lots to the default dataset. Full mode writes complete rows to the paid dataset.

## `sources` (type: `array`):

Auction sources to scan. The MVP supports WebAutoBid public auction listings.

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

Optional custom public auction/listing URLs. If empty, the Actor uses built-in source URLs.

## `countries` (type: `array`):

Preferred origin/location countries. Leave empty to accept all detected countries.

## `makes` (type: `array`):

Vehicle makes to include. Leave empty to include all makes.

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

Optional title/description keywords such as xDrive, hybrid, damaged, front damage, accident, electric.

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

Maximum auction lots to save. Preview mode is capped by Free preview limit.

## `freePreviewLimit` (type: `integer`):

Preview mode limit. The Actor saves up to this many redacted rows to the default dataset and PREVIEW record.

## `maxPagesPerSource` (type: `integer`):

Maximum listing pages to crawl per source. Use 0 to continue until max items or no next page.

## `includeDetails` (type: `boolean`):

Open each lot detail page to extract richer metadata and images.

## `includeImages` (type: `boolean`):

Include listing and detail image URLs when available.

## `monitoring` (type: `boolean`):

Compare with previous runs in a named key-value store and mark new/changed/unchanged lots.

## `monitoringStoreName` (type: `string`):

Key-value store name used for previous-run state.

## `minDealScore` (type: `integer`):

Only save lots with dealScore at or above this value.

## `minRiskScore` (type: `integer`):

Only save lots with riskScore at or above this value.

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

Optional proxy settings passed to Crawlee. Leave empty to crawl directly, which usually returns the full WebAutoBid listing page.

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

Maximum concurrent requests.

## Actor input object example

```json
{
  "accessMode": "preview",
  "sources": [
    "webautobid"
  ],
  "countries": [],
  "maxItems": 50,
  "freePreviewLimit": 50,
  "maxPagesPerSource": 6,
  "includeDetails": true,
  "includeImages": true,
  "monitoring": true,
  "monitoringStoreName": "eastern-europe-car-auction-monitoring",
  "minDealScore": 0,
  "minRiskScore": 0,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `results` (type: `string`):

Main dataset view with normalized auction lots, vehicle metadata, country, mileage, scores, monitoring status, and source URLs.

## `signals` (type: `string`):

Dataset view focused on riskScore, riskSignals, dealScore, dealSignals, recommendations, and source URLs.

## `preview` (type: `string`):

Preview-mode backup copy of the redacted rows stored in the PREVIEW key-value-store record.

## `runOutput` (type: `string`):

Compact machine-readable output with saved item count, dataset mode, source coverage, countries, makes, and top risk/deal lots.

# 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 = {
    "sources": [
        "webautobid"
    ],
    "maxItems": 50,
    "freePreviewLimit": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("mai_amm/eastern-europe-car-auction-watcher").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 = {
    "sources": ["webautobid"],
    "maxItems": 50,
    "freePreviewLimit": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("mai_amm/eastern-europe-car-auction-watcher").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 '{
  "sources": [
    "webautobid"
  ],
  "maxItems": 50,
  "freePreviewLimit": 50
}' |
apify call mai_amm/eastern-europe-car-auction-watcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mai_amm/eastern-europe-car-auction-watcher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eastern Europe Car Auction Watcher",
        "description": "Monitor public Eastern and Central European vehicle auction listings, detect new lots, and score auction risk, urgency, and deal potential.",
        "version": "1.0",
        "x-build-id": "DnEtCSzbyAfN7rtFZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mai_amm~eastern-europe-car-auction-watcher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mai_amm-eastern-europe-car-auction-watcher",
                "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/mai_amm~eastern-europe-car-auction-watcher/runs": {
            "post": {
                "operationId": "runs-sync-mai_amm-eastern-europe-car-auction-watcher",
                "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/mai_amm~eastern-europe-car-auction-watcher/run-sync": {
            "post": {
                "operationId": "run-sync-mai_amm-eastern-europe-car-auction-watcher",
                "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": [
                    "accessMode"
                ],
                "properties": {
                    "accessMode": {
                        "title": "Access mode",
                        "enum": [
                            "preview",
                            "full"
                        ],
                        "type": "string",
                        "description": "Preview mode writes up to 50 redacted auction lots to the default dataset. Full mode writes complete rows to the paid dataset.",
                        "default": "preview"
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Auction sources to scan. The MVP supports WebAutoBid public auction listings.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "webautobid"
                        ]
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional custom public auction/listing URLs. If empty, the Actor uses built-in source URLs.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Public auction or listing page URL to crawl."
                                },
                                "source": {
                                    "type": "string",
                                    "title": "Source",
                                    "description": "Optional source label, for example webautobid."
                                }
                            }
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Preferred origin/location countries. Leave empty to accept all detected countries.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "makes": {
                        "title": "Makes",
                        "type": "array",
                        "description": "Vehicle makes to include. Leave empty to include all makes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional title/description keywords such as xDrive, hybrid, damaged, front damage, accident, electric.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum auction lots to save. Preview mode is capped by Free preview limit.",
                        "default": 50
                    },
                    "freePreviewLimit": {
                        "title": "Free preview limit",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Preview mode limit. The Actor saves up to this many redacted rows to the default dataset and PREVIEW record.",
                        "default": 50
                    },
                    "maxPagesPerSource": {
                        "title": "Max pages per source",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum listing pages to crawl per source. Use 0 to continue until max items or no next page.",
                        "default": 6
                    },
                    "includeDetails": {
                        "title": "Include details",
                        "type": "boolean",
                        "description": "Open each lot detail page to extract richer metadata and images.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Include images",
                        "type": "boolean",
                        "description": "Include listing and detail image URLs when available.",
                        "default": true
                    },
                    "monitoring": {
                        "title": "Monitoring mode",
                        "type": "boolean",
                        "description": "Compare with previous runs in a named key-value store and mark new/changed/unchanged lots.",
                        "default": true
                    },
                    "monitoringStoreName": {
                        "title": "Monitoring store name",
                        "type": "string",
                        "description": "Key-value store name used for previous-run state.",
                        "default": "eastern-europe-car-auction-monitoring"
                    },
                    "minDealScore": {
                        "title": "Minimum deal score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only save lots with dealScore at or above this value.",
                        "default": 0
                    },
                    "minRiskScore": {
                        "title": "Minimum risk score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only save lots with riskScore at or above this value.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings passed to Crawlee. Leave empty to crawl directly, which usually returns the full WebAutoBid listing page."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum concurrent requests.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
