# LoopNet Scraper - US Commercial Real Estate Listings (`studio-amba/loopnet-scraper`) Actor

Scrape commercial property listings from LoopNet.com, the largest US commercial real estate marketplace. Extract offices, industrial, retail, land and multifamily for lease or sale with prices, sizes, brokers, and photos. No login required.

- **URL**: https://apify.com/studio-amba/loopnet-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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

## LoopNet Scraper - US Commercial Real Estate Listings

Scrape commercial property listings from **LoopNet.com**, the largest US commercial real estate marketplace. Extract offices, industrial buildings, retail space, land, and multifamily properties for lease or sale — with prices, sizes, brokers, agents, photos, and full listing descriptions.

No login, no cookies, no setup. Pick a city and a transaction type, and get structured JSON, CSV, or Excel output in minutes.

### What data does it extract?

Every listing includes:

| Field | Description | Example |
|---|---|---|
| `listingId` | LoopNet listing identifier | `20044350` |
| `name` | Property name or street address | `667 Madison Ave, New York, NY 10065` |
| `addressLine` | City/state/zip line | `New York, NY 10065` |
| `city` / `state` / `zip` | Parsed address components | `New York` / `NY` / `10065` |
| `transactionType` | `lease` or `sale` | `lease` |
| `propertyType` | Office, Industrial, Retail, Land, Multifamily, ... | `Office` |
| `priceText` | Price as listed | `$15.00 - $25.00/SF/YR`, `Price Upon Request`, or `Starting Bid $5,000,000` |
| `priceMin` / `priceMax` | Parsed price bounds (USD) | `15` / `25` |
| `priceUnit` | Pricing basis | `per sq ft per year` |
| `sizeText` | Floor area or lot size as listed | `2,556 - 102,262 SF` |
| `sizeMinSqFt` / `sizeMaxSqFt` | Parsed size bounds | `2556` / `102262` |
| `buildYear` | Year built, if listed | `2014` |
| `availability` | Availability note | `6 Units Available` |
| `broker` | Brokerage / listing organization | `Cushman & Wakefield` |
| `agent` | Listing agent name | `Stephen Bellwood` |
| `propertyDescription` | Marketing description from the listing card | `Prime Park Avenue location...` |
| `imageUrl` | Primary listing photo | `https://images1.loopnet.com/...` |
| `url` | Direct link to the listing | `https://www.loopnet.com/Listing/...` |

### How to scrape LoopNet commercial real estate data

1. Choose a **transaction type**: for lease or for sale.
2. Enter a **location** — a city and state like `New York, NY` or `Houston, TX`, a two-letter state code like `TX`, or `usa` for a nationwide search.
3. Set **max results** (each search page carries ~25 listings).
4. Run the actor and download the results as JSON, CSV, Excel, or XML from the dataset tab.

That's it. The actor handles the site's bot protection and pagination automatically.

#### Example input

```json
{
    "transaction": "lease",
    "location": "New York, NY",
    "maxResults": 100
}
````

#### Using search URLs directly

Prefer to fine-tune the search on the website? Apply your filters on loopnet.com (property type, size, price, submarket) and paste the result URL into `startUrls`:

```json
{
    "startUrls": [
        { "url": "https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-lease/" }
    ],
    "maxResults": 200
}
```

All filters in the URL are preserved.

#### Filtering by property type

The `propertyTypeSlug` advanced input controls which property category is searched. It defaults to `commercial-real-estate` (all types). Other supported segments include `office-space`, `industrial-space`, `retail-space`, `land`, `apartment-buildings`, `flex-space`, and `coworking-space` — matching the categories LoopNet itself uses in its search URLs.

#### Supported locations

Major US metros are recognized by name: New York, Los Angeles, Chicago, Houston, Phoenix, Philadelphia, San Antonio, San Diego, Dallas, Austin, San Francisco, Seattle, Denver, Boston, Atlanta, Miami, Washington DC, Las Vegas, Portland, Nashville, Charlotte, Detroit, Minneapolis, Columbus, Indianapolis, San Jose, Jacksonville, Orlando, Tampa, Baltimore, St. Louis, Cleveland, Pittsburgh, Cincinnati, Sacramento, Kansas City, Salt Lake City, Raleigh, and Brooklyn. Any two-letter state code (e.g. `TX`, `CA`) searches the whole state, and `usa` searches nationwide.

You can also pass any location slug taken from a loopnet.com URL (the part between the property type and `/for-lease/` or `/for-sale/`), which covers every city and submarket on the site.

#### Example output

```json
{
    "listingId": "13748244",
    "name": "277 Park Ave, New York, NY 10172",
    "addressLine": "New York, NY 10172",
    "city": "New York",
    "state": "NY",
    "zip": "10172",
    "transactionType": "lease",
    "propertyType": "Office",
    "priceText": "Price Upon Request",
    "currency": "USD",
    "sizeText": "21,385 - 430,558 SF",
    "sizeMinSqFt": 21385,
    "sizeMaxSqFt": 430558,
    "buildYear": 1964,
    "broker": "Cushman & Wakefield",
    "agent": "Stephen Bellwood",
    "propertyDescription": "Prime Park Avenue location currently undergoing a $100+ million renovation and only a 4 min walk to 51st Street Transit Stop and a 9 min walk to Grand Central.",
    "url": "https://www.loopnet.com/Listing/277-Park-Ave-New-York-NY/13748244/"
}
```

### Use cases

- **Market research** — track asking rents and sale prices per city, submarket, or property type.
- **Lead generation** — collect broker and agent contacts behind active listings.
- **Investment sourcing** — monitor new industrial, office, retail, or land stock across the US.
- **Portfolio benchmarking** — compare your asking prices against the live market.
- **PropTech products** — feed US commercial availability into your own tools and dashboards.

### Why this scraper?

- **No login or cookies needed** — runs out of the box, nothing to configure.
- **Structured prices and sizes** — raw strings plus parsed numeric bounds and units, ready for analysis.
- **Broker and agent names included** — extracted from the listing's structured data.
- **Handles heavy bot protection** — loopnet.com runs Akamai Bot Manager; this actor ships with a built-in unblocking layer.
- **Pagination built in** — set `maxResults` and the actor walks the result pages for you.

### Pricing

This actor uses pay-per-event pricing: you pay a small fee per actor start and per result returned. A 100-listing run costs well under a few dollars. There are no subscriptions and no minimums — try it with a handful of results first.

### FAQ

**Does it scrape loopnet.co.uk (UK) too?**
No. This actor targets loopnet.com, the US platform. For the UK site, see our separate LoopNet UK Scraper.

**Why does the price sometimes say "Price Upon Request"?**
That's how LoopNet itself lists many commercial properties, especially larger office and investment assets — the field reflects exactly what's shown on the site rather than a missing value. Smaller retail, industrial, and land listings more often carry an explicit $/SF or sale price.

**Can I filter by property type or size?**
Yes — apply the filters on loopnet.com and pass the resulting URL via `startUrls`, or set `propertyTypeSlug` to a specific category. Name-based city search with the default slug returns all commercial property types.

**How fresh is the data?**
Every run fetches live pages. You get whatever is listed at the moment the run executes.

**How many listings can I get per run?**
A large market like New York exposes hundreds of listings per transaction type (~25 per page). Nationwide searches go much deeper. Requests are paced to respect the site, so very large runs take proportionally longer.

**Is this legal?**
The actor only collects publicly visible listing data — no login, no personal accounts, no paywalled content. You are responsible for how you use the data; check applicable laws and the site's terms for your use case.

### Related actors

Looking for residential or other real estate data? Check the [Studio AMBA store](https://apify.com/studio-amba) for Zoopla, Homegate, Immoweb, Otodom, LoopNet UK, and 25+ other real estate scrapers.

# Actor input Schema

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

Search for commercial properties for lease or for sale.

## `location` (type: `string`):

US city and state (e.g. 'New York, NY', 'Houston, TX'), a two-letter state code (e.g. 'TX'), 'usa' for a nationwide search, or a location slug from a loopnet.com URL (e.g. 'new-york-ny').

## `propertyTypeSlug` (type: `string`):

LoopNet property-type URL segment. Default 'commercial-real-estate' covers all types. Other examples: 'office-space', 'industrial-space', 'retail-space', 'land', 'apartment-buildings', 'flex-space', 'coworking-space'.

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

Maximum number of listings to return.

## `startUrls` (type: `array`):

LoopNet.com search-result URLs to scrape, e.g. https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-lease/ — filters applied on loopnet.com are preserved. Overrides transaction/location if provided.

## `brightDataApiKey` (type: `string`):

Optional override for the built-in unblocking service credentials. Leave empty to use the default.

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

Proxy settings. LoopNet.com uses heavy bot protection (Akamai); the built-in unblocking service handles it, so the default works out of the box.

## Actor input object example

```json
{
  "transaction": "lease",
  "location": "New York, NY",
  "propertyTypeSlug": "commercial-real-estate",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "transaction": "lease",
    "location": "New York, NY",
    "propertyTypeSlug": "commercial-real-estate",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/loopnet-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 = {
    "transaction": "lease",
    "location": "New York, NY",
    "propertyTypeSlug": "commercial-real-estate",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/loopnet-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 '{
  "transaction": "lease",
  "location": "New York, NY",
  "propertyTypeSlug": "commercial-real-estate",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/loopnet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LoopNet Scraper - US Commercial Real Estate Listings",
        "description": "Scrape commercial property listings from LoopNet.com, the largest US commercial real estate marketplace. Extract offices, industrial, retail, land and multifamily for lease or sale with prices, sizes, brokers, and photos. No login required.",
        "version": "0.1",
        "x-build-id": "MqOqawnoaEXkhy7Pw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~loopnet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-loopnet-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/studio-amba~loopnet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-loopnet-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/studio-amba~loopnet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-loopnet-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",
                "properties": {
                    "transaction": {
                        "title": "Transaction Type",
                        "enum": [
                            "lease",
                            "sale"
                        ],
                        "type": "string",
                        "description": "Search for commercial properties for lease or for sale.",
                        "default": "lease"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "US city and state (e.g. 'New York, NY', 'Houston, TX'), a two-letter state code (e.g. 'TX'), 'usa' for a nationwide search, or a location slug from a loopnet.com URL (e.g. 'new-york-ny').",
                        "default": "New York, NY"
                    },
                    "propertyTypeSlug": {
                        "title": "Property Type (advanced)",
                        "type": "string",
                        "description": "LoopNet property-type URL segment. Default 'commercial-real-estate' covers all types. Other examples: 'office-space', 'industrial-space', 'retail-space', 'land', 'apartment-buildings', 'flex-space', 'coworking-space'.",
                        "default": "commercial-real-estate"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "LoopNet.com search-result URLs to scrape, e.g. https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-lease/ — filters applied on loopnet.com are preserved. Overrides transaction/location if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key (optional)",
                        "type": "string",
                        "description": "Optional override for the built-in unblocking service credentials. Leave empty to use the default."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. LoopNet.com uses heavy bot protection (Akamai); the built-in unblocking service handles it, so the default works out of the box.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
