# Das Telefonbuch Scraper (`scrapesmith/telefonbuch-de-scraper`) Actor

Scrape business and person listings from Das Telefonbuch (dastelefonbuch.de). Extract names, addresses, phone numbers, emails, websites, opening hours, reviews, ratings. JSON/CSV/Excel export. API, MCP, webhook, AI-agent ready.

- **URL**: https://apify.com/scrapesmith/telefonbuch-de-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (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 $1.00 / 1,000 results

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/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

## Das Telefonbuch Scraper - German Business & Person Directory

Extract business and person listings from **Das Telefonbuch** (dastelefonbuch.de), Germany's largest phone and business directory. Get names, addresses, phone numbers, emails, websites, opening hours, reviews, and ratings for any business category or person name across all German cities and regions.

### Why this scraper?

- **Richest data available** - Up to 30+ fields per listing including aggregated reviews from Google, Yelp, Speisekarte.de, TripAdvisor, Facebook, and golocal
- **Full contact details** - Phone, fax, mobile, email, and website extracted and decoded automatically
- **Structured opening hours** - Weekly schedule broken down by day, not just a summary
- **Multi-source review aggregation** - External review sources with per-source ratings, review counts, and individual review text
- **Business & person search** - Toggle between business directory (Branchenbuch) and residential phonebook (Telefonbuch)
- **No setup required** - Works out of the box, no API keys or accounts needed
- **Fast & affordable** - Thousands of results in minutes at a fraction of manual research cost
- **Reliable** - Automatic retry logic and state persistence for long-running jobs
- **Export anywhere** - JSON, CSV, Excel, XML with one click

### What data do you get?

Every listing includes up to **30+ fields**:

#### Core fields (always available)

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique listing identifier |
| `name` | string | Business or person name |
| `address` | string | Full formatted address (street, PLZ, city, district) |
| `street` | string | Street name and house number |
| `postalCode` | string | 5-digit German postal code (PLZ) |
| `city` | string | City name |
| `district` | string | City district or Stadtteil |
| `country` | string | Country code (always "DE") |
| `phone` | string | Full phone number |
| `website` | string | Business website URL |
| `category` | string | Business category (Branche) |
| `rating` | number | Aggregate star rating (0-5) |
| `reviewCount` | integer | Total review count |
| `logoUrl` | string | Business logo image URL |
| `openingSummary` | string | Quick opening status text |
| `sourceUrl` | string | Original listing page URL |
| `searchType` | string | "business" or "person" |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Detail fields (with `includeDetails: true`)

| Field | Type | Description |
|-------|------|-------------|
| `email` | string | Email address |
| `fax` | string | Fax number |
| `mobile` | string | Mobile phone number |
| `description` | string | Business description text |
| `openingHours` | string | Structured weekly hours (e.g. "Mo 08:00-18:00; Tu 08:00-18:00") |
| `cuisine` | string | Cuisine type (for restaurants) |
| `searchKeywords` | array | Business search keywords and tags |
| `services` | array | Listed services and specialties |
| `externalReviewSources` | array | Per-source review breakdown with source name, rating, count, and URL |
| `recentReviews` | array | Individual reviews with author, date, text, rating, and source |

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQuery` | string | Yes | - | Business category, name, or keyword. Examples: "Restaurant", "Rechtsanwalt", "Zahnarzt", "Friseur", "Hotel", "Steuerberater" |
| `location` | string | Yes | - | German city, town, or region. Examples: "Berlin", "Hamburg", "Munchen", "Koln", "Frankfurt am Main" |
| `searchType` | string | No | "business" | Set to "business" for the Branchenbuch or "person" for the residential Telefonbuch |
| `maxItems` | integer | No | unlimited | Maximum results to return. Leave empty to collect all available results |
| `includeDetails` | boolean | No | true | Fetch each listing's full profile page for email, hours, reviews, and more. Set to false for faster extraction with fewer fields |

### Example output

```json
{
  "id": "0001131015407",
  "name": "Restaurant und Bierhaus Xantener Eck",
  "address": "Xantener Str. 1, 10707 Berlin, Wilmersdorf",
  "street": "Xantener Str. 1",
  "postalCode": "10707",
  "city": "Berlin",
  "district": "Wilmersdorf",
  "country": "DE",
  "phone": "030 8 83 90 14",
  "fax": "",
  "mobile": "",
  "email": "mail@das-xantener-eck.de",
  "website": "http://www.das-xantener-eck.de",
  "category": "Restaurants",
  "rating": 1.0,
  "reviewCount": 1,
  "logoUrl": "",
  "openingSummary": "Jetzt geoffnet",
  "openingHours": "Mo 12:00-24:00; Tu 12:00-24:00; We 12:00-24:00; Th 12:00-24:00; Fr 12:00-24:00; Sa 12:00-24:00; Su 12:00-24:00",
  "cuisine": "Deutsche Kuche",
  "description": "Traditionelles Berliner Restaurant mit Biergarten.",
  "searchKeywords": ["Berliner Kuche", "Biergarten", "Brunch", "Deutsche Kuche"],
  "services": ["Mittagstisch", "Catering", "Veranstaltungen"],
  "externalReviewSources": [
    {"source": "google", "rating": 4.5, "count": 2061, "url": "https://..."},
    {"source": "yelp", "rating": 3.5, "count": 38, "url": "https://..."}
  ],
  "recentReviews": [
    {"source": "yelp", "rating": 5.0, "author": "Barbara N.", "date": "15.09.2024", "text": "Tolles Essen und guter Service!"}
  ],
  "sourceUrl": "https://www.dastelefonbuch.de/...",
  "searchType": "business",
  "scrapedAt": "2026-07-18T17:45:20.000Z"
}
````

### Use cases

#### Lead generation and sales prospecting

Build targeted B2B lead lists of businesses by category and city. Search for "Rechtsanwalt" (lawyers) in "Frankfurt" or "Zahnarzt" (dentists) in "Berlin" to get complete contact details including phone, email, and website for sales outreach, cold calling, or direct mail campaigns.

#### Market research and competitive analysis

Analyze business density, average ratings, and competition across German cities. Compare the number of restaurants, their review scores, and service offerings between neighborhoods to identify market gaps and opportunities.

#### Local SEO and reputation monitoring

Monitor competitor listings, track review scores across Google, Yelp, and other platforms, and audit your own business listing data. Compare opening hours, categories, and service descriptions across competitors in your area.

#### CRM and database enrichment

Enrich your existing customer or prospect database with verified German business contact details. Match company names and locations to get phone numbers, email addresses, websites, and full postal addresses.

#### Directory monitoring and change detection

Run the scraper periodically to detect new businesses entering a market, track rating changes over time, or monitor when competitors update their listings, hours, or service offerings.

#### Restaurant and hospitality intelligence

Extract restaurant data including cuisine type, opening hours, multi-platform review scores, and individual review text. Build datasets for food delivery market analysis, restaurant recommendation systems, or hospitality industry research.

#### Real estate and location intelligence

Map business density by postal code and district. Identify which areas have the most services, highest-rated businesses, or specific business types to support real estate investment decisions or retail location planning.

### API, MCP & integrations

Use this scraper via the **Apify API**, **MCP server**, or integrate with your existing tools:

- **REST API** - Call via `https://api.apify.com/v2` from any language (Python, JavaScript, Java, Go, Ruby, PHP, etc.)
- **MCP server** - Connect directly to AI agents like Claude, ChatGPT, or custom LLM pipelines for real-time data access
- **JavaScript/TypeScript** - `npm install apify-client` for Node.js integration
- **Python** - `pip install apify-client` for Python scripts, Jupyter notebooks, and data pipelines
- **Webhooks** - Trigger on completion for automated ETL pipelines
- **Integrations** - Works with n8n, Make (Integromat), Zapier, LangChain, LlamaIndex, and any HTTP-capable tool
- **Scheduled runs** - Set up recurring extractions (daily, weekly, monthly) for ongoing monitoring
- **Export formats** - JSON, CSV, Excel (XLSX), XML, RSS

#### Python integration example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "searchQuery": "Restaurant",
    "location": "Berlin",
    "maxItems": 100,
    "includeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} - {item['phone']} - {item['email']}")
```

#### JavaScript integration example

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('YOUR_ACTOR_ID').call({
    searchQuery: 'Zahnarzt',
    location: 'Hamburg',
    maxItems: 50,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.name} - ${item.phone}`));
```

### Tips for best results

- **Be specific with search queries** - "Italienisches Restaurant" returns more targeted results than just "Restaurant"
- **Use German terms** - The directory uses German-language categories. "Rechtsanwalt" works better than "lawyer"
- **Start small** - Test with `maxItems: 10` to verify the output matches your needs before running a large extraction
- **Detail mode tradeoff** - Setting `includeDetails: false` is 3-5x faster but misses email, hours, and reviews. Use it when you only need names, addresses, and phone numbers
- **Common search categories** - Restaurant, Hotel, Arzt (doctor), Zahnarzt (dentist), Rechtsanwalt (lawyer), Friseur (hairdresser), Steuerberater (tax advisor), Handwerker (tradesman), Apotheke (pharmacy), Autowerkstatt (car repair)

### FAQ

**How many results can I get?**
There is no hard limit. The scraper follows pagination automatically to collect as many results as exist for your search query and location combination.

**Does it work for all German cities?**
Yes. Any city, town, or region listed in Das Telefonbuch is supported, from major cities like Berlin, Hamburg, and Munich to small towns and rural areas.

**What is the difference between basic and detail mode?**
Basic mode (`includeDetails: false`) extracts data from search result pages only, which is fast but returns fewer fields (no email, opening hours, or reviews). Detail mode (`includeDetails: true`, the default) visits each listing's full profile page to extract email addresses, structured opening hours, review data, search keywords, services, and business descriptions.

**Can I search for specific businesses by name?**
Yes. Enter the business name as `searchQuery` and the city as `location`. For example, search for "Adlon" in "Berlin" to find the Hotel Adlon.

**What review sources are included?**
The scraper collects reviews aggregated from Google, Yelp, Speisekarte.de, TripAdvisor, Facebook, and golocal. Each source includes its own rating and review count, plus individual review text where available.

**Can I search for people instead of businesses?**
Yes. Set `searchType` to "person" to search the residential phonebook (Telefonbuch) instead of the business directory (Branchenbuch).

**How often is the data updated?**
The scraper extracts live data from Das Telefonbuch on each run. Run it daily, weekly, or monthly depending on your monitoring needs.

**What format is the output in?**
Results are available in JSON, CSV, Excel (XLSX), and XML. You can download them directly from the Apify platform or access them via the API.

**Can I filter results by rating or category?**
The scraper collects all results matching your search. You can filter the output dataset afterward using Apify's built-in dataset filtering or process the data in your own pipeline.

**How long does a typical run take?**
A search with 100 results in detail mode typically completes in 2-5 minutes. Basic mode (without detail pages) is 3-5x faster. Larger extractions scale linearly.

**Is there a free tier?**
Yes. Free users can extract up to 25 results per run to test the scraper before committing to a paid plan.

**What happens if a listing has no email or phone?**
All fields are always present in the output. If a piece of data is not available for a listing, the field will contain an empty string or empty array rather than being omitted. This ensures consistent data structure across all results.

# Actor input Schema

## `searchQuery` (type: `string`):

Business category, name, or keyword to search for (e.g. 'Restaurant', 'Rechtsanwalt', 'Zahnarzt').

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

German city or region to search in (e.g. 'Berlin', 'München', 'Hamburg').

## `searchType` (type: `string`):

Search for businesses or persons.

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

Maximum number of results to return. Leave empty for no limit (subject to plan limits).

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

Fetch full detail pages for each result. Adds email, opening hours, reviews, search keywords, and external review sources. Slower but much richer data.

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

Proxy settings. Datacenter proxy is recommended and free on the Apify platform.

## `debug` (type: `boolean`):

Enable verbose debug logging.

## Actor input object example

```json
{
  "searchQuery": "Restaurant",
  "location": "Berlin",
  "searchType": "business",
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# 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 = {
    "searchQuery": "Restaurant",
    "location": "Berlin"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/telefonbuch-de-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 = {
    "searchQuery": "Restaurant",
    "location": "Berlin",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/telefonbuch-de-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 '{
  "searchQuery": "Restaurant",
  "location": "Berlin"
}' |
apify call scrapesmith/telefonbuch-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Das Telefonbuch Scraper",
        "description": "Scrape business and person listings from Das Telefonbuch (dastelefonbuch.de). Extract names, addresses, phone numbers, emails, websites, opening hours, reviews, ratings. JSON/CSV/Excel export. API, MCP, webhook, AI-agent ready.",
        "version": "0.1",
        "x-build-id": "tIoGWzYm8Kyyvd7T6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~telefonbuch-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-telefonbuch-de-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/scrapesmith~telefonbuch-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-telefonbuch-de-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/scrapesmith~telefonbuch-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-telefonbuch-de-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": [
                    "searchQuery",
                    "location"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Business category, name, or keyword to search for (e.g. 'Restaurant', 'Rechtsanwalt', 'Zahnarzt')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "German city or region to search in (e.g. 'Berlin', 'München', 'Hamburg')."
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "business",
                            "person"
                        ],
                        "type": "string",
                        "description": "Search for businesses or persons.",
                        "default": "business"
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of results to return. Leave empty for no limit (subject to plan limits)."
                    },
                    "includeDetails": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Fetch full detail pages for each result. Adds email, opening hours, reviews, search keywords, and external review sources. Slower but much richer data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxy is recommended and free on the Apify platform.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "debug": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose debug logging.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
