# GoYellow.de Business Directory Scraper (`automation-lab/goyellow-business-directory-scraper`) Actor

Scrape public German business listings from GoYellow.de by keyword and city, including addresses, phones, websites, ratings, and profile URLs.

- **URL**: https://apify.com/automation-lab/goyellow-business-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## GoYellow.de Business Directory Scraper

Scrape German local business listings from GoYellow.de by keyword and city.

Use this actor to collect structured business leads with names, categories, addresses, phone numbers, websites, ratings, review counts, opening-status text, coordinates, GoYellow profile URLs, and source search URLs.

### What does GoYellow.de Business Directory Scraper do?

GoYellow.de Business Directory Scraper extracts public business listings from GoYellow.de search result pages.

It is designed for German local-business research where you need repeatable exports instead of manually copying directory pages.

The actor can search by business type and location, follow pagination, and optionally open each company profile page for phone and website enrichment.

Typical examples:

- Restaurants in Berlin
- Dentists in Hamburg
- Hair salons in Munich
- Tax advisors in Cologne
- Hotels in Frankfurt

### Who is it for?

This scraper is useful for teams that need German SMB data.

- 🧲 Sales teams building regional prospect lists
- 📍 Local SEO agencies mapping competitors and citations
- 🏢 B2B researchers profiling German business categories
- 🧾 Data enrichment teams validating addresses and public contact pages
- 🧑‍💻 Automation builders feeding CRM, Clay, Airtable, or spreadsheets

### Why use this actor?

GoYellow is a German business directory with public local listings.

Manual collection is slow because each search can span many pages and detail pages.

This actor turns those pages into clean JSON records.

Benefits:

- Search by keyword and city
- Export directly to JSON, CSV, Excel, or API
- Enrich with detail-page phone and website links
- Keep source and profile URLs for verification
- Limit result volume for cost control

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Business name |
| `categories` | Category chips shown by GoYellow |
| `address` | Full visible address |
| `streetAddress` | Street and house number |
| `postalCode` | German postal code |
| `city` | City/locality |
| `country` | Country code when present |
| `phone` | Phone number from detail page when public |
| `website` | External business website when public |
| `rating` | GoYellow rating value |
| `reviewCount` | Number of reviews |
| `openingStatus` | Visible opening-status text |
| `latitude` | Latitude from structured metadata |
| `longitude` | Longitude from structured metadata |
| `detailUrl` | GoYellow profile URL |
| `sourceUrl` | Search page where the listing was found |
| `searchKeyword` | Keyword used for the result |
| `searchLocation` | Location used for the result |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape GoYellow.de businesses?

The actor uses pay-per-event pricing.

You pay a small run-start event plus a per-result event for each business saved.

The default input is intentionally small so your first run stays cheap.

For low-cost testing, use `maxItems` between 10 and 25.

For enriched lead lists, keep `includeDetailPages` enabled.

For faster listing-only exports, disable detail-page enrichment.

### How to scrape GoYellow.de

1. Open the actor on Apify.
2. Enter a business type in **Business type / keyword**.
3. Enter a German city or location.
4. Choose a maximum number of businesses.
5. Keep detail pages enabled if you need phone and website fields.
6. Start the run.
7. Download the dataset as CSV, Excel, JSON, or access it through the API.

### Input options

#### Business type / keyword

The main GoYellow search term.

Examples:

- Restaurant
- Zahnarzt
- Friseur
- Steuerberater
- Rechtsanwalt

#### City or location

The German place to search.

Examples:

- Berlin
- Hamburg
- München
- Köln
- Frankfurt am Main

#### Additional searches

Use `queries` to run several keyword/location pairs in one execution.

Example:

```json
[
  { "keyword": "Restaurant", "location": "Berlin" },
  { "keyword": "Zahnarzt", "location": "Hamburg" }
]
````

#### Direct GoYellow search URLs

Use `searchUrls` when you already have exact GoYellow search pages.

Example:

```json
[
  { "url": "https://www.goyellow.de/suche/restaurant/berlin" }
]
```

#### Maximum businesses

`maxItems` controls the total number of dataset rows saved across all searches.

#### Open detail pages

`includeDetailPages` controls enrichment.

When enabled, the actor visits profile pages to look for phone numbers, websites, improved rating metadata, and coordinates.

### Example input

```json
{
  "keyword": "Restaurant",
  "location": "Berlin",
  "maxItems": 25,
  "includeDetailPages": true
}
```

### Example output

```json
{
  "name": "ALEX Berlin Uber Platz",
  "categories": ["Cafes und Kneipen", "Restaurants und Gaststätten"],
  "address": "Hedwig-Wachenheim-Straße 14, 10243 Berlin",
  "streetAddress": "Hedwig-Wachenheim-Straße 14",
  "postalCode": "10243",
  "city": "Berlin",
  "country": "DE",
  "phone": "030233210660",
  "website": "https://www.dein-alex.de/berlin-uber-platz",
  "rating": 5,
  "reviewCount": 1,
  "openingStatus": "öffnet in 1 Std.",
  "latitude": 52.50443966,
  "longitude": 13.44317416,
  "detailUrl": "https://www.goyellow.de/home/cafe-kneipe-alex-berlin-uber-platz-berlin--44gx7p.html",
  "sourceUrl": "https://www.goyellow.de/suche/restaurant/berlin",
  "searchKeyword": "Restaurant",
  "searchLocation": "Berlin",
  "scrapedAt": "2026-06-17T07:00:00.000Z"
}
```

### Tips for better results

- Use German business terms for better matching.
- Start with a single city before running many locations.
- Increase `maxItems` only after checking sample data.
- Disable detail pages if you only need names and addresses.
- Keep source URLs when reconciling exports with the website.

### Common use cases

- Local lead generation
- German market mapping
- Regional competitor discovery
- CRM enrichment
- Agency prospecting
- Store-location research
- Local SEO citation audits

### Integrations

You can connect the dataset to common tools.

- 🧾 Export CSV to Google Sheets or Excel
- 🧲 Send leads to a CRM through Make or Zapier
- 🧱 Load JSON into a warehouse or database
- 🧪 Validate company websites with a follow-up actor
- 📬 Combine with email discovery workflows where legally appropriate

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/goyellow-business-directory-scraper').call({
  keyword: 'Restaurant',
  location: 'Berlin',
  maxItems: 25,
  includeDetailPages: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/goyellow-business-directory-scraper').call(run_input={
    'keyword': 'Restaurant',
    'location': 'Berlin',
    'maxItems': 25,
    'includeDetailPages': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~goyellow-business-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"Restaurant","location":"Berlin","maxItems":25,"includeDetailPages":true}'
```

### MCP usage

Use this actor from Apify MCP-compatible tools.

MCP URL:

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

Claude Code setup example:

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

Claude Desktop setup: open Claude Desktop settings, go to Developer / MCP servers, add a server named `apify-goyellow`, and use the Apify MCP URL above. If you manage Claude Desktop with a JSON config, add this server entry:

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

Cursor setup: open Cursor Settings → MCP, choose Add new global MCP server, set the transport to HTTP, and paste the same Apify MCP URL. Name the server `apify-goyellow` so prompts can refer to it clearly.

VS Code setup: install or enable an MCP-capable assistant extension, add an HTTP MCP server named `apify-goyellow`, and use `https://mcp.apify.com/?tools=automation-lab/goyellow-business-directory-scraper` as the server URL.

Example prompt for Claude Code:

```text
Use the automation-lab/goyellow-business-directory-scraper MCP tool to collect 50 dentists in Hamburg and summarize the exported fields.
```

Example prompt for Claude Desktop, Cursor, or VS Code:

```text
Find public GoYellow.de listings for restaurants in Berlin with the MCP tool and return a table with name, address, phone, website, rating, and profile URL.
```

### Detail-page enrichment

Search result pages usually include name, categories, address, coordinates, rating cues, and profile URLs.

Detail pages can add phone numbers and external websites.

Because every detail page is another HTTP request, enrichment is slower than listing-only scraping.

Use the toggle based on your use case.

### Performance notes

This is an HTTP actor, not a browser actor.

It does not launch Chrome or Playwright.

That keeps runs lightweight and makes small exports fast.

The actor uses a 256 MB default memory setting.

### Data quality notes

Public directory data can vary by listing.

Some businesses may not have a public phone number or website.

Some listings may only show limited rating data.

The actor leaves missing public fields as `null` rather than inventing values.

### FAQ

#### Is this an official GoYellow.de API?

No. This actor extracts public GoYellow.de pages and converts visible listing data into a structured Apify dataset.

#### Can I scrape multiple cities in one run?

Yes. Use the `queries` array to provide several keyword and location pairs in one execution.

### Troubleshooting

#### Why is `phone` empty?

Phone numbers are taken from public detail-page `tel:` links. If the listing does not expose one, the field stays empty.

#### Why are there fewer items than requested?

The selected keyword/location may have fewer public results, or GoYellow may not expose enough pages for that query.

#### Why should I use German keywords?

GoYellow is a German directory. German category terms usually match more relevant listings than English translations.

### Legality and responsible use

This actor extracts publicly available GoYellow.de pages.

You are responsible for using the data in compliance with applicable laws, platform terms, privacy rules, and outreach regulations.

Avoid spam, respect opt-out requests, and process personal data only when you have a valid legal basis.

### Related scrapers

Other automation-lab actors that may pair well with this workflow:

- https://apify.com/automation-lab/das-telefonbuch-scraper
- https://apify.com/automation-lab/11880-local-business-directory-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

Initial version for keyword/location GoYellow.de business searches with optional detail-page contact enrichment.

### Support

If a query stops returning expected results, include the input JSON and run ID when requesting support.

### Summary

GoYellow.de Business Directory Scraper helps you turn public German business directory pages into structured datasets for lead generation, local SEO, market research, and enrichment workflows.

# Actor input Schema

## `keyword` (type: `string`):

What to search for on GoYellow.de, for example Restaurant, Zahnarzt, Friseur, Steuerberater, or Hotel.

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

German city, district, or place name to search in.

## `queries` (type: `array`):

Optional extra keyword/location pairs to run in the same actor execution.

## `searchUrls` (type: `array`):

Optional GoYellow.de /suche/... URLs to scrape directly. Use this when you already have exact search URLs.

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

Maximum number of business listings to save across all searches.

## `includeDetailPages` (type: `boolean`):

Fetch each business detail page to enrich results with phone and website when available. Disable for faster low-cost listing-only runs.

## Actor input object example

```json
{
  "keyword": "Restaurant",
  "location": "Berlin",
  "queries": [
    {
      "keyword": "Zahnarzt",
      "location": "Hamburg"
    }
  ],
  "searchUrls": [
    {
      "url": "https://www.goyellow.de/suche/restaurant/berlin"
    }
  ],
  "maxItems": 20,
  "includeDetailPages": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "Restaurant",
    "location": "Berlin",
    "queries": [
        {
            "keyword": "Zahnarzt",
            "location": "Hamburg"
        }
    ],
    "searchUrls": [
        {
            "url": "https://www.goyellow.de/suche/restaurant/berlin"
        }
    ],
    "maxItems": 20,
    "includeDetailPages": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/goyellow-business-directory-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keyword": "Restaurant",
    "location": "Berlin",
    "queries": [{
            "keyword": "Zahnarzt",
            "location": "Hamburg",
        }],
    "searchUrls": [{ "url": "https://www.goyellow.de/suche/restaurant/berlin" }],
    "maxItems": 20,
    "includeDetailPages": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/goyellow-business-directory-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "Restaurant",
  "location": "Berlin",
  "queries": [
    {
      "keyword": "Zahnarzt",
      "location": "Hamburg"
    }
  ],
  "searchUrls": [
    {
      "url": "https://www.goyellow.de/suche/restaurant/berlin"
    }
  ],
  "maxItems": 20,
  "includeDetailPages": true
}' |
apify call automation-lab/goyellow-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoYellow.de Business Directory Scraper",
        "description": "Scrape public German business listings from GoYellow.de by keyword and city, including addresses, phones, websites, ratings, and profile URLs.",
        "version": "0.1",
        "x-build-id": "OQGNubaz84SkbWOeD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~goyellow-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-goyellow-business-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~goyellow-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-goyellow-business-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~goyellow-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-goyellow-business-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keyword": {
                        "title": "Business type / keyword",
                        "type": "string",
                        "description": "What to search for on GoYellow.de, for example Restaurant, Zahnarzt, Friseur, Steuerberater, or Hotel."
                    },
                    "location": {
                        "title": "City or location",
                        "type": "string",
                        "description": "German city, district, or place name to search in."
                    },
                    "queries": {
                        "title": "Additional searches",
                        "type": "array",
                        "description": "Optional extra keyword/location pairs to run in the same actor execution.",
                        "items": {
                            "type": "object",
                            "required": [
                                "keyword",
                                "location"
                            ],
                            "properties": {
                                "keyword": {
                                    "type": "string",
                                    "title": "Keyword",
                                    "description": "GoYellow business type or search term."
                                },
                                "location": {
                                    "type": "string",
                                    "title": "Location",
                                    "description": "German city or place name."
                                }
                            }
                        }
                    },
                    "searchUrls": {
                        "title": "Direct GoYellow search URLs",
                        "type": "array",
                        "description": "Optional GoYellow.de /suche/... URLs to scrape directly. Use this when you already have exact search URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum businesses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of business listings to save across all searches.",
                        "default": 20
                    },
                    "includeDetailPages": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Fetch each business detail page to enrich results with phone and website when available. Disable for faster low-cost listing-only runs.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
