# MyHammer Contractor Scraper for German Leads (`truenorth/myhammer-search`) Actor

Extract MyHammer contractor directory results by German postal code and fixed job-title dropdown for local market research.

- **URL**: https://apify.com/truenorth/myhammer-search.md
- **Developed by:** [TrueNorth](https://apify.com/truenorth) (community)
- **Categories:** Lead generation, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 93.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.50 / 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.

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

## MyHammer Contractor Scraper for German Leads

Find MyHammer contractors by German postal code and profession without manually browsing search pages.

The MyHammer Contractor Search Scraper extracts structured contractor directory results from MyHammer for a selected German ZIP code and a fixed job-title dropdown value such as `Maler und Lackierer`, `Elektriker`, `Dachdecker`, or `Sanitärinstallateur`. It is built for agencies, local-market analysts, construction suppliers, SaaS teams, and B2B researchers who need clean contractor profile data for German regional market research.

Use it to collect MyHammer search result records into Apify datasets and export them as JSON, CSV, Excel, or via API for downstream workflows.

### Key Features

- Search MyHammer contractor results by German 5-digit postal code.
- Select a profession from the fixed MyHammer job-title dropdown values exposed in the Actor input schema.
- Extract contractor search result data from MyHammer Next.js page data.
- Capture company/display name, MyHammer profile URL, contractor ID, city/location text, ratings, review count, services, badges, snippets, descriptions, images when available, and raw source metadata.
- Handles result pagination with configurable `maxPages` and `maxItems` limits.
- Deduplicates contractors across pages before saving dataset records.
- Uses PlaywrightCrawler for browser-based extraction and supports Apify proxy configuration.
- Fails clearly if MyHammer serves a Cloudflare challenge or a page without contractor directory data, instead of fabricating output.
- Produces CSV/JSON-ready records for analysis, enrichment, CRM import preparation, or automation workflows.

### How it Works

1. Enter a German postal code and choose a supported MyHammer job title from the dropdown.
2. Set optional limits such as maximum contractors, maximum pages, request delay, and proxy configuration.
3. Run the Actor on Apify and download the resulting dataset as JSON, CSV, Excel, or consume it through the Apify API.

### Input Example

```json
{
  "postalCode": "10115",
  "jobTitle": "Maler und Lackierer",
  "maxItems": 100,
  "maxPages": 10,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Input Parameters

- `postalCode` — German 5-digit postal code, for example `10115`.
- `jobTitle` — fixed dropdown/select value from the Actor input schema, for example `Maler und Lackierer`, `Elektriker`, `Dachdecker`, or `Sanitärinstallateur`. Free-form job titles are not supported.
- `maxItems` — maximum unique contractors to save. Default: `100`. Allowed range: `1` to `1000`.
- `maxPages` — maximum search result pages to crawl. Default: `10`. Allowed range: `1` to `100`.
- `requestDelayMs` — polite delay before each page navigation. Default: `1000`. Allowed range: `0` to `30000`.
- `proxyConfiguration` — Apify proxy settings. Residential proxies are recommended because MyHammer uses Cloudflare.

### Output Sample (JSON format)

```json
{
  "searchPostalCode": "10115",
  "searchJobTitle": "Maler und Lackierer",
  "searchUrl": "https://www.my-hammer.de/malerarbeiten-tapezieren/maler-lackierer-berufe/berlin",
  "pageNumber": 1,
  "positionOnPage": 1,
  "scrapedAt": "2026-06-04T14:22:34.613Z",
  "companyName": "GT. Maler & Trockenbau",
  "displayName": "GT. Maler & Trockenbau",
  "profileUrl": "https://www.my-hammer.de/auftragnehmer/gt-maler-trockenbau",
  "contractorId": "15184557",
  "locationText": "Zeuthen",
  "city": "Zeuthen",
  "postalCode": null,
  "distanceKm": null,
  "ratingValue": 4.7,
  "reviewCount": 9,
  "trades": [],
  "services": [
    "Innenausbau und Sanierung"
  ],
  "badges": [
    "VALID_ID",
    "VERIFIED_LICENSE"
  ],
  "snippet": "Alles gut!",
  "shortDescription": "GT. Maler-Trockenbau\n20 Jahre Erfahrung in der Branche\nLegen Sie Farbe in Ihr Leben und machen Sie Ihr Zuhause.",
  "imageUrl": "https://www.my-hammer.de/images/sp/thumbnail_small/b4e93cd0-d01e-4e4e-b97d-f41c4b6ab8ff.jpg",
  "logoUrl": "https://www.my-hammer.de/images/sp/thumbnail_small/b4e93cd0-d01e-4e4e-b97d-f41c4b6ab8ff.jpg",
  "responseTime": null,
  "availability": null,
  "rawMetadata": {
    "id": 15184557,
    "slug": "gt-maler-trockenbau",
    "name": "GT. Maler & Trockenbau",
    "score": 9.3,
    "ratings": 9,
    "isNew": false,
    "review": {
      "text": "Alles gut!",
      "createdAt": "2026-03-19T17:52:12+00:00",
      "serviceName": "Innenausbau und Sanierung",
      "picture": null
    },
    "badges": [],
    "verifications": [
      "VALID_ID",
      "VERIFIED_LICENSE"
    ],
    "isFeatured": true,
    "avatar": "https://www.my-hammer.de/images/sp/thumbnail_small/b4e93cd0-d01e-4e4e-b97d-f41c4b6ab8ff.jpg",
    "bio": "GT. Maler-Trockenbau\n20 Jahre Erfahrung in der Branche\nLegen Sie Farbe in Ihr Leben und machen Sie Ihr Zuhause.",
    "contentCluster": {
      "__typename": "ContentCluster",
      "slug": "bauen-renovieren"
    },
    "sponsoredPlacementId": 115819,
    "primaryLocation": "Zeuthen"
  }
}
```

### AI & LLM Integration (RAG-Ready)

The Actor returns structured contractor records that can be used in AI and automation workflows:

- Feed `companyName`, `city`, `services`, `badges`, `snippet`, `shortDescription`, `ratingValue`, and `reviewCount` into lead scoring or market segmentation models.
- Store contractor profiles in a vector database for retrieval-augmented generation (RAG), for example to answer questions about local service-provider density by profession and region.
- Use the dataset as a source for Model Context Protocol (MCP) tools or internal analytics assistants.
- Summarize contractor descriptions and recent review snippets for regional market research.
- Compare repeated runs over the same postal code and job title to monitor changes in MyHammer search results.

Do not use the output to imply verified credentials beyond the badge or verification strings returned by MyHammer in the public page data.

### Target Users

- B2B sales and marketing teams researching German home-service and contractor markets.
- Construction suppliers and SaaS vendors looking for regional contractor segments.
- Local SEO and agency teams analyzing service-provider visibility by profession and ZIP code.
- Market researchers comparing contractor density, reviews, and profile quality across German locations.
- Data teams building enrichment, scoring, or monitoring pipelines around public contractor directory data.

### Use Cases

- Build a CSV list of MyHammer contractor profiles for a selected German postal code and trade.
- Compare which contractors appear for the same trade in different German cities or postal codes.
- Monitor rating and review-count changes in local contractor categories.
- Prepare public directory profile data for manual outreach research or CRM enrichment workflows.
- Analyze competitive coverage for professions such as painters, electricians, roofers, plumbers, and landscapers.

### Limitations & Compliance-Friendly Notes

- The Actor extracts public MyHammer directory result data available in the loaded page data.
- It does not claim to extract private contact details, private customer data, hidden emails, or phone numbers.
- Free-form job title search is not supported; use the fixed dropdown values provided in the input schema.
- MyHammer uses Cloudflare. Residential proxies are recommended, and some runs may fail if the site serves a challenge page.
- Badge and verification strings are passed through from MyHammer data. The Actor does not independently verify contractor licenses, identity, or qualifications.
- Results can vary by time, location, MyHammer ranking, pagination, and platform changes.
- Users are responsible for complying with applicable laws, platform terms, and privacy obligations when using extracted data.

### Troubleshooting

- **No contractor records found:** Verify that `postalCode` is a valid German 5-digit ZIP code and that `jobTitle` is one of the fixed dropdown values in the input schema.
- **Cloudflare or challenge-page error:** Run with Apify Proxy, preferably a residential proxy group, and retry with conservative limits.
- **Unexpectedly low result count:** MyHammer rankings, availability, pagination, and location matching can change over time. Increase `maxPages` or compare another postal code/job-title pair.
- **Free-form job title rejected:** The Actor intentionally accepts only supported MyHammer profession dropdown values to keep URLs deterministic.

### Review Checklist Before Store Publish

- README, input schema, dataset schema, output schema, and deployment notes are synchronized.
- Example input uses a German 5-digit postal code and a fixed job-title dropdown value.
- Example output fields match the real dataset records emitted by the Actor.
- Local `pnpm test`, `pnpm build`, and `apify run` have passed.
- Apify Store PPE is configured as `per-contractor-extracted` at `$0.004` per contractor record.
- Pass platform usage costs to users is enabled.
- Final `apify push` and Store publish are performed only after Peter's explicit approval.

# Actor input Schema

## `postalCode` (type: `string`):

German 5-digit postal code used to resolve the MyHammer search location, for example 10115.

## `jobTitle` (type: `string`):

Fixed MyHammer profession dropdown value. Free-form job titles are not supported.

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

Maximum number of unique contractor records to save to the dataset.

## `maxPages` (type: `integer`):

Maximum number of MyHammer result pages to crawl.

## `requestDelayMs` (type: `integer`):

Delay before each page navigation. Use 0 only when rate limiting is handled elsewhere.

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

Apify proxy configuration. Residential proxies are recommended because MyHammer uses Cloudflare.

## Actor input object example

```json
{
  "postalCode": "10115",
  "jobTitle": "Maler und Lackierer",
  "maxItems": 100,
  "maxPages": 10,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Extracted MyHammer contractor records.

## `runSummary` (type: `string`):

Summary record with search URL and item count.

# 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 = {
    "postalCode": "10115",
    "jobTitle": "Maler und Lackierer",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("truenorth/myhammer-search").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 = {
    "postalCode": "10115",
    "jobTitle": "Maler und Lackierer",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("truenorth/myhammer-search").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 '{
  "postalCode": "10115",
  "jobTitle": "Maler und Lackierer",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call truenorth/myhammer-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyHammer Contractor Scraper for German Leads",
        "description": "Extract MyHammer contractor directory results by German postal code and fixed job-title dropdown for local market research.",
        "version": "1.0",
        "x-build-id": "XQVfS5zzHiGgqOyEq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truenorth~myhammer-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truenorth-myhammer-search",
                "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/truenorth~myhammer-search/runs": {
            "post": {
                "operationId": "runs-sync-truenorth-myhammer-search",
                "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/truenorth~myhammer-search/run-sync": {
            "post": {
                "operationId": "run-sync-truenorth-myhammer-search",
                "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": [
                    "postalCode",
                    "jobTitle"
                ],
                "properties": {
                    "postalCode": {
                        "title": "German postal code",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "German 5-digit postal code used to resolve the MyHammer search location, for example 10115."
                    },
                    "jobTitle": {
                        "title": "MyHammer job title",
                        "enum": [
                            "Abrissunternehmen",
                            "Architekt",
                            "Autolackierer",
                            "Baumpfleger",
                            "Bauplaner und -berater",
                            "Bauunternehmen",
                            "Betonbohrer und -schneider",
                            "Boden- und Estrichleger",
                            "Brunnenbauer",
                            "Dachdecker",
                            "Elektriker",
                            "Energieberater",
                            "Entrümpelungsunternehmen",
                            "Entsorgungsunternehmen",
                            "Erdbau- und Baggerunternehmen",
                            "Fahrradwerkstatt",
                            "Fassadenbauer",
                            "Fensterputzer",
                            "Firma für Rohreinigung",
                            "Fliesenleger",
                            "Garten- und Landschaftsbauer",
                            "Gärtner",
                            "Gebäudereiniger",
                            "Gerüstbauer",
                            "Glaser",
                            "Hausmeisterservice",
                            "Heizungsinstallateur",
                            "Holz- und Bautenschützer",
                            "Innenarchitekt",
                            "Kaminbauer",
                            "KFZ Werkstatt",
                            "Klempner",
                            "Klimatechniker",
                            "Küchenbauer",
                            "Maler und Lackierer",
                            "Maurer und Betonbauer",
                            "Metallbauer",
                            "Montageservice & Allroundhandwerker",
                            "Motorradwerkstatt",
                            "Parkettleger",
                            "Pflaster- und Straßenbauer",
                            "Polsterei",
                            "Poolbauer",
                            "Raumausstatter",
                            "Reinigungskraft",
                            "Rolladenbauer",
                            "Sanitärinstallateur",
                            "Sattlerei",
                            "Schornsteinfeger",
                            "Solarteur",
                            "Steinmetz",
                            "Techniker für Haushaltsgeräte",
                            "Tischler und Schreiner",
                            "Transportunternehmen",
                            "Treppenbauer",
                            "Trockenbauer",
                            "Türen & Fensterbauer",
                            "Umzugsunternehmen",
                            "Verputzer",
                            "Zaunbauer",
                            "Zimmerer",
                            "Fenster-, Türen- & Markisenbauer"
                        ],
                        "type": "string",
                        "description": "Fixed MyHammer profession dropdown value. Free-form job titles are not supported.",
                        "default": "Maler und Lackierer"
                    },
                    "maxItems": {
                        "title": "Maximum contractors",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique contractor records to save to the dataset.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of MyHammer result pages to crawl.",
                        "default": 10
                    },
                    "requestDelayMs": {
                        "title": "Request delay in milliseconds",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Delay before each page navigation. Use 0 only when rate limiting is handled elsewhere.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Residential proxies are recommended because MyHammer uses Cloudflare."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
