# MagicBricks Scraper - India Property Listings (`benthepythondev/magicbricks-scraper`) Actor

Scrape public MagicBricks sale and rental listings across India with price, BHK, area, location, project, builder, images, lister and RERA metadata.

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

## Pricing

from $5.00 / 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.

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

## MagicBricks Scraper - India Property Listings

Scrape public MagicBricks property listings across India and export structured sale or rental data. Search by city and property type, then collect the asking price, BHK, bathrooms, balconies, area, price per square foot, locality, address, property description, photos, furnishing, ownership, parking, facing, possession status, agent or owner name, agency, RERA-agent registration, coordinates, and listing URL.

The Actor uses MagicBricks' first-party public web search endpoint instead of rendering every result page in a browser. That makes collection faster and more predictable while preserving the rich fields shown in search. A direct request is attempted first; if MagicBricks blocks the datacenter route, the Actor switches to a sticky India residential session. Results are deduplicated before they are written to the dataset.

### What you can collect

Each property row can include:

- MagicBricks listing ID and direct listing URL;
- property title and public description;
- sale or rent transaction type;
- property type, BHK, bathrooms, and balconies;
- numeric asking price, formatted Indian price, and currency;
- price per square foot, covered area in square feet, and converted square metres;
- city, locality, landmark, and public address;
- project, builder, furnishing, ownership, facing, parking, and flooring;
- possession and transaction status;
- posted date and the visible posted label;
- latitude and longitude when the listing provides them;
- one preview photo and the complete public photo array;
- lister name, lister type, lister ID, and agency;
- RERA-agent status and public registration value when shown;
- approval authority and listing quality flags; and
- a transparent lead score based on contact, agency, registration, location, image, price, URL, and description completeness.

MagicBricks does not expose an email address or phone number in every public search result. The Actor does not invent or infer contact details. It returns the public agent, owner, agency, and RERA fields that the first-party search response actually supplies.

### Use cases

#### Property-market research

Collect comparable asking prices for apartments, houses, villas, plots, or land in major Indian cities. Export the data to a spreadsheet or database and calculate median asking price, price per square foot, inventory mix, or differences between localities. Listing prices are offers, not completed transaction prices, so use them as market signals rather than registered-sale evidence.

#### Real-estate lead research

Build a list of public agents, owners, agencies, and RERA-registered professionals attached to active listings. Sort by `lead_score` to prioritize complete records. Before outreach, verify the listing is current and follow applicable Indian privacy, telecom, anti-spam, and platform rules.

#### Rental and acquisition monitoring

Run separate saved Tasks for sale and rent searches. Schedule them daily or weekly, compare listing IDs, and identify newly observed inventory, changed asking prices, or properties that disappear from search.

#### Location and investment analysis

Use locality, coordinates, area, price, and price-per-square-foot fields in a BI dashboard or map. Combine the dataset with public infrastructure, commute, RERA, or neighborhood data to support manual investment research. The Actor does not provide investment advice or guarantee listing accuracy.

#### Broker and agency intelligence

Measure which agencies appear in selected locations, what property types they represent, and how complete their listings are. Agency fields are only returned when MagicBricks publishes them in the result response.

#### Automation and feeds

Connect the default dataset to Make, Zapier, n8n, Google Sheets, Airtable, a warehouse, or your application through the Apify API. Bounded defaults make it practical to create repeat-use city feeds without unbounded crawling.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `cities` | array | Indian city names such as Bengaluru, Mumbai, Hyderabad, Pune, Chennai, Kolkata, Ahmedabad, or New Delhi. |
| `transaction` | string | `sale` or `rent`. |
| `propertyTypes` | array | One or more of `apartment`, `house`, or `plot`. |
| `maxResultsPerSearch` | integer | Maximum listings for each city and property-type combination. Default: 10. |
| `maxPagesPerSearch` | integer | Safety limit for pagination. |

Example sale search:

```json
{
  "cities": ["Bengaluru", "Hyderabad"],
  "transaction": "sale",
  "propertyTypes": ["apartment", "house"],
  "maxResultsPerSearch": 25,
  "maxPagesPerSearch": 2
}
````

Example rental search:

```json
{
  "cities": ["Mumbai"],
  "transaction": "rent",
  "propertyTypes": ["apartment"],
  "maxResultsPerSearch": 20,
  "maxPagesPerSearch": 2
}
```

The result limit applies to each city and property-type combination. Two cities and two property types can therefore return up to four times `maxResultsPerSearch`, subject to actual availability and deduplication.

### Output example

```json
{
  "id": "82455477",
  "url": "https://www.magicbricks.com/propertyDetails-...",
  "title": "4BHK Residential House for New Property in Horamavu",
  "description": "Beautiful 4 BHK duplex house for sale...",
  "transaction": "sale",
  "property_type": "Residential House",
  "bedrooms": 4,
  "bathrooms": 4,
  "balconies": 1,
  "price": 20300000,
  "price_display": "2.03 Cr",
  "currency": "INR",
  "price_per_sqft": 9227,
  "area_sqft": 2200,
  "area_sqm": 204.39,
  "city": "Bangalore",
  "locality": "Horamavu",
  "address": "Bangalore, Karnataka",
  "furnishing": "Semi-Furnished",
  "ownership": "Freehold",
  "possession_status": "Ready to Move",
  "latitude": 13.03171017,
  "longitude": 77.66088781,
  "lister_name": "Surya",
  "lister_type": "Agent",
  "agency": "Nexus Walls Pvt Ltd",
  "is_rera_agent": true,
  "rera_agent_id": "PRM/KA/RERA/...",
  "lead_score": 100,
  "search_city": "Bengaluru",
  "search_rank": 1,
  "scraped_at": "2026-07-11T13:00:00+00:00"
}
```

Fields can be null when a seller did not publish them. Numeric output remains numeric wherever the source provides a usable value, while formatted Indian prices are preserved separately in `price_display`.

### How it works

1. The Actor validates the cities, transaction, property types, and limits.
2. It resolves known city names to MagicBricks search identifiers and can use the public autosuggest endpoint for additional cities.
3. It calls the first-party property search endpoint with the selected transaction and property type.
4. Direct access is attempted first to minimize cost.
5. If the source blocks the datacenter route, the Actor creates one sticky India residential session and reuses it.
6. It maps the current MagicBricks response fields rather than relying on outdated HTML selectors.
7. Listings are deduplicated by source ID or URL.
8. The Actor pushes one clean dataset item per unique listing and fails explicitly if no usable properties are returned.

The Actor runs with limited Apify permissions and only writes to its default dataset. It does not require a MagicBricks login, seller account, or user credentials.

### Pricing

This Actor uses pay-per-event pricing: a minimal start event and a flat `$0.005` event for each unique property written to the default dataset. Duplicate or unusable records are not pushed and do not create result events. Check the current Store pricing panel before a large run because Store pricing is authoritative.

The per-property rate follows the portfolio's standard for new real-estate Actors. It is positioned for reusable lead and market data rather than a high run-start fee. Residential proxy use is handled inside the Actor when needed.

### Reliability notes

Property portals change fields and traffic controls. This Actor validates the first-party JSON response and raises an error on empty output instead of returning a misleading successful run. For recurring feeds, save a Task, keep limits reasonable, and enable Apify failure notifications.

Search results are dynamic. Ranking, inventory, pricing, lister status, and public metadata can change between runs. Always open the listing URL before making a purchase, rental, outreach, or compliance decision. MagicBricks and individual advertisers remain responsible for source content.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/benthepythondev~magicbricks-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cities":["Bengaluru"],"transaction":"sale","propertyTypes":["apartment"],"maxResultsPerSearch":10,"maxPagesPerSearch":1}'
```

Read or export the default dataset after the run succeeds. Keep Apify tokens in secret storage or server-side environment variables and never publish them in client-side code.

### Frequently asked questions

#### Can it scrape properties for rent?

Yes. Set `transaction` to `rent`.

#### Does it support cities outside the hardcoded examples?

The Actor knows common major-city identifiers and can resolve additional Indian cities through MagicBricks' public autosuggest data. If a small locality is not resolved as a city, use its parent city.

#### Does `apartment` return only apartment cards?

MagicBricks controls its property-type codes and can include related residential inventory. The Actor returns the exact `property_type` published for each listing so downstream filtering stays truthful.

#### Are phone numbers or emails included?

Only when the public search response provides them. The current result feed commonly exposes agent or owner names, agency, lister type, and RERA-agent information but not a direct phone or email for every card.

#### What does `lead_score` mean?

It is a transparent completeness score, not a prediction of conversion. Points come from public lister, agency, RERA, coordinates, images, price, URL, and description fields.

#### Why can a listing have no coordinates?

Some advertisers omit precise map data or publish zero coordinates. The Actor does not geocode or guess an address because that could introduce incorrect location claims.

### Related Actors

- [Sreality Scraper](https://apify.com/benthepythondev/sreality-scraper) for Czech property and agent-lead research.
- [PropertyFinder Scraper](https://apify.com/benthepythondev/propertyfinder-scraper) for UAE property and broker data.
- [Idealista Scraper](https://apify.com/benthepythondev/idealista-scraper) for Spain property listings.
- [Real Estate Agent Lead Scraper](https://apify.com/benthepythondev/real-estate-agent-lead-scraper) for agency-oriented lead workflows.

If this Actor produces useful property data, leave an honest Apify Store review. For support, include the run ID, a sanitized input, and the expected result; never share login credentials or API tokens.

Keywords: MagicBricks scraper, India property API, Bangalore real estate scraper, Mumbai rental scraper, property listing data, Indian real estate leads, RERA agent scraper, MagicBricks property search, house price dataset, Apify real estate scraper.

# Actor input Schema

## `cities` (type: `array`):

Indian city names to search on MagicBricks.

## `transaction` (type: `string`):

Search properties offered for sale or for rent.

## `propertyTypes` (type: `array`):

One or more residential property types to collect.

## `maxResultsPerSearch` (type: `integer`):

Maximum unique listings saved for each city and property-type combination.

## `maxPagesPerSearch` (type: `integer`):

Safety cap for MagicBricks search pagination.

## Actor input object example

```json
{
  "cities": [
    "Bengaluru",
    "Mumbai"
  ],
  "transaction": "sale",
  "propertyTypes": [
    "apartment"
  ],
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "cities": [
        "Bengaluru",
        "Mumbai"
    ],
    "transaction": "sale",
    "propertyTypes": [
        "apartment"
    ],
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/magicbricks-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 = {
    "cities": [
        "Bengaluru",
        "Mumbai",
    ],
    "transaction": "sale",
    "propertyTypes": ["apartment"],
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/magicbricks-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 '{
  "cities": [
    "Bengaluru",
    "Mumbai"
  ],
  "transaction": "sale",
  "propertyTypes": [
    "apartment"
  ],
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 20
}' |
apify call benthepythondev/magicbricks-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MagicBricks Scraper - India Property Listings",
        "description": "Scrape public MagicBricks sale and rental listings across India with price, BHK, area, location, project, builder, images, lister and RERA metadata.",
        "version": "1.0",
        "x-build-id": "ekDxZkTBx1dSRvJR1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~magicbricks-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-magicbricks-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/benthepythondev~magicbricks-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-magicbricks-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/benthepythondev~magicbricks-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-magicbricks-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": [
                    "cities"
                ],
                "properties": {
                    "cities": {
                        "title": "Indian cities",
                        "type": "array",
                        "description": "Indian city names to search on MagicBricks.",
                        "default": [
                            "Bengaluru"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "transaction": {
                        "title": "Transaction",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Search properties offered for sale or for rent.",
                        "default": "sale"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "One or more residential property types to collect.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartment",
                                "house",
                                "plot"
                            ]
                        },
                        "default": [
                            "apartment"
                        ]
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum listings per city and type",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique listings saved for each city and property-type combination.",
                        "default": 10
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per city and type",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety cap for MagicBricks search pagination.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
