# Travel Accommodation Scraper (`lentic_clockss/travel-accommodation-scraper`) Actor

Search hotels and vacation rentals across Booking.com and Airbnb in one run. Compare prices, ratings, and availability. No login, no API key needed.

- **URL**: https://apify.com/lentic\_clockss/travel-accommodation-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Travel Accommodation Scraper — Booking.com & Airbnb

Scrape hotels and vacation rentals from **Booking.com** and **Airbnb** in a single run with one Actor built for **hotel price comparison**, travel monitoring,. This **travel scraper** collects listings from two major travel marketplaces, normalizes the output, and returns data you can use for dashboards, alerts, competitor tracking, without requiring login credentials or third-party APIs for the target sites.

The Actor is designed for teams that need a reliable **Booking.com scraper** and **Airbnb scraper** experience without stitching together two separate tools. Instead of merging mismatched payloads after the fact, you get one **accommodation scraper** with a shared schema for hotels, apartments, private rooms, and vacation stays. That makes it easier to build **hotel price comparison** products, market intelligence tools, travel planning assistants, or a **vacation rental scraper** workflow that runs on a schedule inside Apify.

### Features

- **Dual-platform scraping** — Run `booking`, `airbnb`, or `both` from the same input and compare results across two high-intent travel platforms.
- **Unified output schema** — Receive standardized listing objects with price, rating, review count, property type, image, location, and scrape timestamp fields.
- **Built for price intelligence** — Use it as a **hotel scraper**, **travel scraper**, or **hotel price comparison** backend for monitoring pricing changes.
- **Flexible search controls** — Filter by destination, check-in, check-out, adult count, currency hint, and per-platform result limits.
- **Production-ready on Apify** — Supports Apify Proxy input, runs headless in the cloud, and is optimized for repeatable Actor runs.
- **Automation friendly** — Send output to datasets, webhooks, or downstream pipelines for research, lead generation, or travel data enrichment.

### Output Fields

Each item in the default dataset represents one accommodation record. The Actor returns a unified structure so your downstream code does not need separate parsing logic for Booking.com and Airbnb.

| Field | Type | Description |
|---|---|---|
| `platform` | string | Source platform: `booking` or `airbnb`. |
| `name` | string | Listing title or property name shown in search results. |
| `url` | string | Canonical listing URL when available. |
| `price` | number \| null | Parsed numeric price extracted from visible listing text. |
| `totalPrice` | number \| null | Parsed total price when present in the page text. |
| `currency` | string | Currency symbol or code inferred from the listing text or input hint. |
| `rating` | number \| null | Numeric rating parsed from visible score text. |
| `ratingText` | string | Raw rating text as displayed on the website. |
| `reviewCount` | integer | Parsed review count when available. |
| `propertyType` | string | Property classification such as hotel, home, apartment, or private room. |
| `location` | string | Best-effort location snippet from the listing card. |
| `distanceFromCenter` | string | Booking.com distance snippet when available. |
| `imageUrl` | string | Main card image URL. |
| `roomType` | string | Room or stay subtype if exposed in the search result card. |
| `amenities` | array | Amenities list when available in the raw card extraction. |
| `scrapedAt` | string | ISO 8601 UTC timestamp for the scrape event. |

### Input Parameters

| Field | Type | Required | Default | Description |
|---|---|---:|---|---|
| `destination` | string | Yes | — | City, area, or destination query such as `Singapore`, `Tokyo`, or `Paris`. |
| `checkin` | string | No | empty | Check-in date in `YYYY-MM-DD` format. |
| `checkout` | string | No | empty | Check-out date in `YYYY-MM-DD` format. |
| `adults` | integer | No | `2` | Number of adult guests. Accepted range is 1–10. |
| `platforms` | string | No | `both` | `both`, `booking`, or `airbnb`. |
| `maxResults` | integer | No | `50` | Maximum number of results per platform. The current hard limit is 500. |
| `currency` | string | No | `USD` | Preferred currency code such as `USD`, `EUR`, `JPY`, or `SGD`. |
| `proxy` | object | No | `null` | Standard Apify proxy configuration, including residential proxies when needed. |

For schema-level validation, see [`.actor/input_schema.json`](.actor/input_schema.json).

### Usage Examples

#### 1. Compare Booking.com and Airbnb prices in one run

```json
{
  "destination": "Singapore",
  "checkin": "2026-05-01",
  "checkout": "2026-05-03",
  "adults": 2,
  "platforms": "both",
  "maxResults": 20,
  "currency": "USD"
}
````

#### 2. Booking.com only with local currency

```json
{
  "destination": "Tokyo",
  "checkin": "2026-06-15",
  "checkout": "2026-06-18",
  "adults": 2,
  "platforms": "booking",
  "maxResults": 25,
  "currency": "JPY"
}
```

#### 3. Airbnb only for family stays

```json
{
  "destination": "Paris",
  "checkin": "2026-07-01",
  "checkout": "2026-07-07",
  "adults": 4,
  "platforms": "airbnb",
  "maxResults": 30
}
```

#### 4. Dual-platform run with Apify residential proxy

```json
{
  "destination": "New York",
  "checkin": "2026-08-10",
  "checkout": "2026-08-14",
  "adults": 2,
  "platforms": "both",
  "maxResults": 15,
  "currency": "USD",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Use Cases

- **Price comparison** — Compare hotel and rental pricing across Booking.com and Airbnb for the same destination and date window. This is ideal for travel agencies, and founders building a **hotel price comparison** product.
- **Market research** — Track accommodation pricing, rating, and listing mix across cities to understand supply, affordability, and positioning. Analysts can use this **accommodation scraper** for destination studies, hospitality benchmarking, or tourism research.
- **Travel planning tools** — Feed normalized hotel and rental results into itinerary builders, chatbots, recommendation engines, or AI travel assistants that need a **travel scraper** data source.
- **Rate monitoring** — Schedule repeat runs to detect price drops, weekend spikes, or seasonal changes. This is useful for alerting systems, dynamic pricing experiments, and a **hotel scraper** workflow.
- **Academic research** — Collect listing data for tourism economics, urban planning, or mobility studies. A single **vacation rental scraper** plus hotel feed simplifies dataset preparation.

### Cost Estimate

This Actor is intended to support a pay-per-event pricing model with a small run start charge plus a per-result charge. Based on the current product brief, the live commercial target is approximately **$2 per 1,000 results**, with a small fixed charge each time the Actor starts.

In practical terms:

- Small validation run: `maxResults: 10` on one platform keeps cost low and is suitable for selector checks.
- Standard comparison run: `maxResults: 50` on `both` platforms gives a useful sample for a **Booking.com scraper** plus **Airbnb scraper** comparison workflow.
- Larger monitoring run: use scheduled runs with moderate result counts and proxy settings only when needed.

Browser-based actors consume more compute than lightweight HTTP scrapers, so the best operating pattern is to keep your inputs targeted, reuse destination/date windows intelligently, and avoid collecting more data than your downstream workflow actually needs.

### Performance

Performance depends on destination complexity, date filters, proxy usage, and how aggressively the source platforms load cards in the browser. As a general rule:

- Single-platform runs are faster than dual-platform runs.
- Booking.com often returns structured card data quickly for mainstream destinations.
- Airbnb can vary more by geography and may need extra page load time for results to stabilize.
- Residential proxies can improve reliability in some regions, but they may add latency.

For most validation runs, keeping `maxResults` between `5` and `20` per platform is a good balance between speed and confidence. For production monitoring, increase counts gradually and observe success rate and cost per usable result.

### Local Development

1. Use Python **3.13** if possible to match the Actor base image.
2. Install dependencies:

```bash
python3.13 -m venv .venv
.venv/bin/pip install -r requirements.txt
python -m patchright install --with-deps chromium
```

3. Run locally with Apify CLI:

```bash
apify run
```

Store local input in `storage/key_value_stores/default/INPUT.json` or provide it through the CLI prompt. When running locally, do not force `APIFY_IS_AT_HOME=1` unless you are intentionally emulating the Apify runtime with the right environment context.

### Notes

- **DOM dependency** — Booking.com and Airbnb occasionally change listing card structure, so selectors may need maintenance.
- **Blocking risk** — For higher-volume runs, use reasonable limits and enable Apify Proxy when necessary.
- **Currency parsing** — `currency` is best-effort from visible text; Booking.com also uses the explicit input hint when available.
- **Cloud browser mode** — On Apify, the Actor runs headless with bundled Chromium. Local development can use Chrome when installed.

### Legal

This Actor automates search result pages only. You are responsible for complying with Booking.com, Airbnb, and Apify terms of service, applicable privacy and data protection laws, and robots or acceptable-use rules that apply in your jurisdiction or workflow.

Do not use this tool for spam, credential stuffing, abusive automation, or other prohibited activities. The software is provided on an as-is basis without warranty, and you are responsible for validating fitness for your use case before production deployment.

### Pushing to Apify

Authenticate with the Apify CLI first, then push the Actor:

```bash
apify push
```

Use an `APIFY_TOKEN` environment variable or CLI login flow. Do not commit credentials, API tokens, or private configuration values into the repository.

# Actor input Schema

## `destination` (type: `string`):

City or area to search (e.g. 'Singapore', 'Tokyo', 'Paris'). Used as search query on both platforms.

## `checkin` (type: `string`):

Check-in date in YYYY-MM-DD format.

## `checkout` (type: `string`):

Check-out date in YYYY-MM-DD format.

## `adults` (type: `integer`):

Number of adult guests.

## `platforms` (type: `string`):

Which platforms to search: 'both' for Booking + Airbnb, 'booking' for Booking.com only, 'airbnb' for Airbnb only.

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

Maximum number of results per platform. Default 50.

## `currency` (type: `string`):

Preferred currency code (e.g. 'USD', 'EUR', 'SGD'). Booking.com supports currency parameter; Airbnb shows prices in local or account currency.

## `proxy` (type: `object`):

Proxy configuration. May be needed for large runs or if blocked.

## Actor input object example

```json
{
  "destination": "Singapore",
  "checkin": "2026-05-01",
  "checkout": "2026-05-03",
  "adults": 2,
  "platforms": "both",
  "maxResults": 50,
  "currency": "USD"
}
```

# Actor output Schema

## `accommodations` (type: `string`):

Dataset containing all scraped accommodation records

# 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 = {
    "destination": "Singapore"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/travel-accommodation-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 = { "destination": "Singapore" }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/travel-accommodation-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 '{
  "destination": "Singapore"
}' |
apify call lentic_clockss/travel-accommodation-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Travel Accommodation Scraper",
        "description": "Search hotels and vacation rentals across Booking.com and Airbnb in one run. Compare prices, ratings, and availability. No login, no API key needed.",
        "version": "0.1",
        "x-build-id": "eTUxCiaJxmEveXJcg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~travel-accommodation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-travel-accommodation-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/lentic_clockss~travel-accommodation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-travel-accommodation-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/lentic_clockss~travel-accommodation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-travel-accommodation-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": [
                    "destination"
                ],
                "properties": {
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "City or area to search (e.g. 'Singapore', 'Tokyo', 'Paris'). Used as search query on both platforms."
                    },
                    "checkin": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format."
                    },
                    "checkout": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format."
                    },
                    "adults": {
                        "title": "Number of Adults",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "platforms": {
                        "title": "Platforms",
                        "enum": [
                            "both",
                            "booking",
                            "airbnb"
                        ],
                        "type": "string",
                        "description": "Which platforms to search: 'both' for Booking + Airbnb, 'booking' for Booking.com only, 'airbnb' for Airbnb only.",
                        "default": "both"
                    },
                    "maxResults": {
                        "title": "Max Results Per Platform",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of results per platform. Default 50.",
                        "default": 50
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Preferred currency code (e.g. 'USD', 'EUR', 'SGD'). Booking.com supports currency parameter; Airbnb shows prices in local or account currency.",
                        "default": "USD"
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration. May be needed for large runs or if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
