# Rijksmuseum Collection Scraper (`crawlerbros/rijksmuseum-collection-scraper`) Actor

Scrape the Rijksmuseum's public online collection (rijksmuseum.nl) - 800,000+ artworks and objects. Search by artist/title/keyword, browse by object type or century, and filter by on-display status.

- **URL**: https://apify.com/crawlerbros/rijksmuseum-collection-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Rijksmuseum Collection Scraper

Search and browse the **Rijksmuseum**'s public online collection (rijksmuseum.nl) — the Dutch national museum's catalog of 800,000+ paintings, prints, drawings, photographs, and decorative-art objects, including masterpieces like *The Night Watch* and *The Milkmaid*. No login, no API key, no paid proxy required.

### What this actor does

- **Four modes:** `search` (artist/title/keyword), `byObjectType` (painting, print, furniture, etc.), `byCentury` (13th–21st century), `byObjectNumber` (direct lookup, e.g. `SK-A-2344`)
- **Material and technique filters** — narrow to e.g. oil paint on canvas, or etchings on paper
- **Sort order and language** — most popular or most relevant first; English or Dutch text fields
- **On-display filter** — only items currently exhibited in the museum
- **Full curatorial detail on demand** — optionally fetch each object's full detail page for description, materials, technique, credit line, acquisition history, provenance, related objects, and literature references
- **High-resolution images** via the museum's own Micrio image service
- **Empty fields are omitted**

### Output per artwork

- `objectNumber`, `objectUrl`, `linkedDataUri` — identifiers and canonical links
- `title`, `makerDisplay` (maker + date, e.g. "Johannes Vermeer, c. 1660")
- `century`, `physicalFeatures`
- `isOnDisplay`, `onDisplayLocation`
- `imageUrl`, `thumbnailUrl`, `highResImageUrl` (when downloadable), `imageWidth`, `imageHeight`
- With `fetchFullDetails: true`, additionally:
  - `description`, `objectTypes[]`, `materials[]`, `techniques[]`, `dimensionsText[]`
  - `makerRole`, `dating`, `creditLine`, `acquisition`, `rightsText`, `provenance`
  - `relatedObjects[]`, `documentation[]` (literature/catalog references, when published)
- `recordType: "artwork"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byObjectType` / `byCentury` / `byObjectNumber` |
| `searchQuery` | string | `Vermeer` | Artist, title, or keyword |
| `objectType` | string | – | Painting, Print, Drawing, Photograph, Furniture, Chair, Vase, Costume, Jewellery, Map, Figure/sculpture, Plate, Letter, Page, Album leaf, Book illustration |
| `century` | string | – | 13th–21st century |
| `material` | string | – | Paper, Photographic support, Pasteboard, Cardboard, Ink, Pencil, Oil paint, Canvas |
| `technique` | string | – | Etching, Engraving, Albumen print, Gelatin silver print, Pen, Lithography, Letterpress printing, Brush |
| `sortingType` | string | `Popularity` | `Popularity` (most popular first) or `Relevance` (most relevant first) |
| `language` | string | `en` | `en` or `nl` — language of returned text fields |
| `objectNumbers` | array | – | Object numbers for direct lookup (mode=byObjectNumber) |
| `onDisplayOnly` | bool | `false` | Only objects on display in the museum |
| `hasImageOnly` | bool | `true` | Only objects with a viewable image |
| `fetchFullDetails` | bool | `false` | Fetch each object's full detail page (slower, richer) |
| `maxItems` | int | `20` | Hard cap (1–500) |

#### Example: search for a Dutch diacritic name

```json
{ "mode": "search", "searchQuery": "Rembrandt van Rijn", "maxItems": 30 }
````

#### Example: browse 17th-century paintings on display

```json
{ "mode": "search", "objectType": "painting", "century": "17", "onDisplayOnly": true }
```

#### Example: full curatorial detail for specific masterpieces

```json
{
  "mode": "byObjectNumber",
  "objectNumbers": ["SK-A-2344", "SK-C-5"],
  "fetchFullDetails": true
}
```

### Use cases

- **Digital humanities & research** — bulk metadata and images for a period, maker, or object type
- **Museum data analysis** — compare object types and centuries across the collection
- **Education** — high-resolution art images with full provenance for coursework
- **Creative reuse** — most Rijksmuseum objects are public-domain and free to reuse
- **Trip planning** — find what's currently on display before a visit

### Data source / limitations

This actor reads the same public collection-search API (`rijksmuseum.nl/api/v1/collection/search`) and object-detail pages that power the museum's own website — no separate API key is required (unlike the older, deprecated `api.rijksmuseum.nl` key-gated API, which this actor intentionally does not use). Object type and century filters use the Rijksmuseum's own internal facet identifiers; the curated list in this actor covers the most common, reliably populated categories. `fetchFullDetails` requires one extra request per item, so leave it off for fast bulk listing and turn it on when you need full curatorial text.

### FAQ

**Do I need an API key?** No. This actor uses the same public endpoints the Rijksmuseum website itself calls.

**Is the artwork data public domain?** Most of the Rijksmuseum's digitized collection is in the public domain or released under Creative Commons; check the `rightsText` field (available with `fetchFullDetails: true`) for the specific work.

**What's the difference between `imageUrl` and `highResImageUrl`?** `imageUrl` is a ~1600px version suitable for most uses; `highResImageUrl` is the maximum resolution and is only included when the museum marks the image as downloadable.

**Why is `makerDisplay` a single combined string?** The museum's search listing combines maker name and date into one field. Set `fetchFullDetails: true` to get the maker's role (`makerRole`) and a clean `dating` field separately.

**Can I look up a specific famous work?** Yes — use `mode=byObjectNumber` with its object number, found on the object's Rijksmuseum page URL (e.g. `SK-C-5` for *The Night Watch*).

# Actor input Schema

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

What to fetch.

## `searchQuery` (type: `string`):

Free-text query — artist name, title, or keyword (mode=search; also narrows byObjectType/byCentury if set).

## `objectType` (type: `string`):

Kind of object (mode=byObjectType required; optional filter otherwise).

## `century` (type: `string`):

Century the object was made in (mode=byCentury required; optional filter otherwise).

## `material` (type: `string`):

Filter to objects made of this material (any mode).

## `technique` (type: `string`):

Filter to objects made with this technique (any mode).

## `sortingType` (type: `string`):

Result ordering for search-listing modes.

## `language` (type: `string`):

Language of returned text fields (title, maker role, etc).

## `objectNumbers` (type: `array`):

Rijksmuseum object numbers, e.g. `SK-A-2344` (The Milkmaid), `SK-C-5` (The Night Watch).

## `onDisplayOnly` (type: `boolean`):

Only emit objects currently on display in the museum.

## `hasImageOnly` (type: `boolean`):

Only emit objects that have a viewable image.

## `fetchFullDetails` (type: `boolean`):

Additionally fetch each object's detail page for description, materials, technique, credit line, acquisition, and provenance. Slower (one extra request per item) but much richer output.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Vermeer",
  "sortingType": "Popularity",
  "language": "en",
  "objectNumbers": [],
  "onDisplayOnly": false,
  "hasImageOnly": true,
  "fetchFullDetails": false,
  "maxItems": 20
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped Rijksmuseum collection items.

# 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": "search",
    "searchQuery": "Vermeer",
    "sortingType": "Popularity",
    "language": "en",
    "objectNumbers": [],
    "onDisplayOnly": false,
    "hasImageOnly": true,
    "fetchFullDetails": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rijksmuseum-collection-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 = {
    "mode": "search",
    "searchQuery": "Vermeer",
    "sortingType": "Popularity",
    "language": "en",
    "objectNumbers": [],
    "onDisplayOnly": False,
    "hasImageOnly": True,
    "fetchFullDetails": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rijksmuseum-collection-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 '{
  "mode": "search",
  "searchQuery": "Vermeer",
  "sortingType": "Popularity",
  "language": "en",
  "objectNumbers": [],
  "onDisplayOnly": false,
  "hasImageOnly": true,
  "fetchFullDetails": false,
  "maxItems": 20
}' |
apify call crawlerbros/rijksmuseum-collection-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rijksmuseum Collection Scraper",
        "description": "Scrape the Rijksmuseum's public online collection (rijksmuseum.nl) - 800,000+ artworks and objects. Search by artist/title/keyword, browse by object type or century, and filter by on-display status.",
        "version": "1.0",
        "x-build-id": "3JAnbP3eDnUM1EC0G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rijksmuseum-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rijksmuseum-collection-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/crawlerbros~rijksmuseum-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rijksmuseum-collection-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/crawlerbros~rijksmuseum-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rijksmuseum-collection-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byObjectType",
                            "byCentury",
                            "byObjectNumber"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query — artist name, title, or keyword (mode=search; also narrows byObjectType/byCentury if set).",
                        "default": "Vermeer"
                    },
                    "objectType": {
                        "title": "Object type",
                        "enum": [
                            "",
                            "painting",
                            "print",
                            "drawing",
                            "photograph",
                            "furniture",
                            "chair",
                            "vase",
                            "costume",
                            "jewellery",
                            "map",
                            "figure",
                            "plate",
                            "letter",
                            "page",
                            "albumLeaf",
                            "bookIllustration"
                        ],
                        "type": "string",
                        "description": "Kind of object (mode=byObjectType required; optional filter otherwise)."
                    },
                    "century": {
                        "title": "Century",
                        "enum": [
                            "",
                            "13",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21"
                        ],
                        "type": "string",
                        "description": "Century the object was made in (mode=byCentury required; optional filter otherwise)."
                    },
                    "material": {
                        "title": "Material",
                        "enum": [
                            "",
                            "paper",
                            "photographicSupport",
                            "pasteboard",
                            "cardboard",
                            "ink",
                            "pencil",
                            "oilPaint",
                            "canvas"
                        ],
                        "type": "string",
                        "description": "Filter to objects made of this material (any mode)."
                    },
                    "technique": {
                        "title": "Technique",
                        "enum": [
                            "",
                            "etching",
                            "engraving",
                            "albumenPrint",
                            "gelatinSilverPrint",
                            "pen",
                            "lithography",
                            "letterpressPrinting",
                            "brush"
                        ],
                        "type": "string",
                        "description": "Filter to objects made with this technique (any mode)."
                    },
                    "sortingType": {
                        "title": "Sort order",
                        "enum": [
                            "Popularity",
                            "Relevance"
                        ],
                        "type": "string",
                        "description": "Result ordering for search-listing modes.",
                        "default": "Popularity"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "nl"
                        ],
                        "type": "string",
                        "description": "Language of returned text fields (title, maker role, etc).",
                        "default": "en"
                    },
                    "objectNumbers": {
                        "title": "Object numbers (mode=byObjectNumber)",
                        "type": "array",
                        "description": "Rijksmuseum object numbers, e.g. `SK-A-2344` (The Milkmaid), `SK-C-5` (The Night Watch).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "onDisplayOnly": {
                        "title": "On display only",
                        "type": "boolean",
                        "description": "Only emit objects currently on display in the museum.",
                        "default": false
                    },
                    "hasImageOnly": {
                        "title": "Only items with an image",
                        "type": "boolean",
                        "description": "Only emit objects that have a viewable image.",
                        "default": true
                    },
                    "fetchFullDetails": {
                        "title": "Fetch full curatorial details",
                        "type": "boolean",
                        "description": "Additionally fetch each object's detail page for description, materials, technique, credit line, acquisition, and provenance. Slower (one extra request per item) but much richer output.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
