# DasTelefonbuch Scraper - German Business Directory (`crawlerbros/dastelefonbuch-scraper`) Actor

Scrape DasTelefonbuch.de (Germany's business directory) listings. Search by category (Branche) and city (Ort), or fetch full business profiles by URL. Get names, addresses, phone numbers, ratings, opening hours, websites, and coordinates.

- **URL**: https://apify.com/crawlerbros/dastelefonbuch-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, Lead generation
- **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.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

## DasTelefonbuch Scraper - German Business Directory

Scrape **DasTelefonbuch** (dastelefonbuch.de) — one of Germany's leading business directories. Search any business category (Branche) in any German city, town, or postal code and get names, addresses, phone numbers, ratings, opening status, and websites. Optionally follow through to each business's full profile page for precise GPS coordinates, opening-hours text, and the complete list of registered categories. No login, no cookies, no API key required.

### What this actor does

- **Two modes:** `search` (category + city) and `detail` (direct business profile URLs)
- **40+ curated categories** to pick from, or type any custom Branche
- **Sort by** relevance, rating, or name (A-Z)
- **Filter by** "open now", minimum star rating (1-5), or "has at least one rating"
- **Full German character support** — ä, ö, ü, ß are handled correctly in both input and output
- **Rich business profiles** — GPS coordinates, structured opening hours, email, logo, services, all listed categories
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `category` — the business's primary listed category (mode=search)
- `categories[]` — all registered categories (when profile fetched)
- `rating`, `reviewCount` — average star rating (1-5) and number of reviews
- `street`, `zipCode`, `city`, `district`
- `latitude`, `longitude` — precise GPS coordinates (when profile fetched)
- `isOpenNow` — live open/closed status from the search listing
- `openingHours[]` — structured opening hours (`{day, open, close}` per slot; when profile fetched and the business publishes schema.org hours)
- `openingHoursText` — human-readable opening-hours summary (when profile fetched)
- `phone`, `email`, `website`, `logoUrl`
- `services[]` — listed services/offerings ("Dienstleistungen"), `searchKeywords[]` — the business's own search-keyword list (when profile fetched and published)
- `searchCategory`, `searchCity` — the category/city you searched for (mode=search)
- `sourceUrl` — canonical DasTelefonbuch profile URL for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (category + city) or `detail` (fetch by URL) |
| `category` | string (select) | `Klempner` | Pick a common category, or `custom` to use `customCategory` (mode=search) |
| `customCategory` | string | – | Any free-text category, overrides `category` (mode=search) |
| `city` | string | `Berlin` | City, town, or postal code to search in (mode=search) |
| `sortBy` | string (select) | `relevance` | `relevance` / `rating` (highest first) / `name` (A-Z) |
| `openNowOnly` | boolean | `false` | Only return businesses currently open |
| `ratedOnly` | boolean | `false` | Only return businesses that have at least one rating (ignored when `minRating` is set) |
| `minRating` | string (select) | – (no minimum) | Only return businesses rated at least `1`-`5` stars |
| `fetchDetails` | boolean | `false` | Also visit each business's profile page for richer data (slower) |
| `businessUrls` | array | – | DasTelefonbuch profile URLs to fetch directly (mode=detail) |
| `maxItems` | int | `50` | Hard cap on returned records (1-1000) |

#### Example: search plumbers in Berlin

```json
{
  "mode": "search",
  "category": "Klempner",
  "city": "Berlin",
  "maxItems": 50
}
````

#### Example: highest-rated restaurants in Munich, with full profiles

```json
{
  "mode": "search",
  "customCategory": "Restaurant",
  "city": "München",
  "sortBy": "rating",
  "fetchDetails": true,
  "ratedOnly": true,
  "maxItems": 30
}
```

#### Example: lawyers open right now in Cologne, A-Z

```json
{
  "mode": "search",
  "category": "Rechtsanwalt",
  "city": "Köln",
  "sortBy": "name",
  "openNowOnly": true,
  "maxItems": 100
}
```

#### Example: 4+ star electricians in Hamburg, with full profiles (email, hours, services)

```json
{
  "mode": "search",
  "category": "Elektroinstallation",
  "city": "Hamburg",
  "minRating": "4",
  "fetchDetails": true,
  "maxItems": 40
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "detail",
  "businessUrls": [
    { "url": "https://adresse.dastelefonbuch.de/Berlin/1-Klempner-Wolfgang-Barthelt-Berlin-Heiligenseestr.html" }
  ]
}
```

### Use cases

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

### FAQ

**What data source does this actor use?**
It reads the publicly available search and business-profile pages on dastelefonbuch.de, a leading German business directory. No account or API key is needed.

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

**Why do some businesses have no rating, phone, or website?**
DasTelefonbuch only shows a rating once a business has received at least one review, and only shows contact details a business itself provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**What's the difference between `category` and `categories`?**
`category` is the single category shown on the search-results card. `categories` (only populated with `fetchDetails: true`, or always in `detail` mode) lists the category text from the business's full profile page.

**Can I search by postal code instead of a city name?**
Yes — the `city` field accepts German postal codes as well as city/town names.

**How accurate are the GPS coordinates?**
`latitude`/`longitude` come directly from the business's own DasTelefonbuch profile page (only available with `fetchDetails: true` in search mode, or always in `detail` mode).

**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 coordinates, structured opening hours, email, logo, services, or the full category list.

**How does `minRating` differ from `ratedOnly`?**
`ratedOnly` returns any business with at least one review (any star rating). `minRating` is stricter — it only returns businesses rated at least the chosen number of stars, using DasTelefonbuch's own rating-tier filter. Set `minRating` when you need a quality bar, not just "has reviews".

**Where does `email` come from?**
Business profile pages hide the email address behind Cloudflare's email-obfuscation mechanism to block scrapers; this actor decodes it locally. Only populated with `fetchDetails: true` in search mode, or always in `detail` mode, and only when the business has published an email.

# Actor input Schema

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

What to fetch: search a category + city, or fetch full business profiles from direct 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. 'Fensterreinigung' or 'Yoga-Studio' (mode=search). Takes priority over 'Category' when set.

## `city` (type: `string`):

German city, town, or postal code to search in, e.g. 'Berlin', 'München', 'Köln', 'Hamburg' (mode=search).

## `sortBy` (type: `string`):

How to order search results (mode=search).

## `openNowOnly` (type: `boolean`):

Only return businesses that are currently open (mode=search).

## `ratedOnly` (type: `boolean`):

Only return businesses that have at least one customer rating (mode=search). Ignored when 'Minimum rating' below is set.

## `minRating` (type: `string`):

Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search). Applied both server-side (via DasTelefonbuch's own rating filter) and as a client-side safety check.

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

For each search result, also visit its business profile page to collect precise coordinates, opening hours text, and the full list of categories. Slower (mode=search).

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

Direct DasTelefonbuch business profile URLs to fetch, e.g. https://adresse.dastelefonbuch.de/\<city>/\<id-slug>.html. 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": "Klempner",
  "city": "Berlin",
  "sortBy": "relevance",
  "openNowOnly": false,
  "ratedOnly": false,
  "minRating": "",
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped DasTelefonbuch 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": "Klempner",
    "city": "Berlin",
    "sortBy": "relevance",
    "openNowOnly": false,
    "ratedOnly": false,
    "minRating": "",
    "fetchDetails": false,
    "businessUrls": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/dastelefonbuch-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": "Klempner",
    "city": "Berlin",
    "sortBy": "relevance",
    "openNowOnly": False,
    "ratedOnly": False,
    "minRating": "",
    "fetchDetails": False,
    "businessUrls": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/dastelefonbuch-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": "Klempner",
  "city": "Berlin",
  "sortBy": "relevance",
  "openNowOnly": false,
  "ratedOnly": false,
  "minRating": "",
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 50
}' |
apify call crawlerbros/dastelefonbuch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DasTelefonbuch Scraper - German Business Directory",
        "description": "Scrape DasTelefonbuch.de (Germany's business directory) listings. Search by category (Branche) and city (Ort), or fetch full business profiles by URL. Get names, addresses, phone numbers, ratings, opening hours, websites, and coordinates.",
        "version": "1.0",
        "x-build-id": "t2DvHjFUFouZFIKhc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~dastelefonbuch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-dastelefonbuch-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~dastelefonbuch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-dastelefonbuch-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~dastelefonbuch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-dastelefonbuch-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 + city, or fetch full business profiles from direct URLs.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category (Branche)",
                        "enum": [
                            "custom",
                            "Klempner",
                            "Restaurant",
                            "Rechtsanwalt",
                            "Zahnarzt",
                            "Arzt",
                            "Allgemeinarzt",
                            "Friseur",
                            "Hotel",
                            "Elektroinstallation",
                            "Dachdecker",
                            "Maler",
                            "Steuerberater",
                            "Immobilien",
                            "Gartenbau",
                            "Bestatter",
                            "Physiotherapie",
                            "Tierarzt",
                            "Apotheke",
                            "Optiker",
                            "Fahrschule",
                            "Kfz-Werkstatt",
                            "Gebäudereinigung",
                            "Umzugsunternehmen",
                            "Bäckerei",
                            "Metzgerei",
                            "Kosmetikstudio",
                            "Massage",
                            "Fitnessstudio",
                            "Sanitärinstallation",
                            "Heizung",
                            "Schreiner",
                            "Fenster",
                            "Kanalreinigung",
                            "Rohrreinigung",
                            "Kammerjäger",
                            "Logopädie",
                            "Bauunternehmen",
                            "Notar",
                            "Architekt",
                            "Versicherungsmakler",
                            "Nachhilfe"
                        ],
                        "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": "Klempner"
                    },
                    "customCategory": {
                        "title": "Custom category (overrides selection above)",
                        "type": "string",
                        "description": "Free-text Branche/category not in the curated list above, e.g. 'Fensterreinigung' or 'Yoga-Studio' (mode=search). Takes priority over 'Category' when set."
                    },
                    "city": {
                        "title": "City / location (Ort)",
                        "type": "string",
                        "description": "German city, town, or postal code to search in, e.g. 'Berlin', 'München', 'Köln', 'Hamburg' (mode=search).",
                        "default": "Berlin"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order search results (mode=search).",
                        "default": "relevance"
                    },
                    "openNowOnly": {
                        "title": "Open now only",
                        "type": "boolean",
                        "description": "Only return businesses that are currently open (mode=search).",
                        "default": false
                    },
                    "ratedOnly": {
                        "title": "Only businesses with ratings",
                        "type": "boolean",
                        "description": "Only return businesses that have at least one customer rating (mode=search). Ignored when 'Minimum rating' below is set.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search). Applied both server-side (via DasTelefonbuch's own rating filter) and as a client-side safety check.",
                        "default": ""
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each search result, also visit its business profile page to collect precise coordinates, opening hours text, and the full list of categories. Slower (mode=search).",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs (mode=detail)",
                        "type": "array",
                        "description": "Direct DasTelefonbuch business profile URLs to fetch, e.g. https://adresse.dastelefonbuch.de/&lt;city&gt;/&lt;id-slug&gt;.html. Use the 'sourceUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "DasTelefonbuch 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
