# search.ch Swiss Business Directory Scraper (`automation-lab/search-ch-swiss-business-directory-scraper`) Actor

Find Swiss business directory leads on search.ch. Export public names, addresses, phones, websites, ratings, profile links, and emails.

- **URL**: https://apify.com/automation-lab/search-ch-swiss-business-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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

## search.ch Swiss Business Directory Scraper

Find Swiss businesses, professionals, and telephone-directory leads from public search.ch listings.

This Apify Actor searches the public search.ch business and telephone directory and exports structured contact data such as company names, categories, Swiss addresses, phone numbers, websites, profile URLs, ratings, and public email addresses when detail pages expose them.

### What does search.ch Swiss Business Directory Scraper do?

The actor turns public search.ch result pages into clean dataset rows.

- 🔎 Searches by keyword, profession, company type, or company name
- 📍 Supports optional Swiss location filters such as Zurich, Bern, Geneva, Basel, Lugano, or canton codes
- ☎️ Extracts public phone numbers and profile links
- 🌐 Captures website URLs when search.ch lists them
- ✉️ Optionally opens detail pages to collect public email addresses
- 🧾 Adds query, source URL, and scrape timestamp metadata

### Who is it for?

Sales, research, and operations teams use this actor when they need structured Swiss local-business data.

- 🧑‍💼 B2B sales teams building lead lists by industry and region
- 🧭 Market researchers mapping local service providers
- 🏢 Agencies looking for Swiss SMB prospects
- 🛠️ RevOps teams enriching CRM accounts with public directory fields
- 📊 Analysts comparing business density by canton or city

### Why use it?

search.ch is a widely used Swiss directory, but manually copying results is slow and error-prone. This actor automates that collection while keeping the output simple to export to JSON, CSV, Excel, Google Sheets, or your CRM.

### Data you can extract

| Field | Description |
| --- | --- |
| `query` | Search term used |
| `location` | Optional location filter |
| `resultPosition` | Position in returned results |
| `name` | Business or person name |
| `categories` | Directory categories |
| `industry` | First category for quick filtering |
| `description` | Occupation or listing snippet |
| `address` | Full public address |
| `streetAddress` | Street portion |
| `postalCode` | Swiss postal code |
| `locality` | City or municipality |
| `canton` | Canton/region code when shown |
| `phones` | Public phone numbers |
| `website` | Public website URL |
| `email` | Public email from detail page when enabled |
| `profileUrl` | search.ch listing profile |
| `rating` | Rating when available |
| `reviewCount` | Review count when available |
| `isPaidListing` | Whether the result appears as a paid listing |
| `sourceUrl` | Result page URL |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape search.ch business directory leads?

The actor uses pay-per-event pricing: a small start event plus a per-listing event. For typical HTTP-only runs, this is intended to be lightweight for small lead lists and predictable for larger exports.

| Plan tier | Start event | Per extracted listing | Example: 25 listings | Example: 100 listings | Example: 1,000 listings |
| --- | ---: | ---: | ---: | ---: | ---: |
| Free | $0.005 | $0.000115 | about $0.008 | about $0.017 | about $0.120 |
| Bronze | $0.005 | $0.000100 | about $0.008 | about $0.015 | about $0.105 |
| Silver | $0.005 | $0.000078 | about $0.007 | about $0.013 | about $0.083 |
| Gold | $0.005 | $0.000060 | about $0.007 | about $0.011 | about $0.065 |
| Platinum | $0.005 | $0.000040 | about $0.006 | about $0.009 | about $0.045 |
| Diamond | $0.005 | $0.000028 | about $0.006 | about $0.008 | about $0.033 |

Cost formula: `estimated cost = $0.005 start + extracted listings × your tier's per-listing price`. You are charged for listings the actor successfully extracts, not for empty source pages.

Free-plan estimate: a small 20–25 listing test run is usually around one cent or less on the Free tier. A 100-listing prospecting run is typically under two cents before any platform-level subscription or usage rules that apply to your Apify account.

### How to use

1. Open the actor on Apify.
2. Enter one or more search terms, for example `software`, `plumber`, or `dentist`.
3. Optionally enter a Swiss location such as `Zurich`.
4. Choose `maxResults`.
5. Enable `includeDetails` if you need public emails.
6. Run the actor.
7. Export the dataset to CSV, JSON, Excel, or via API.

### Input example

```json
{
  "searchTerms": ["software"],
  "location": "Zurich",
  "language": "de",
  "maxResults": 20,
  "maxPages": 2,
  "includeDetails": false
}
````

### Output example

```json
{
  "query": "software",
  "location": "Zurich",
  "resultPosition": 1,
  "name": "Example Informatik AG",
  "categories": ["Software", "Informatik"],
  "industry": "Software",
  "description": "IT services",
  "address": "Example Street 1, 8000 Zurich ZH",
  "streetAddress": "Example Street 1",
  "postalCode": "8000",
  "locality": "Zurich",
  "canton": "ZH",
  "phones": ["044 000 00 00"],
  "website": "https://example.ch/",
  "email": null,
  "profileUrl": "https://search.ch/tel/...",
  "rating": 4.5,
  "reviewCount": 12,
  "isPaidListing": true,
  "sourceUrl": "https://search.ch/tel/?was=software&wo=Zurich&pages=2",
  "scrapedAt": "2026-06-04T00:00:00.000Z"
}
```

### Tips for better results

- Use Swiss local terms when relevant.
- Try both German and English category names.
- Add a city or canton when you need regional leads.
- Keep the first test run small.
- Turn on detail pages only when emails are important.

### Detail page mode

When `includeDetails` is enabled, the actor visits each public search.ch profile page. This can reveal public email addresses that are obfuscated in page scripts. It also gives the actor another chance to collect website and description fields.

### Integrations

Use the dataset with:

- HubSpot or Salesforce lead imports
- Google Sheets enrichment workflows
- Zapier or Make automations
- Apify webhooks for scheduled lead refreshes
- Internal market maps and regional dashboards

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/search-ch-swiss-business-directory-scraper').call({
  searchTerms: ['software'],
  location: 'Zurich',
  maxResults: 20
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/search-ch-swiss-business-directory-scraper').call(run_input={
    'searchTerms': ['software'],
    'location': 'Zurich',
    'maxResults': 20,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~search-ch-swiss-business-directory-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["software"],"location":"Zurich","maxResults":20}'
```

### MCP usage

Connect Apify MCP with this actor enabled:

`https://mcp.apify.com/?tools=automation-lab/search-ch-swiss-business-directory-scraper`

Claude Code setup:

```bash
claude mcp add apify-search-ch --transport http "https://mcp.apify.com/?tools=automation-lab/search-ch-swiss-business-directory-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-search-ch": {
      "url": "https://mcp.apify.com/?tools=automation-lab/search-ch-swiss-business-directory-scraper"
    }
  }
}
```

Example prompts:

- “Find 20 software companies in Zurich and summarize the dataset.”
- “Scrape public search.ch listings for dentists in Geneva.”
- “Export Swiss plumbing businesses in Bern as CSV.”

### Scheduling

Run the actor weekly or monthly to refresh prospect lists. Use the same inputs and compare datasets over time to spot new public listings or changed contact fields.

### Legality and responsible use

The actor collects information visible on public search.ch pages. You are responsible for using the data lawfully, respecting privacy rules, complying with applicable Swiss/EU data-protection requirements, and honoring source-site terms.

### Limitations

- The actor does not log in.
- It does not bypass CAPTCHA or protected content.
- Public search result depth is capped at 20 pages per term.
- Some listings do not expose websites or emails.
- Email extraction requires detail page mode.

### FAQ

#### Can I scrape emails from search.ch?

Yes, when a listing exposes a public email on its profile page. Enable `includeDetails` so the actor opens profile pages and decodes public email links. Not every listing publishes an email.

#### Does the actor need a search.ch account?

No. It uses public result pages and public profile pages only. It does not log in or access account-only data.

#### Why did I receive fewer results than requested?

The source may have fewer public listings for the keyword and location combination. Try increasing `maxPages`, broadening the keyword, or removing the location filter.

### Troubleshooting

If you get fewer rows than expected, increase `maxPages`, broaden the keyword, or remove the location filter.

If emails are empty, enable `includeDetails`. Many listings still do not publish an email address.

### Related scrapers

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/11880-local-business-directory-scraper
- https://apify.com/automation-lab/gelbe-seiten-scraper

### Changelog

Initial version extracts public search.ch result listings with optional detail-page enrichment.

### Support

If a search.ch page changes or a result field stops appearing, open an issue with a sample input and run URL.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords, business types, company names, or professions to search for in the Swiss search.ch telephone/business directory.

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

Optional Swiss city, canton, postal code, or region to narrow results, for example Zurich, Bern, Geneva, Basel, or TI.

## `language` (type: `string`):

Language version of search.ch to use for labels and result pages.

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

Maximum number of directory listings to save across all search terms. Keep the first run small; search.ch returns 10 results per page.

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

Maximum number of search.ch result pages to load per search term. Each page contains about 10 listings; the public page supports up to 20 pages.

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

Open each public profile page to extract email addresses when search.ch exposes them. This is slower but adds more lead/contact value.

## Actor input object example

```json
{
  "searchTerms": [
    "software"
  ],
  "location": "Zurich",
  "language": "de",
  "maxResults": 20,
  "maxPages": 2,
  "includeDetails": false
}
```

# Actor output Schema

## `businessListings` (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 = {
    "searchTerms": [
        "software"
    ],
    "location": "Zurich"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/search-ch-swiss-business-directory-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 = {
    "searchTerms": ["software"],
    "location": "Zurich",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/search-ch-swiss-business-directory-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 '{
  "searchTerms": [
    "software"
  ],
  "location": "Zurich"
}' |
apify call automation-lab/search-ch-swiss-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "search.ch Swiss Business Directory Scraper",
        "description": "Find Swiss business directory leads on search.ch. Export public names, addresses, phones, websites, ratings, profile links, and emails.",
        "version": "0.1",
        "x-build-id": "vMgkw9t7cTmdiaInd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~search-ch-swiss-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-search-ch-swiss-business-directory-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~search-ch-swiss-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-search-ch-swiss-business-directory-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~search-ch-swiss-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-search-ch-swiss-business-directory-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "minItems": 1,
                        "type": "array",
                        "description": "Keywords, business types, company names, or professions to search for in the Swiss search.ch telephone/business directory.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional Swiss city, canton, postal code, or region to narrow results, for example Zurich, Bern, Geneva, Basel, or TI."
                    },
                    "language": {
                        "title": "search.ch language",
                        "enum": [
                            "de",
                            "fr",
                            "it",
                            "en"
                        ],
                        "type": "string",
                        "description": "Language version of search.ch to use for labels and result pages.",
                        "default": "de"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of directory listings to save across all search terms. Keep the first run small; search.ch returns 10 results per page.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of search.ch result pages to load per search term. Each page contains about 10 listings; the public page supports up to 20 pages.",
                        "default": 2
                    },
                    "includeDetails": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Open each public profile page to extract email addresses when search.ch exposes them. This is slower but adds more lead/contact value.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```