# BOVAG Vehicle Listings Scraper (`automation-lab/bovag-vehicle-listings-scraper`) Actor

Scrape public viaBOVAG car listings with prices, specs, mileage, images, warranty labels, and dealer contact details.

- **URL**: https://apify.com/automation-lab/bovag-vehicle-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## BOVAG Vehicle Listings Scraper

Scrape public vehicle listings from viaBOVAG.nl and export structured Dutch marketplace data for analysis, monitoring, pricing, and lead workflows.

The actor reads viaBOVAG search or category URLs, paginates the public listing results, extracts the server-rendered Next.js listing data, and saves one dataset row per vehicle.

### What does BOVAG Vehicle Listings Scraper do?

BOVAG Vehicle Listings Scraper collects public vehicle listings from viaBOVAG search pages.

It can extract:

- 🚗 Listing title and URL
- 💶 Price and VAT flag
- 🏷️ Make, model, body type, fuel, transmission, color, and year
- 🧭 Mileage and mileage unit
- 🏢 Dealer name, city, phone, and website
- 🖼️ Listing image URL
- ✅ BOVAG, warranty, return warranty, service, and certainty labels
- 🔗 External dealer advertisement URL when available
- 🕒 Scrape timestamp and source page context

### Who is it for?

This actor is useful for teams that need recurring visibility into the Dutch vehicle market.

- 🚘 **Auto dealers** monitor comparable inventory and pricing.
- 📊 **Pricing analysts** benchmark mileage, age, and asking prices.
- 🏪 **Marketplace operators** compare supply across categories and regions.
- 🧾 **Lead generation teams** collect dealer contact details from public listings.
- 🔍 **Researchers** analyze vehicle mix, fuel types, warranties, and market availability.
- 🧰 **Data teams** feed normalized vehicle listings into BI tools or databases.

### Why use this viaBOVAG scraper?

viaBOVAG is a major Dutch vehicle marketplace. This MVP focuses on public car search/listing pages under `/auto`, where the listing data is server-rendered and reliable.

Manual browsing works for one-off shopping, but it is slow when you need hundreds or thousands of structured rows.

This actor helps you:

- Save time on repetitive marketplace checks
- Export data in JSON, CSV, Excel, XML, RSS, or HTML through Apify datasets
- Run scheduled monitoring jobs
- Build alerts for price and inventory changes
- Compare dealers and regions
- Connect results to external tools via the Apify API

### How it works

The actor uses an HTTP-first approach.

1. You provide one or more viaBOVAG search URLs.
2. The actor downloads the public HTML.
3. It reads listing data from the `__NEXT_DATA__` JSON embedded in the page.
4. It paginates by adding or updating the `p` query parameter.
5. It saves clean vehicle listing rows to the default dataset.

No browser automation is used for the MVP, which keeps runs fast and cost-efficient.

### Supported start URLs

Use public viaBOVAG URLs copied from the website.

Examples:

```text
https://www.viabovag.nl/auto
https://www.viabovag.nl/auto?brandstof=benzine
````

Filtered car URLs are supported as long as they return public listing results on viaBOVAG.

### Data you can extract

| Field | Description |
| --- | --- |
| `listingUrl` | Public viaBOVAG listing URL |
| `title` | Listing title as shown by viaBOVAG |
| `price` | Asking price in EUR |
| `make` | Vehicle brand |
| `model` | Vehicle model |
| `year` | Registration/build year when available |
| `mileage` | Mileage value |
| `fuelTypes` | Fuel labels such as benzine, diesel, hybrid, electric |
| `transmission` | Transmission type |
| `bodyType` | Body style |
| `dealerName` | Dealer or seller company name |
| `dealerCity` | Dealer city |
| `imageUrls` | Listing image URLs |
| `warrantyLabels` | Warranty and BOVAG trust labels |

### How much does it cost to scrape viaBOVAG vehicle listings?

This actor uses pay-per-event pricing with a small run start fee and a per-listing event.

Formula-derived BRONZE pricing from cloud validation is **$0.000035757 per listing** (about **$0.035757 per 1,000 listings**) plus a **$0.005 run start fee**. Higher subscription tiers receive automatic per-listing discounts.

Apify shows the exact maximum charge before you start a run.

### Input

The actor input has two main fields.

```json
{
  "startUrls": [
    { "url": "https://www.viabovag.nl/auto" }
  ],
  "maxItems": 50
}
```

#### `startUrls`

A list of viaBOVAG search or category URLs.

Use the website to apply filters, then copy the resulting URL into the actor input.

#### `maxItems`

Maximum number of vehicle listings to save across all start URLs.

Set a low number for quick checks and a higher number for market analysis.

### Output

Each dataset item is one vehicle listing.

```json
{
  "listingUrl": "https://www.viabovag.nl/auto/aanbod/example",
  "title": "BMW 1 Serie 118i Executive Edition",
  "price": 24450,
  "priceCurrency": "EUR",
  "make": "BMW",
  "model": "1-Serie",
  "year": 2020,
  "mileage": 84437,
  "fuelTypes": ["benzine"],
  "transmission": "Automatisch",
  "bodyType": "hatchback",
  "dealerName": "Example Dealer",
  "dealerCity": "ROTTERDAM",
  "imageUrls": ["https://.../media.0001.jpg"],
  "scrapedAt": "2026-06-09T10:00:00.000Z"
}
```

### Tips for best results

- Start with `maxItems: 50` to confirm that your filters return the expected listings.
- Use specific filtered `/auto` URLs for focused market segments.
- Run separate actor runs for very different categories if you want easier dataset comparison.
- Schedule daily or weekly runs for price and inventory monitoring.
- Deduplicate by `listingUrl` in your downstream database.

### Example use cases

#### Dealer price monitoring

Track competing listings for a brand, model, fuel type, and mileage range.

#### Inventory intelligence

Measure how many public listings exist for specific segments of the Dutch vehicle market.

#### Lead enrichment

Collect dealer names, cities, websites, and public phone numbers attached to listings.

#### Warranty analysis

Compare availability of BOVAG, return warranty, service, and certainty labels by vehicle category.

### Integrations

You can connect this scraper to:

- Google Sheets through Apify integrations
- Make or Zapier for alerts
- BigQuery, Snowflake, or PostgreSQL through dataset exports
- BI dashboards for price trend reports
- CRM tools for dealer research workflows
- Webhooks that fire when a scheduled run finishes

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bovag-vehicle-listings-scraper').call({
  startUrls: [{ url: 'https://www.viabovag.nl/auto' }],
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/bovag-vehicle-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.viabovag.nl/auto'}],
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~bovag-vehicle-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.viabovag.nl/auto"}],"maxItems":50}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/bovag-vehicle-listings-scraper
```

Claude Code setup:

```bash
claude mcp add apify-bovag "https://mcp.apify.com/?tools=automation-lab/bovag-vehicle-listings-scraper"
```

Generic MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-bovag": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bovag-vehicle-listings-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 viaBOVAG car listings and summarize the top makes by count."
- "Get public viaBOVAG listings from this filtered URL and list the cheapest cars."
- "Monitor this viaBOVAG search weekly and tell me when new BMW listings appear."

### Scheduling

Apify lets you schedule this actor without writing infrastructure.

Common schedules:

- Daily inventory snapshots
- Weekly price benchmarking
- Monthly market reports
- Hourly checks for narrow filtered URLs

### Data quality notes

The actor extracts the public data embedded by viaBOVAG in the listing search page.

Some fields may be missing when viaBOVAG does not provide them for a specific listing.

For example, not every listing has the same warranty labels, dealer website, image metadata, or external advertisement URL.

### Limits and performance

The actor is designed for public listing pages and polite pagination.

If a URL returns no public results on the website, the actor will also return no dataset rows.

Very large runs should use realistic limits and scheduled batches.

### Troubleshooting

#### Why did my run return fewer listings than `maxItems`?

The filtered viaBOVAG search may have fewer public listings than your limit, or pagination may stop when the source returns an empty page.

#### Why are some fields null?

viaBOVAG does not expose every attribute on every listing. Null means the field was not available in the public search result data.

#### Can I scrape detail pages too?

The MVP focuses on search/listing pages for speed and reliability. Detail-page enrichment can be added later if it is needed and remains publicly accessible.

### Legality

This actor extracts publicly available listing data. You are responsible for using the data in compliance with applicable laws, viaBOVAG terms, and privacy rules.

Do not use scraped data for spam, harassment, or unlawful profiling.

### Related scrapers

Other automation-lab actors you may find useful:

- https://apify.com/automation-lab/carsales-scraper
- https://apify.com/automation-lab/autotrader-scraper
- https://apify.com/automation-lab/marktplaats-scraper
- https://apify.com/automation-lab/2dehands-2ememain-scraper

### FAQ

#### Does this actor require a viaBOVAG account?

No. It is built for public search/category listing pages.

#### Does it use a browser?

No. It reads server-rendered data from HTML, which is faster and cheaper than browser automation.

#### Can I use filtered URLs?

Yes. Apply filters on viaBOVAG, copy the URL, and use it as a start URL.

#### What is the best unique key?

Use `listingUrl` or `listingId` for deduplication.

#### Can I run it on a schedule?

Yes. Use Apify schedules to run recurring monitoring jobs.

#### What export formats are supported?

Apify datasets support JSON, CSV, Excel, XML, HTML, and RSS exports.

# Actor input Schema

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

One or more public viaBOVAG car search/category URLs under /auto. Use filtered URLs copied from viabovag.nl.

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

Maximum number of vehicle listings to save across all start URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.viabovag.nl/auto"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.viabovag.nl/auto"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bovag-vehicle-listings-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.viabovag.nl/auto" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bovag-vehicle-listings-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.viabovag.nl/auto"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/bovag-vehicle-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/bovag-vehicle-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BOVAG Vehicle Listings Scraper",
        "description": "Scrape public viaBOVAG car listings with prices, specs, mileage, images, warranty labels, and dealer contact details.",
        "version": "0.1",
        "x-build-id": "Dr8dsSulPMfhEWHNE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bovag-vehicle-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bovag-vehicle-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~bovag-vehicle-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bovag-vehicle-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~bovag-vehicle-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bovag-vehicle-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "viaBOVAG start URLs",
                        "type": "array",
                        "description": "One or more public viaBOVAG car search/category URLs under /auto. Use filtered URLs copied from viabovag.nl.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to save across all start URLs.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
