# Herold.at Scraper (`crawlerbros/herold-scraper`) Actor

Scrape Herold.at - Austria's leading business directory (Gelbe Seiten). Search by category and Bundesland/city, or fetch full business profiles with opening hours, ratings, phone, email, and website.

- **URL**: https://apify.com/crawlerbros/herold-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper - Austria's Business Directory (Gelbe Seiten)

Scrape **Herold.at** — Austria's leading business directory ("Gelbe Seiten"). Search any business category (Branche) across Austria's federal states (Bundesländer) and select cities, and get names, addresses, phone numbers, ratings, and opening hours. Search results already include email and website when the business listed one; optionally follow through to each business's full profile page for opening hours per weekday, Facebook page, payment methods, GPS coordinates, offered services, and recent reviews. No login, no cookies, no API key required.

### What this actor does

- **Two modes:** `search` (category + region) and `detail` (direct business profile URLs)
- **39 curated categories** to pick from, or type any custom Branche
- **22 curated Austrian regions** — all 9 federal states (Bundesländer), Wien, select Vorarlberg cities, and 9 state-capital/major-city pages (Graz, Linz, Innsbruck, Klagenfurt, Wels, Villach, St. Pölten, Wiener Neustadt, Steyr) — or type any custom location
- **Full Austrian/German character support** — ä, ö, ü, ß are handled correctly in both input and output
- **Rich business profiles** — opening hours per weekday, payment methods, GPS coordinates, offered services, recent reviews, email, website, Facebook page, full address
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `businessId` — Herold.at internal listing identifier
- `name` — business name
- `category` — the business's listed category
- `street`, `zipCode`, `city`, `district`, `state`, `country` — full address breakdown
- `latitude`, `longitude` — GPS coordinates (mode=detail or `fetchDetails=true`)
- `rating`, `reviewCount` — average star rating (1-5) and number of reviews
- `reviews` — up to 5 recent reviews, each with `title`, `text`, `author`, `date`, `rating` (mode=detail or `fetchDetails=true`)
- `isOpenNow` — live open/closed status from the search listing
- `openingHours` — full weekly schedule keyed by German weekday name (when profile fetched)
- `paymentMethods` — accepted payment methods, e.g. Mastercard, Barzahlung (mode=detail or `fetchDetails=true`)
- `services` — offered services/amenities tags, e.g. Gastgarten, Mittagsmenü (mode=detail or `fetchDetails=true`)
- `phone`, `email`, `website`, `facebookUrl` — `email`/`website` are already present on search results when listed; `facebookUrl` requires the profile page
- `logoUrl` — business logo image
- `description` — short summary of the business
- `searchCategory`, `searchLocation` — the category/region you searched for (mode=search)
- `sourceUrl` — canonical Herold.at profile URL for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (category + region) or `detail` (fetch by URL) |
| `category` | string (select) | `installateur` | Pick a common category, or `custom` to use `customCategory` (mode=search) |
| `customCategory` | string | – | Any free-text category, overrides `category` (mode=search) |
| `location` | string (select) | `Wien` | Pick an Austrian region/city, or `custom` to use `customLocation` (mode=search) |
| `customLocation` | string | – | Any free-text region/city, overrides `location` (mode=search) |
| `fetchDetails` | boolean | `false` | Also visit each business's profile page for richer data (slower) |
| `businessUrls` | array | – | Herold.at profile URLs to fetch directly (mode=detail) |
| `maxItems` | int | `50` | Hard cap on returned records (1-1000) |

#### Example: search plumbers in Vienna

```json
{
  "mode": "search",
  "category": "installateur",
  "location": "Wien",
  "maxItems": 50
}
````

#### Example: dentists in Salzburg, with full profiles

```json
{
  "mode": "search",
  "category": "zahnarzt",
  "location": "Salzburg",
  "fetchDetails": true,
  "maxItems": 30
}
```

#### Example: electricians across Kärnten

```json
{
  "mode": "search",
  "category": "elektriker",
  "location": "Kärnten",
  "maxItems": 100
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "detail",
  "businessUrls": [
    { "url": "https://www.herold.at/gelbe-seiten/wien/3M7DR/ar-all-round-installationen-gmbh/" }
  ]
}
```

### Regions covered

Herold.at groups most search results at the federal-state (Bundesland) level rather than by individual city — searching "Wien" returns Vienna-only results because Vienna is both a city and a state, but searching "Steiermark" returns results across the whole state (Graz included). The curated `location` list covers all 9 Austrian Bundesländer, a handful of Vorarlberg cities that have their own dedicated Herold.at page (Dornbirn, Feldkirch, Bregenz, Bludenz), and 9 state-capital/major-city-only pages that use a "-Stadt" suffix (Graz-Stadt, Linz-Stadt, Innsbruck-Stadt, Klagenfurt-Stadt, Wels-Stadt, Villach-Stadt, St Pölten-Stadt, Wiener Neustadt-Stadt, Steyr-Stadt) — these return a narrower, city-only subset of the state's results. Use `customLocation` to try any other Austrian town name or postal code — if Herold.at has no dedicated page for it, the actor returns 0 results rather than erroring.

### Use cases

- **Local lead generation** — build a prospect list of Austrian businesses by trade and region for B2B outreach
- **Market research** — measure business density and average ratings for a category across Austria
- **Directory aggregation** — feed structured Austrian business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and region, with ratings and contact info
- **Franchise & site-selection analysis** — evaluate service-business coverage across Austrian regions

### FAQ

**What data source does this actor use?**
It reads the publicly available search and business-profile pages on herold.at, Austria's leading Gelbe Seiten directory. No account or API key is needed.

**Is this affiliated with Herold.at?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some businesses have no rating, email, or website?**
Herold.at only shows a rating once a business has received at least one review, and only shows an email/website/Facebook page if the business listed one. Fields with no data are simply omitted from the record rather than shown as empty or null.

**Can I search by city instead of a whole region?**
Herold.at itself only exposes dedicated search pages for a limited set of cities: Wien, Salzburg, several Vorarlberg towns, and the other state capitals/major cities under a "-Stadt" suffix (e.g. `Graz-Stadt`, `Linz-Stadt`). Other locations within a state, such as smaller Tirol or Oberösterreich towns, are only searchable at the state level. You can still try any city name via `customLocation` — the actor gracefully returns 0 results if Herold has no matching page.

**Can I search by postal code instead of a region name?**
You can try, via `customLocation`. Herold.at's postal-code pages are matched to a specific locality within that code range, which may not always be the city you expect — a region/Bundesland or a curated city option is more reliable.

**Why is `fetchDetails` off by default?**
Fetching each business's full profile page requires one extra request per result, which is slower. Turn it on when you need opening hours, email, website, or Facebook page.

**How many businesses are typically available per search?**
It varies widely by category and region — anywhere from a handful of results to 25+ pages (roughly 30 businesses per page). Set `maxItems` to control how many you actually want returned.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search a category + region/city, or fetch full business profiles from direct Herold.at URLs.

## `category` (type: `string`):

Business category to search for. Pick a common category from the list, or choose 'Custom category' and type your own in the field below (mode=search).

## `customCategory` (type: `string`):

Free-text Branche/category not in the curated list above, e.g. 'Tischlerei' or 'Kfz-Werkstatt' (mode=search). Takes priority over 'Category' when set. Best-effort URL match -- if Herold has no page for the exact term, 0 results are returned (no error).

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

Austrian federal state (Bundesland) or a city with its own Herold.at page, e.g. 'Wien', 'Salzburg', 'Graz-Stadt'. Herold.at groups most results at the state level, but state capitals and select cities (suffixed '-Stadt') have their own dedicated, narrower listing page (mode=search).

## `customLocation` (type: `string`):

Free-text Austrian region, city, or postal code not in the curated list above (mode=search). Takes priority over 'Region / city' when set. Best-effort URL match -- if Herold has no dedicated page for the exact term, 0 results are returned (no error).

## `fetchDetails` (type: `boolean`):

For each search result, also visit its business profile page to collect opening hours per weekday, email, website, Facebook page, and full address details. Slower (mode=search).

## `businessUrls` (type: `array`):

Direct Herold.at business profile URLs to fetch, e.g. https://www.herold.at/gelbe-seiten/wien/\<id>/\<slug>/. Use the 'sourceUrl' field from search results.

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "search",
  "category": "installateur",
  "location": "Wien",
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 50
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped Herold.at business listings.

# 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 = {
    "mode": "search",
    "category": "installateur",
    "location": "Wien",
    "fetchDetails": false,
    "businessUrls": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/herold-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 = {
    "mode": "search",
    "category": "installateur",
    "location": "Wien",
    "fetchDetails": False,
    "businessUrls": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/herold-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 '{
  "mode": "search",
  "category": "installateur",
  "location": "Wien",
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 50
}' |
apify call crawlerbros/herold-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Herold.at Scraper",
        "description": "Scrape Herold.at - Austria's leading business directory (Gelbe Seiten). Search by category and Bundesland/city, or fetch full business profiles with opening hours, ratings, phone, email, and website.",
        "version": "1.0",
        "x-build-id": "ssgDS3mBM50ed6KVH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~herold-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-herold-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/crawlerbros~herold-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-herold-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/crawlerbros~herold-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-herold-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "What to fetch: search a category + region/city, or fetch full business profiles from direct Herold.at URLs.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category (Branche)",
                        "enum": [
                            "custom",
                            "installateur",
                            "elektriker",
                            "restaurant",
                            "friseur",
                            "zahnarzt",
                            "rechtsanwalt",
                            "hotel",
                            "dachdecker",
                            "steuerberater",
                            "immobilien",
                            "haarentfernung",
                            "gartencenter",
                            "fahrschule",
                            "garage-parkgarage",
                            "tierarzt",
                            "apotheke",
                            "optiker",
                            "massage",
                            "fensterreinigung",
                            "notar",
                            "versicherungsmakler",
                            "physiotherapie",
                            "bestattungsunternehmen",
                            "maler-anstreicher-u-lackierer",
                            "catering",
                            "campingplatz",
                            "edv-dienstleistung",
                            "facility-management",
                            "buchhaltung",
                            "unternehmensberatung",
                            "bank-sparkasse",
                            "spedition",
                            "tischlerei",
                            "schlosserei",
                            "glaserei",
                            "augenarzt",
                            "hautarzt",
                            "kinderarzt",
                            "frauenarzt"
                        ],
                        "type": "string",
                        "description": "Business category to search for. Pick a common category from the list, or choose 'Custom category' and type your own in the field below (mode=search).",
                        "default": "installateur"
                    },
                    "customCategory": {
                        "title": "Custom category (overrides selection above)",
                        "type": "string",
                        "description": "Free-text Branche/category not in the curated list above, e.g. 'Tischlerei' or 'Kfz-Werkstatt' (mode=search). Takes priority over 'Category' when set. Best-effort URL match -- if Herold has no page for the exact term, 0 results are returned (no error)."
                    },
                    "location": {
                        "title": "Region / city (Bundesland or Ort)",
                        "enum": [
                            "custom",
                            "Wien",
                            "Niederösterreich",
                            "Oberösterreich",
                            "Steiermark",
                            "Tirol",
                            "Kärnten",
                            "Salzburg",
                            "Vorarlberg",
                            "Burgenland",
                            "Dornbirn",
                            "Feldkirch",
                            "Bregenz",
                            "Bludenz",
                            "Graz-Stadt",
                            "Linz-Stadt",
                            "Innsbruck-Stadt",
                            "Klagenfurt-Stadt",
                            "Wels-Stadt",
                            "Villach-Stadt",
                            "St Pölten-Stadt",
                            "Wiener Neustadt-Stadt",
                            "Steyr-Stadt"
                        ],
                        "type": "string",
                        "description": "Austrian federal state (Bundesland) or a city with its own Herold.at page, e.g. 'Wien', 'Salzburg', 'Graz-Stadt'. Herold.at groups most results at the state level, but state capitals and select cities (suffixed '-Stadt') have their own dedicated, narrower listing page (mode=search).",
                        "default": "Wien"
                    },
                    "customLocation": {
                        "title": "Custom location (overrides selection above)",
                        "type": "string",
                        "description": "Free-text Austrian region, city, or postal code not in the curated list above (mode=search). Takes priority over 'Region / city' when set. Best-effort URL match -- if Herold has no dedicated page for the exact term, 0 results are returned (no error)."
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each search result, also visit its business profile page to collect opening hours per weekday, email, website, Facebook page, and full address details. Slower (mode=search).",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs (mode=detail)",
                        "type": "array",
                        "description": "Direct Herold.at business profile URLs to fetch, e.g. https://www.herold.at/gelbe-seiten/wien/&lt;id&gt;/&lt;slug&gt;/. Use the 'sourceUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Herold.at business profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
