# Rental Listings Scraper & Real Estate Data API (`housingfeed/rental-listings-api`) Actor

One clean API for rental listings from property platforms and portals worldwide — normalized rent, beds, location and geo, pulled direct from the source.

- **URL**: https://apify.com/housingfeed/rental-listings-api.md
- **Developed by:** [HousingFeed](https://apify.com/housingfeed) (community)
- **Categories:** Real estate, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## Rental Listings Scraper & Real Estate Data API 🏘️

**One clean API for rental listings from property platforms and portals worldwide.** HousingFeed unifies rental inventory from across the web — property-management platforms *and* the major listing portals — into a single normalized schema. Query by country, city, state, ZIP, rent, and bedrooms; get back clean JSON with address, geo-coordinates, rent (native currency **and** USD), beds, baths, square footage, property type, availability, and photos.

Most tools scrape one portal. HousingFeed pulls **direct from the source** and normalizes everything, so you integrate once instead of stitching together a dozen scrapers.

---

### Why HousingFeed

- 🌍 **Many sources, one schema** — property-management platforms + major portals across the US, UK, and Europe, all in the same shape
- 🏢 **Source-layer coverage others don't have** — direct from AppFolio, Buildium, RentCafe, ShowMojo, not just the portals everyone else scrapes
- 🧭 **Geo-ready** — latitude/longitude where available, plus city/state/ZIP
- 💵 **Currency-normalized** — rent stored native + a derived `rent_usd` for cross-country comparison
- 🧱 **One integration** — no per-portal parsing on your side
- ⚡ **Fast & filterable** — country, location, rent range, bed range, availability
- 🔌 **Zero-config** — no proxies, no browser automation, no scraper code to maintain
- 📈 **Expanding continuously** — new platforms and countries added on an ongoing basis

---

### Sources

Rental listings unified from property-management platforms and portals including:

**United States** — AppFolio · Buildium · RentCafe (Yardi) · ShowMojo · Avail · TurboTenant · Rentler · Rently · TenantTurner · Rentable · ApartmentGuide · Zumper (+ PadMapper) · Rent.com

**United Kingdom & Ireland** — Rightmove · OnTheMarket · Gumtree · MyHome (IE)

**Europe** — Immoweb (BE) · Bien'ici (FR) · Fotocasa · Pisos · Habitaclia (ES) · Otodom (PL) · Immobiliare · Immowelt (DE) · Wunderflats (DE) · Finn (NO) · Kamernet (NL) · Spotahome · HousingAnywhere (EU)

…and more added continuously.

> Looking for a **specific portal** (Zillow, Apartments.com, Idealista, Zoopla, Funda…)? They're on the roadmap as dedicated scrapers — [tell us](mailto:iron@simpleanalytics.com) and we'll prioritize by demand.

---

### Example output

Each listing is returned as a flat, normalized JSON object:

```json
{
  "platform": "appfolio",
  "listing_id": "sunset-village-apts-2b",
  "url": "https://sunsetpm.appfolio.com/listings/detail/…",
  "address": "1420 Sunset Blvd, Los Angeles, CA 90026",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90026",
  "lat": 34.0782,
  "lng": -118.2606,
  "rent_min": 2450,
  "rent_max": 2450,
  "currency": "USD",
  "rent_usd": 2450,
  "beds": 2,
  "baths": 1,
  "sqft_min": 880,
  "property_type": "apartment",
  "available": "now",
  "furnished": false,
  "image": "https://…/photo.jpg",
  "country": "US",
  "scraped_at": "2026-07-04T09:12:00Z"
}
````

***

### How to use it

Set any combination of filters — all optional, blank returns the latest across every source:

| Field | What it does |
|---|---|
| `country` | Restrict to one country (US, UK, FR, DE, …) |
| `platform` | Restrict to one source (e.g. `appfolio`, `zumper`, `immoweb`, `rightmove`) |
| `state` | US state code (e.g. `CA`) or region |
| `city` | City name (partial match) |
| `minRent` / `maxRent` | Monthly rent range |
| `minBeds` / `maxBeds` | Bedroom range |
| `availableNow` | Only listings marked available now |
| `maxItems` | Cap the number of results (default 100, up to 5000) |

**Example:** *2-bedroom homes in California renting between $1,500 and $2,500:*

```json
{ "country": "US", "state": "CA", "minBeds": 2, "minRent": 1500, "maxRent": 2500, "maxItems": 500 }
```

Run it from the Apify UI, via the API, or on a schedule. Results land in the dataset and export to **CSV, Excel, JSON, or XML**, or push to your own storage.

#### Call it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/housingfeed~rental-listings-api/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "country": "US", "state": "CA", "minBeds": 2, "maxRent": 2500 }'
```

***

### Examples

**Latest listings across all sources:**

```json
{ "maxItems": 100 }
```

**2-bed apartments in California under $2,500:**

```json
{ "country": "US", "state": "CA", "minBeds": 2, "maxRent": 2500, "maxItems": 500 }
```

**One platform only (e.g. Rightmove, UK):**

```json
{ "platform": "rightmove", "minBeds": 2, "maxItems": 500 }
```

**A whole country's inventory:**

```json
{ "country": "DE", "maxItems": 5000 }
```

***

### Output schema

`platform` · `source_id` · `listing_id` · `url` · `address` · `street` · `city` · `state` · `zip` · `lat` · `lng` · `rent_min` · `rent_max` · `currency` · `rent_usd` · `beds` · `baths` · `sqft_min` · `sqft_max` · `property_type` · `available` · `units_available` · `furnished` · `image` · `country` · `granularity` · `scraped_at`

Every source maps into this one schema, so a listing from a US property manager and one from a Belgian portal come back in exactly the same shape.

***

### Who it's for

- **Proptech & rental apps** — power search, comps, and market pages without integrating a dozen portals yourself
- **Real-estate investors & analysts** — pull rent comps and inventory by market to underwrite deals
- **Market researchers & data teams** — track rent levels, supply, and trends across cities and countries
- **ML / AI teams** — a clean, normalized training set of live rental inventory with geo + pricing

***

### Freshness

Listings are re-harvested on a schedule, so inventory stays current — expired listings age out and new ones come in. Rental data turns over constantly, which is exactly why a live feed beats a one-time export. Need a specific refresh cadence or a change-history feed (new / removed / price-changed)? Available on higher tiers.

***

### Pricing

Usage-based — you pay only for the results you pull, and a free allowance lets you test it before spending anything.

***

### Bulk & enterprise access

Need more than per-run pulls? Direct **HousingFeed** access is built for teams:

- **Full-database & bulk delivery** — pushed to your S3 / GCS bucket on a custom cadence
- **Change-history feeds** — new / removed / price-changed events, not just snapshots
- **Enrichment** — geocoding, dedupe, currency normalization, and market-level rent data
- **Reselling & white-label** terms · priority coverage · SLAs
- **Higher volumes & faster responses** than per-run limits

[Get in touch](mailto:hello@housingfeed.com) to scope a plan.

***

### FAQ

**Is web scraping rental data legal?**
This Actor collects **publicly available** listing data that property managers and portals *publish to be seen and syndicated*. It focuses on the property-management source layer (AppFolio, Buildium, etc.) — data owners generally want it distributed. As always, review the terms of the sites you target and consult your own counsel for your use case; don't collect personal data unlawfully.

**How much coverage do you have?**
Rental inventory from property-management platforms and major portals across the US, UK, and Europe — expanding continuously as we add sources and countries. Want current coverage for a specific market? Just ask.

**How often is the data updated?**
On a recurring schedule. Turn on live-refresh for the portal sources, or contact us for a custom cadence / real-time feed.

**Can you add \[Zillow / Apartments.com / Idealista / a country]?**
Yes — new platforms are just a new adapter. We prioritize by demand, so tell us what you need.

**What formats can I export?**
JSON, CSV, Excel, or XML from the dataset, or call the run-sync endpoint to get results inline.

**Can I get the whole database or a bulk feed?**
Yes — direct bulk delivery and reselling terms are available for teams. Reach out.

***

### Roadmap

Dedicated single-source scrapers — **Rightmove, Zumper, Immoweb, Otodom, OnTheMarket** and more — are rolling out, each returning this same normalized schema and feeding the unified API. Need one prioritized, a new portal (Zillow, Apartments.com, Idealista…), or a specific country? Tell us and we'll bump it up the list.

***

***HousingFeed** — building the global rental data layer: every rental listing, unified into one clean API. Custom platforms, specific countries, or bulk / full-database access — get in touch: iron@simpleanalytics.com*

# Actor input Schema

## `country` (type: `string`):

Return listings from one country only. Blank = all countries.

## `state` (type: `string`):

US state code (e.g. CA, NY, TX) or region. Blank = all.

## `city` (type: `string`):

City name, partial match (e.g. "Los Angeles"). Blank = all.

## `minRent` (type: `integer`):

Minimum monthly rent, in the listing's local currency.

## `maxRent` (type: `integer`):

Maximum monthly rent, in the listing's local currency.

## `minBeds` (type: `integer`):

Minimum number of bedrooms.

## `maxBeds` (type: `integer`):

Maximum number of bedrooms.

## `platform` (type: `string`):

Restrict to one source platform (e.g. appfolio, zumper, immoweb, rightmove). Blank = all 30+ platforms.

## `availableNow` (type: `boolean`):

Only return listings marked available now.

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

Maximum number of listings to return.

## `refresh` (type: `boolean`):

Re-scrape the portal platforms live for the freshest data instead of serving the latest snapshot. Slower — leave off for fast queries.

## Actor input object example

```json
{
  "country": "US",
  "state": "CA",
  "minRent": 1000,
  "maxRent": 3000,
  "minBeds": 2,
  "availableNow": false,
  "maxItems": 100,
  "refresh": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "country": "US",
    "state": "CA",
    "minRent": 1000,
    "maxRent": 3000,
    "minBeds": 2,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("housingfeed/rental-listings-api").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 = {
    "country": "US",
    "state": "CA",
    "minRent": 1000,
    "maxRent": 3000,
    "minBeds": 2,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("housingfeed/rental-listings-api").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 '{
  "country": "US",
  "state": "CA",
  "minRent": 1000,
  "maxRent": 3000,
  "minBeds": 2,
  "maxItems": 100
}' |
apify call housingfeed/rental-listings-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=housingfeed/rental-listings-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rental Listings Scraper & Real Estate Data API",
        "description": "One clean API for rental listings from property platforms and portals worldwide — normalized rent, beds, location and geo, pulled direct from the source.",
        "version": "0.1",
        "x-build-id": "P4L1VsGKnGjoV1wBS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/housingfeed~rental-listings-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-housingfeed-rental-listings-api",
                "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/housingfeed~rental-listings-api/runs": {
            "post": {
                "operationId": "runs-sync-housingfeed-rental-listings-api",
                "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/housingfeed~rental-listings-api/run-sync": {
            "post": {
                "operationId": "run-sync-housingfeed-rental-listings-api",
                "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",
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "UK",
                            "IE",
                            "FR",
                            "DE",
                            "NL",
                            "PL",
                            "BE",
                            "ES",
                            "IT",
                            "NO",
                            "EU"
                        ],
                        "type": "string",
                        "description": "Return listings from one country only. Blank = all countries.",
                        "default": ""
                    },
                    "state": {
                        "title": "State / region",
                        "type": "string",
                        "description": "US state code (e.g. CA, NY, TX) or region. Blank = all."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, partial match (e.g. \"Los Angeles\"). Blank = all."
                    },
                    "minRent": {
                        "title": "Min rent",
                        "type": "integer",
                        "description": "Minimum monthly rent, in the listing's local currency."
                    },
                    "maxRent": {
                        "title": "Max rent",
                        "type": "integer",
                        "description": "Maximum monthly rent, in the listing's local currency."
                    },
                    "minBeds": {
                        "title": "Min bedrooms",
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "maxBeds": {
                        "title": "Max bedrooms",
                        "type": "integer",
                        "description": "Maximum number of bedrooms."
                    },
                    "platform": {
                        "title": "Platform",
                        "type": "string",
                        "description": "Restrict to one source platform (e.g. appfolio, zumper, immoweb, rightmove). Blank = all 30+ platforms."
                    },
                    "availableNow": {
                        "title": "Available now only",
                        "type": "boolean",
                        "description": "Only return listings marked available now.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results",
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "refresh": {
                        "title": "Live refresh (slower)",
                        "type": "boolean",
                        "description": "Re-scrape the portal platforms live for the freshest data instead of serving the latest snapshot. Slower — leave off for fast queries.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
