# Property24 Scraper - SA Property Listings & Agent Data (`haketa/property24-scraper`) Actor

Scrape Property24 SA real estate: for-sale, to-rent, sold properties with price, beds, baths, floor size, location, agent data. SA property data, market research and lead gen.

- **URL**: https://apify.com/haketa/property24-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Property24 Scraper — South Africa Real Estate Listings & Property Data API

Extract comprehensive property listings from **Property24.com** — South Africa's largest real estate portal. Scrape for-sale, to-rent and recently sold properties with prices (ZAR), bedrooms, bathrooms, floor size, parking spaces, location details, agent contacts, images and more. Perfect for real estate market research, property investment analysis, lead generation, competitive intelligence and SA housing market data pipelines.

### 🎯 Key Differentiators

- **Server-rendered HTML extraction** — Property24 is an ASP.NET MVC site that renders listings server-side. No JavaScript execution needed — fast, cheap CheerioCrawler architecture
- **20+ data fields per listing** — price, beds, baths, floor size, parking, location, agent details, listing URL, and more
- **Three listing types** — For Sale, To Rent, and Sold Properties across all nine South African provinces
- **Location-based search** — search by province, city, or suburb slug (e.g., "gauteng", "cape-town", "sandton")
- **Zero anti-bot** — no Cloudflare, no DataDome, no CAPTCHA. Datacenter proxies work fine for large-scale runs
- **Auto-pagination** — handles up to 200 pages per location automatically
- **Lean & fast** — CheerioCrawler extracts listings in milliseconds per page with minimal memory footprint
- **No login required** — all data is publicly accessible on Property24

### 📊 What You Can Extract

| Field | Description | Example |
|-------|-------------|---------|
| `propertyId` | Numeric property ID | "117293126" |
| `listingNumber` | Property24 listing number | "P117293126" |
| `title` | Full listing title | "2 Bedroom Apartment / Flat to rent in Kibler Park" |
| `price` | Price in ZAR (numeric) | 7600 |
| `priceFormatted` | Price as displayed | "R 7 600" |
| `description` | Short listing description | "2 Bedroom Apartment in Kibler Park" |
| `location` | Suburb/area name | "Kibler Park" |
| `bedrooms` | Number of bedrooms | 2 |
| `bathrooms` | Number of bathrooms | 1 |
| `parkingSpaces` | Number of parking spaces | 1 |
| `floorSizeM2` | Floor/land size in m² | 51 |
| `listingUrl` | Full property detail URL | property24.com/to-rent/kibler-park/.../117293126 |
| `image` | Main listing image URL | images.prop24.com/355778626/Crop525x350 |
| `agentTitle` | Agency/agent name | "CSi Property Group" |
| `agentLogo` | Agency logo URL | images.prop24.com/214384406/Ensure450x261 |
| `availableBadge` | Availability status | "AVAILABLE: 01 JUL" |
| `availableDate` | Available date | "01 JUL" |
| `searchLocation` | Search location used | "gauteng" |
| `listingType` | Listing type | "to-rent" / "for-sale" / "sold" |
| `scrapedAt` | Extraction timestamp | ISO 8601 |

### 🚀 Use Cases

#### Real Estate Market Research
Analyze South African property markets at scale. Track pricing trends across provinces and cities, identify undervalued areas, and monitor inventory levels by property type and location.

#### Property Investment Intelligence
Screen for investment opportunities across the entire SA market. Filter by price, bedrooms, location to find rental yield opportunities, fix-and-flip candidates, or development land.

#### Competitor & Agent Analysis
Track which agencies are most active in specific areas. Monitor competitor listings, pricing strategies, and market share by suburb or city.

#### Lead Generation for Real Estate Services
Extract agent/agency data to build B2B contact lists. Identify active agents and agencies for partnership, software sales, or service offerings in the SA property sector.

#### Data Pipelines & Analytics
Feed structured SA property data into your data warehouse, BI dashboards, or ML models. Track market changes over time with scheduled scraping runs.

### 📥 Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `listingType` | Enum | ✅ Yes | `"for-sale"` | `"for-sale"`, `"to-rent"`, or `"sold"` |
| `locations` | String array | ✅ Yes | — | SA provinces, cities or suburbs. Examples: `["gauteng"]`, `["western-cape", "cape-town"]`, `["sandton", "durban"]` |
| `maxItems` | Integer | No | 200 | Maximum properties to scrape across all locations |
| `includeDetails` | Boolean | No | `false` | Visit each property page for full descriptions, GPS, agent contacts |
| `proxyConfiguration` | Object | No | Datacenter | Proxy settings. Datacenter works fine. Residential for large runs. |

### 📍 Location Reference

#### Provinces (broadest coverage)
`gauteng`, `western-cape`, `kwazulu-natal`, `eastern-cape`, `free-state`, `limpopo`, `mpumalanga`, `north-west`, `northern-cape`

#### Major Cities
`cape-town`, `johannesburg`, `pretoria`, `durban`, `port-elizabeth`, `bloemfontein`, `east-london`, `polokwane`, `nelspruit`

#### Popular Suburbs
`sandton`, `alberton`, `centurion`, `midrand`, `roodepoort`, `kibler-park`, `umhlanga`, `stellenbosch`, `somerset-west`

> **Tip**: Use lowercase with hyphens for multi-word names. Check property24.com to find the exact URL slug for any location.

### 💰 Pricing & Performance

Property24 Scraper uses a **CheerioCrawler** — the lightest, fastest crawler type:

- **Speed**: ~200-500ms per page (no browser, no JavaScript)
- **Cost**: ~$0.01-0.05 per 1,000 listings (datacenter proxy)
- **Memory**: 512 MB minimum
- **Concurrency**: 8 parallel requests default
- **Pagination**: ~20 listings per page, auto-paginated

### 📋 Example Output

```json
{
  "propertyId": "117293126",
  "listingNumber": "P117293126",
  "title": "2 Bedroom Apartment / Flat to rent in Kibler Park",
  "description": "2 Bedroom Apartment in Kibler Park",
  "price": 7600,
  "priceFormatted": "R 7 600",
  "location": "Kibler Park",
  "bedrooms": 2,
  "bathrooms": 1,
  "parkingSpaces": 1,
  "floorSizeM2": 51,
  "listingUrl": "https://www.property24.com/to-rent/kibler-park/johannesburg/gauteng/5326/117293126",
  "image": "https://images.prop24.com/355778626/Crop525x350",
  "agentTitle": "Contact CSi Property Group to sell your home",
  "agentLogo": "https://images.prop24.com/214384406/Ensure450x261",
  "availableBadge": "AVAILABLE: 01 JUL",
  "availableDate": "01 JUL",
  "listingType": "to-rent",
  "searchLocation": "alberton",
  "scrapedAt": "2026-06-24T14:00:00.000Z"
}
````

### 🏗️ Technical Architecture

Built on:

- **[Crawlee](https://crawlee.dev)** — Apify's open-source scraping framework with request queuing, dedup, and proxy rotation
- **[Cheerio](https://cheerio.js.org)** — Fast jQuery-like HTML parser for server-rendered content
- **[Apify SDK](https://docs.apify.com/sdk/js)** — Cloud platform integration for storage, proxy, and deployment

Property24 serves listings via **server-rendered HTML** (ASP.NET MVC). Each search results page contains ~20 listing cards in structured HTML with clear CSS classes (`p24_tileContainer`, `p24_price`, `p24_featureDetails`, etc.). The scraper parses these cards directly — no JavaScript, no browser, no anti-bot challenges.

### 🔍 Tips for Best Results

- **Use specific locations** for targeted data. "gauteng" returns thousands of listings across the whole province. "sandton" returns focused results for one area.
- **Combine provinces and cities** in one run to build a comprehensive dataset.
- **Run regularly** (weekly/monthly) to track price changes, new developments, and market trends.
- **Set `includeDetails: true`** when you need agent phone numbers and full property descriptions — adds ~1 extra request per listing.
- **Check sold properties** for actual transaction data to calibrate price estimates and investment models.

### ⚙️ Running on Apify

1. Click "Try for free"
2. Select listing type: For Sale, To Rent, or Sold
3. Enter locations (e.g., `["western-cape", "gauteng"]`)
4. Set max items to your desired limit
5. Click "Save & Run"

Results download as JSON, CSV, Excel, or via API integration.

### 📚 Related Actors

- **Realestate.com.kh Scraper** — Cambodia property market
- **Daft.ie Scraper** — Ireland real estate data
- **Hemnet Scraper** — Sweden housing market with sold prices
- **Otodom Scraper** — Poland property listings
- **Funda Scraper** — Netherlands real estate data

### ⚠️ Legal & Responsible Use

This scraper extracts publicly available property listing data from Property24.com. It is designed for market research, investment analysis, and real estate data applications.

Users are responsible for:

- Complying with Property24's Terms of Service
- Respecting rate limits and fair use
- Not scraping personal data beyond publicly displayed listing information
- Complying with POPIA (South Africa's data protection law) and applicable regulations

***

Built for the SA real estate and property data community.

# Actor input Schema

## `listingType` (type: `string`):

Type of property listings to scrape.

## `locations` (type: `array`):

South African provinces, cities, suburbs or areas to search. Examples: "gauteng", "cape-town", "western-cape", "durban", "sandton", "alberton". Lowercase with hyphens for multi-word names.

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

Maximum properties to scrape across all locations. 0 = no limit. ~20 listings per page.

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

Visit each property page for full description, agent contact info, GPS coordinates, and complete feature list. Adds ~1 request per listing.

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

Property24 has no aggressive anti-bot protection. Datacenter proxies work fine. Proxy recommended for large runs to avoid IP rate limiting.

## Actor input object example

```json
{
  "listingType": "for-sale",
  "locations": [
    "western-cape",
    "gauteng",
    "cape-town"
  ],
  "maxItems": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

Clean JSON array of every scraped property listing with all fields.

## `propertiesCsv` (type: `string`):

Spreadsheet-ready CSV export.

## `dataset` (type: `string`):

Default dataset of this run.

# 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 = {
    "listingType": "for-sale",
    "locations": [
        "gauteng"
    ],
    "maxItems": 100,
    "includeDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/property24-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 = {
    "listingType": "for-sale",
    "locations": ["gauteng"],
    "maxItems": 100,
    "includeDetails": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/property24-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 '{
  "listingType": "for-sale",
  "locations": [
    "gauteng"
  ],
  "maxItems": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/property24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Property24 Scraper - SA Property Listings & Agent Data",
        "description": "Scrape Property24 SA real estate: for-sale, to-rent, sold properties with price, beds, baths, floor size, location, agent data. SA property data, market research and lead gen.",
        "version": "1.0",
        "x-build-id": "VqnLUbFywb01OEdnR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~property24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-property24-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/haketa~property24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-property24-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/haketa~property24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-property24-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": [
                    "locations",
                    "listingType"
                ],
                "properties": {
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "for-sale",
                            "to-rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Type of property listings to scrape.",
                        "default": "for-sale"
                    },
                    "locations": {
                        "title": "Search locations",
                        "type": "array",
                        "description": "South African provinces, cities, suburbs or areas to search. Examples: \"gauteng\", \"cape-town\", \"western-cape\", \"durban\", \"sandton\", \"alberton\". Lowercase with hyphens for multi-word names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max properties",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum properties to scrape across all locations. 0 = no limit. ~20 listings per page.",
                        "default": 200
                    },
                    "includeDetails": {
                        "title": "Include property details",
                        "type": "boolean",
                        "description": "Visit each property page for full description, agent contact info, GPS coordinates, and complete feature list. Adds ~1 request per listing.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Property24 has no aggressive anti-bot protection. Datacenter proxies work fine. Proxy recommended for large runs to avoid IP rate limiting.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
