# Herold.at Business Directory Scraper (`automation-lab/herold-at-business-directory-scraper`) Actor

🇦🇹 Export Austrian company leads from Herold.at with phones, emails, websites, addresses, ratings, snippets, and profile URLs.

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

## Herold.at Business Directory Scraper

Export Austrian business listings from Herold.at for lead generation, local SEO checks, market mapping, and sales enrichment.

### What does Herold.at Business Directory Scraper do?

Herold.at Business Directory Scraper extracts public company listings from the Austrian Herold.at Yellow Pages / Gelbe Seiten website.

It can search by business category and location or scrape ready-made Herold search URLs.

Typical output includes company names, addresses, phone numbers, emails, websites, ratings, profile URLs, snippets, and the source search URL.

### Who is it for?

#### Sales teams

Find Austrian companies in a category and export contact details for prospecting.

#### Marketing agencies

Build local SEO and outreach lists by city, district, and industry.

#### Market researchers

Map how many businesses exist in a niche and compare location coverage.

#### Data enrichment teams

Add phone, email, website, address, and Herold profile links to company databases.

### Why use this scraper?

- 🇦🇹 Focused on Austrian local business data.
- 📇 Extracts practical lead fields, not just page titles.
- 🔎 Works from search terms or exact Herold URLs.
- ⚡ Uses HTTP/Cheerio for fast low-cost scraping.
- 🧾 Saves clean tabular data to an Apify dataset.
- 🔁 Follows pagination until your `maxItems` limit.
- 🧩 Optional profile-page enrichment for deeper records.

### Data fields

| Field | Description |
| --- | --- |
| `companyName` | Business name shown on Herold.at |
| `category` | Category/search term context |
| `phone` | Phone number from listing/profile |
| `email` | Email address when available |
| `website` | External business website |
| `streetAddress` | Street and house number |
| `postalCode` | Austrian postal code |
| `city` | City or region value |
| `region` | Full address text |
| `country` | Country code |
| `ratingValue` | Average rating |
| `ratingCount` | Rating count |
| `reviewCount` | Review count when present |
| `profileUrl` | Herold company profile URL |
| `searchUrl` | Herold search result page URL |
| `position` | Listing position on the result page |
| `description` | Listing snippet |
| `verified` | Whether Herold marks the company as verified |
| `branchCode` | Herold identifier when available |
| `profileText` | Optional profile text with enrichment enabled |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Herold.at business leads?

This actor uses pay-per-event pricing.

You pay a small run start fee and then a per-business price for each saved listing.

The exact price is shown on the Apify Store pricing panel before you run the actor.

Use a low `maxItems` value for tests, then increase it for production exports.

### How to scrape Herold.at by keyword and location

1. Open the actor on Apify.
2. Enter `what`, for example `restaurant`, `installateur`, or `steuerberater`.
3. Enter `where`, for example `wien`, `graz`, or `salzburg`.
4. Set `maxItems`.
5. Keep `includeProfiles` disabled for a fast listing export.
6. Start the run.
7. Download the dataset as CSV, JSON, Excel, or via API.

### How to scrape Herold.at search URLs

Paste one or more Herold result URLs into `startUrls`.

Example:

```json
{
  "startUrls": [
    { "url": "https://www.herold.at/gelbe-seiten/wien/restaurant/" }
  ],
  "maxItems": 100,
  "includeProfiles": false
}
````

### Input options

#### `startUrls`

Optional list of Herold search result URLs.

Use this when you already created a search on Herold.at and want the actor to continue from that URL.

#### `what`

Business category or keyword.

Examples: `restaurant`, `zahnarzt`, `friseur`, `installateur`, `steuerberater`.

#### `where`

Austrian location.

Examples: `wien`, `graz`, `linz`, `salzburg`, `innsbruck`.

#### `maxItems`

Maximum number of business listings to save.

The actor follows pagination until this limit is reached or no next page exists.

#### `includeProfiles`

When false, the actor extracts data from search results only.

When true, it opens each Herold profile page to fill missing details and profile text.

#### `proxyConfiguration`

Optional Apify proxy configuration.

The default is direct HTTP because Herold result pages are currently public and server-rendered.

### Output example

```json
{
  "companyName": "EF16 Restaurant Weinbar",
  "category": "restaurant",
  "profileUrl": "https://www.herold.at/gelbe-seiten/wien/sm4rW/ef16-restaurant-weinbar/",
  "searchUrl": "https://www.herold.at/gelbe-seiten/wien/restaurant/",
  "position": 1,
  "description": "Authentische Wiener Küche...",
  "streetAddress": "Fleischmarkt 16",
  "postalCode": "1010",
  "city": "Wien",
  "country": "AT",
  "phone": "+43 1 5132318",
  "email": "office@ef16.at",
  "website": "https://www.ef16.at/",
  "ratingValue": 4.9,
  "ratingCount": 7,
  "verified": true,
  "branchCode": "sm4rW",
  "scrapedAt": "2026-07-03T03:15:10.698Z"
}
```

### Tips for better Herold exports

- Start with 20-50 items to validate the category.
- Use German category terms when possible.
- Use Herold URLs if the site UI produces a more specific search than simple keyword/location.
- Disable profile enrichment for large lead lists.
- Enable profile enrichment for high-value small lists.
- Export to CSV for spreadsheet workflows.
- Export to JSON for enrichment pipelines.

### Integrations

#### CRM import

Download CSV and import leads into HubSpot, Pipedrive, Salesforce, or another CRM.

#### Lead scoring

Combine Herold website, email, ratings, and category fields with your scoring model.

#### Local SEO audits

Check which companies are listed in each Austrian city and category.

#### Agency outreach

Build prospecting lists for websites, reviews, ads, and local marketing services.

#### Data warehouses

Use Apify API or webhooks to send Herold datasets to BigQuery, Snowflake, or Postgres.

### 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/herold-at-business-directory-scraper').call({
  what: 'restaurant',
  where: 'wien',
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/herold-at-business-directory-scraper').call(run_input={
    'what': 'restaurant',
    'where': 'wien',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~herold-at-business-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"what":"restaurant","where":"wien","maxItems":100}'
```

### MCP usage

Use this actor with Apify MCP in Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/herold-at-business-directory-scraper
```

Claude Code setup:

```bash
claude mcp add apify-herold "https://mcp.apify.com/?tools=automation-lab/herold-at-business-directory-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 100 restaurants in Vienna from Herold.at and summarize how many have websites."
- "Find dentists in Graz on Herold.at and return companies with email addresses."
- "Create a CSV of Austrian installers from Herold.at with phone and profile URLs."

### Legality and responsible use

This actor extracts publicly available business directory information.

You are responsible for using the data lawfully, respecting privacy rules, and complying with applicable Austrian and EU regulations.

Do not use scraped contact data for unlawful spam or prohibited outreach.

### FAQ and troubleshooting

#### Why did I get fewer results than `maxItems`?

The selected category/location may have fewer listings, or Herold may stop pagination for that query.

Try a broader location or category.

#### Why are some emails or websites missing?

Not every Herold listing publishes every contact field.

Enable `includeProfiles` to try profile-page enrichment.

#### Do I need proxies?

Usually no. Direct HTTP worked during development.

If you run many large jobs and see rate limiting, enable Apify proxy in the input.

### Related scrapers

Explore other automation-lab local lead and directory scrapers on Apify:

- https://apify.com/automation-lab/wko-austria-business-directory-scraper
- https://apify.com/automation-lab/local-ch-scraper
- https://apify.com/automation-lab/brownbook-business-scraper
- https://apify.com/automation-lab/11880-scraper

### Changelog

#### 0.1

Initial Herold.at business directory scraper with search URL support, keyword/location search, pagination, contact extraction, ratings, and optional profile enrichment.

### Support

If a Herold page layout changes or a query returns unexpected results, open an Apify issue with your run input and dataset sample.

# Actor input Schema

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

Optional Herold.at Gelbe Seiten search result URLs to scrape. If omitted, use the keyword and location fields below.

## `what` (type: `string`):

Business category or search term, for example restaurant, installateur, steuerberater, zahnarzt.

## `where` (type: `string`):

City, district, state, or Austrian location to search on Herold.at.

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

Maximum Herold business listings to save. The actor follows pagination until this limit is reached.

## `includeProfiles` (type: `boolean`):

Visit each Herold company profile for extra details. Slower but can enrich missing contact and profile text fields.

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

Optional Apify proxy settings. Direct HTTP is usually enough for Herold.at; enable proxies only if your run is rate-limited.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.herold.at/gelbe-seiten/wien/restaurant/"
    }
  ],
  "what": "restaurant",
  "where": "wien",
  "maxItems": 20,
  "includeProfiles": false,
  "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.herold.at/gelbe-seiten/wien/restaurant/"
        }
    ],
    "what": "restaurant",
    "where": "wien",
    "maxItems": 20,
    "includeProfiles": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/herold-at-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 = {
    "startUrls": [{ "url": "https://www.herold.at/gelbe-seiten/wien/restaurant/" }],
    "what": "restaurant",
    "where": "wien",
    "maxItems": 20,
    "includeProfiles": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/herold-at-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 '{
  "startUrls": [
    {
      "url": "https://www.herold.at/gelbe-seiten/wien/restaurant/"
    }
  ],
  "what": "restaurant",
  "where": "wien",
  "maxItems": 20,
  "includeProfiles": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/herold-at-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Herold.at Business Directory Scraper",
        "description": "🇦🇹 Export Austrian company leads from Herold.at with phones, emails, websites, addresses, ratings, snippets, and profile URLs.",
        "version": "0.1",
        "x-build-id": "ZyrPSJ38An5RDXhPf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~herold-at-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-herold-at-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~herold-at-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-herold-at-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~herold-at-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-herold-at-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",
                "properties": {
                    "startUrls": {
                        "title": "Herold search URLs",
                        "type": "array",
                        "description": "Optional Herold.at Gelbe Seiten search result URLs to scrape. If omitted, use the keyword and location fields below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "what": {
                        "title": "What / category",
                        "type": "string",
                        "description": "Business category or search term, for example restaurant, installateur, steuerberater, zahnarzt."
                    },
                    "where": {
                        "title": "Where / Austrian location",
                        "type": "string",
                        "description": "City, district, state, or Austrian location to search on Herold.at."
                    },
                    "maxItems": {
                        "title": "Maximum businesses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Herold business listings to save. The actor follows pagination until this limit is reached.",
                        "default": 20
                    },
                    "includeProfiles": {
                        "title": "Open profile pages",
                        "type": "boolean",
                        "description": "Visit each Herold company profile for extra details. Slower but can enrich missing contact and profile text fields.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Direct HTTP is usually enough for Herold.at; enable proxies only if your run is rate-limited."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```