# BusinessesForSale Scraper (`automation-lab/businessesforsale-scraper`) Actor

🏢 Extract public BusinessesForSale listings with price, revenue, cash flow, location, image, description, and URLs for deal sourcing.

- **URL**: https://apify.com/automation-lab/businessesforsale-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## BusinessesForSale Scraper

Extract public BusinessesForSale listing data from search pages for SMB acquisition sourcing, brokerage research, and market monitoring.

### What does BusinessesForSale Scraper do?

BusinessesForSale Scraper collects public listing metadata from BusinessesForSale search result pages. It saves business titles, asking prices, revenue snippets, cash-flow snippets, locations, descriptions, images, and listing URLs into an Apify dataset.

The actor is designed for repeat monitoring workflows where you need structured acquisition leads instead of manually opening many search result pages.

### Who is it for?

- 🧭 Acquisition entrepreneurs and search funds tracking newly listed SMB opportunities.
- 🏢 Business brokers benchmarking asking prices and category activity.
- 📈 Private equity scouts watching sectors, regions, and deal-flow volume.
- 🧩 Lead-generation teams building public business-for-sale prospect lists.
- 🔎 Market researchers comparing business categories and locations.

### Why use it?

BusinessesForSale pages are useful for deal sourcing, but copying listings by hand is slow. This actor turns public result pages into clean rows that you can export to CSV, Excel, Google Sheets, a CRM, or a database.

### Data extracted

| Field | Description |
|---|---|
| `title` | Listing title |
| `url` | Public listing URL |
| `price` | Asking price text when available |
| `numericPrice` | Numeric asking price when present in structured data |
| `currency` | Currency code when available |
| `revenue` | Public revenue snippet |
| `cashFlow` | Public cash-flow snippet |
| `location` | Combined city, region, and country |
| `city` | City/locality |
| `region` | State/region |
| `country` | Country |
| `description` | Public listing teaser |
| `imageUrl` | Listing image URL |
| `sourceUrl` | Search page that produced the row |
| `resultType` | Product result or other/promoted result |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape BusinessesForSale listings?

The actor uses pay-per-event pricing: a small start fee and a per-listing fee. You control spend with `maxItems` and `maxPages`. Start with a small run, inspect the output, then scale to larger monitoring jobs.

### How to use BusinessesForSale Scraper

1. Open the actor on Apify.
2. Paste one or more BusinessesForSale search URLs into `startUrls`.
3. Set `maxItems` and `maxPages`.
4. Leave proxy disabled unless your run is blocked.
5. Run the actor.
6. Export the dataset or connect it to your downstream workflow.

### Input options

#### `startUrls`

BusinessesForSale search result URLs, for example:

```json
[{ "url": "https://www.businessesforsale.com/search/businesses-for-sale" }]
````

#### `searchPath`

Fallback search path used when `startUrls` is empty. Example: `restaurants-for-sale`.

#### `maxItems`

Maximum listings to save.

#### `maxPages`

Maximum search pages to crawl.

#### `includeOtherResults`

Includes BusinessesForSale “Other Results” records in addition to Product Results.

#### `proxyConfiguration`

Optional proxy settings. The default run uses direct HTTP because the site exposes public JSON-LD in HTML.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.businessesforsale.com/search/businesses-for-sale" }
  ],
  "maxItems": 100,
  "maxPages": 10,
  "includeOtherResults": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Example output

```json
{
  "title": "Fast Food Franchise In The Vaal Mall",
  "url": "https://www.businessesforsale.co.za/southafrican/fast-food-franchise-in-the-vaal-mall-1.aspx",
  "sourceUrl": "https://www.businessesforsale.com/search/businesses-for-sale",
  "resultType": "product",
  "position": 1,
  "price": "R595,000",
  "numericPrice": 595000,
  "currency": "ZAR",
  "revenue": "R1.5M - R3M",
  "cashFlow": "R100K - R500K",
  "location": "Vanderbijlpark, Gauteng, South Africa",
  "description": "Fast Food Franchise for sale in the Vaal Mall...",
  "imageUrl": "https://www.businessesforsale.com/uploadsstatic/a3968995mediumthumbnail.jpg",
  "scrapedAt": "2026-06-24T10:49:16.320Z"
}
```

### Tips for better results

- Use specific category or country search URLs when you know the target market.
- Keep `maxPages` conservative for frequent monitoring runs.
- Turn off `includeOtherResults` if you only want core product listings.
- Use `sourceUrl` to segment output by the search that produced each row.
- Export to CSV for quick broker or acquisition pipeline review.

### Integrations

- 📊 Send output to Google Sheets for sourcing dashboards.
- 🧾 Load rows into a CRM and assign review tasks to analysts.
- 🕒 Schedule daily runs to monitor new listings.
- 🧪 Compare `price`, `revenue`, and `cashFlow` across markets.
- 🔔 Trigger alerts when a category or region produces new opportunities.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/businessesforsale-scraper').call({
  startUrls: [{ url: 'https://www.businessesforsale.com/search/businesses-for-sale' }],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/businessesforsale-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.businessesforsale.com/search/businesses-for-sale'}],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~businessesforsale-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.businessesforsale.com/search/businesses-for-sale"}],"maxItems":100}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, or other MCP-compatible clients through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/businessesforsale-scraper
```

Claude Code setup:

```bash
claude mcp add apify-businessesforsale "https://mcp.apify.com/?tools=automation-lab/businessesforsale-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-businessesforsale": {
      "url": "https://mcp.apify.com/?tools=automation-lab/businessesforsale-scraper"
    }
  }
}
```

Example prompts:

- “Run BusinessesForSale Scraper for UK restaurant listings and summarize top opportunities.”
- “Monitor this BusinessesForSale search URL daily and highlight listings with disclosed revenue.”
- “Export the latest business acquisition leads to a spreadsheet-ready table.”

### Scheduling and monitoring

Create an Apify schedule for recurring market monitoring. Use a fixed search URL and a reasonable `maxItems` value so each run stays predictable and affordable.

### Limitations

- The actor extracts public search/listing metadata only.
- It does not scrape gated contact details.
- Some listings may omit price, revenue, cash flow, or images.
- BusinessesForSale may change page markup; the actor prioritizes JSON-LD structured data for resilience.

### FAQ

#### Does this actor scrape contact details?

No. The MVP extracts public search/listing metadata only. Contact forms and gated seller details are out of scope.

#### Can I monitor one country or category?

Yes. Paste the relevant BusinessesForSale search URL into `startUrls`, or use a category-like `searchPath` such as `restaurants-for-sale`.

### Troubleshooting

#### My run returns fewer listings than expected

Increase `maxPages`, enable `includeOtherResults`, or use a broader BusinessesForSale search URL.

#### I get blocked or empty pages

Try enabling Apify Proxy in `proxyConfiguration`. Start with a small `maxItems` value to confirm the connection works.

### Legality

This actor extracts publicly available metadata from public pages. You are responsible for using the data in line with applicable laws, BusinessesForSale terms, and privacy rules. Do not use scraped data for spam, fraud, or unlawful profiling.

### Related scrapers

Automation Lab maintains complementary actors for lead generation, market research, and public listing extraction. See the Automation Lab profile for related tools:

- https://apify.com/automation-lab

### Changelog

#### 0.1

Initial private build: public BusinessesForSale search listing extraction with HTTP + Cheerio.

### Support

If you need a new field or a specific BusinessesForSale search workflow, open an Apify issue with an example URL and the desired output columns.

### Notes for buyers

Use the output as a first-pass sourcing dataset. Always verify important deal details directly on the original listing page before outreach, valuation, or transaction work.

# Actor input Schema

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

One or more BusinessesForSale search result URLs. If omitted, the worldwide businesses-for-sale search is used.

## `searchPath` (type: `string`):

Optional BusinessesForSale search path used when startUrls is empty, for example restaurants-for-sale or businesses-for-sale.

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

Maximum number of listing records to save.

## `maxPages` (type: `integer`):

Maximum search result pages to crawl across all start URLs.

## `includeOtherResults` (type: `boolean`):

Include BusinessesForSale JSON-LD Other Results in addition to Product Results. Turn off for stricter business-listing-only output.

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

Optional proxy settings. Start without proxy; enable Apify Proxy only if your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.businessesforsale.com/search/businesses-for-sale"
    }
  ],
  "searchPath": "businesses-for-sale",
  "maxItems": 20,
  "maxPages": 10,
  "includeOtherResults": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.businessesforsale.com/search/businesses-for-sale"
        }
    ],
    "searchPath": "businesses-for-sale",
    "maxItems": 20,
    "maxPages": 10,
    "includeOtherResults": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/businessesforsale-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 = {
    "startUrls": [{ "url": "https://www.businessesforsale.com/search/businesses-for-sale" }],
    "searchPath": "businesses-for-sale",
    "maxItems": 20,
    "maxPages": 10,
    "includeOtherResults": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/businessesforsale-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 '{
  "startUrls": [
    {
      "url": "https://www.businessesforsale.com/search/businesses-for-sale"
    }
  ],
  "searchPath": "businesses-for-sale",
  "maxItems": 20,
  "maxPages": 10,
  "includeOtherResults": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/businessesforsale-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BusinessesForSale Scraper",
        "description": "🏢 Extract public BusinessesForSale listings with price, revenue, cash flow, location, image, description, and URLs for deal sourcing.",
        "version": "0.1",
        "x-build-id": "fuNknGhQ4dv0JAVqQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~businessesforsale-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-businessesforsale-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/automation-lab~businessesforsale-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-businessesforsale-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/automation-lab~businessesforsale-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-businessesforsale-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": {
                    "startUrls": {
                        "title": "BusinessesForSale search URLs",
                        "type": "array",
                        "description": "One or more BusinessesForSale search result URLs. If omitted, the worldwide businesses-for-sale search is used.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchPath": {
                        "title": "Search path fallback",
                        "type": "string",
                        "description": "Optional BusinessesForSale search path used when startUrls is empty, for example restaurants-for-sale or businesses-for-sale."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listing records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Maximum search result pages to crawl across all start URLs.",
                        "default": 10
                    },
                    "includeOtherResults": {
                        "title": "Include other/promoted results",
                        "type": "boolean",
                        "description": "Include BusinessesForSale JSON-LD Other Results in addition to Product Results. Turn off for stricter business-listing-only output.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Start without proxy; enable Apify Proxy only if your run is blocked."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```