# Globus Baumarkt Scraper — German Hardware & DIY Products (`studio-amba/globus-baumarkt-scraper`) Actor

Scrape products from Globus-Baumarkt.de — tool specs, building material prices, and garden equipment data from this German hardware and DIY chain.

- **URL**: https://apify.com/studio-amba/globus-baumarkt-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

## Globus Baumarkt Scraper

Scrape product data, prices, specifications, and customer reviews from globus-baumarkt.de -- Germany's large-format DIY chain with a deep catalog of tools, garden supplies, building materials, and home improvement products.

### What is Globus Baumarkt Scraper?

Globus Baumarkt operates spacious DIY stores primarily across central and southern Germany. Unlike national chains that compete on breadth, Globus stores are known for their warehouse-style layout and aggressive pricing on building materials and garden equipment. Their online catalog provides detailed product specs and structured data that this scraper taps into directly.

Here is how teams typically use this scraper:

- **Regional price intelligence** -- Globus Baumarkt frequently undercuts national chains like OBI and Hornbach on specific product lines. Track these pricing differences systematically rather than checking manually
- **Cross-border price comparison** -- Benchmark German hardware store pricing against French (Brico Depot, Castorama), Nordic (Byggmax, K-Rauta), and Benelux (Gamma, Praxis) equivalents. The same Bosch drill can vary 30% across borders
- **Product specification harvesting** -- Extract structured spec tables (voltage, weight, dimensions) to build comparison databases for power tools, garden equipment, and building materials
- **Brand distribution mapping** -- Discover which tool, paint, and garden brands are stocked at Globus versus competitors. Valuable for manufacturers planning retail distribution in Germany
- **Promotional cycle analysis** -- Track seasonal discounting on categories like garden furniture (spring), heating (autumn), and Christmas decorations to predict future pricing windows

### What data does Globus Baumarkt Scraper extract?

Each product result includes these fields when available on the page:

- 🏷️ **Product name** -- Full listing title from the product page
- 🏢 **Brand** -- Manufacturer name (extracted from JSON-LD structured data or HTML)
- 💰 **Price** -- Current retail price in EUR
- 🔖 **Original price** -- Crossed-out price for items currently on discount
- 🔢 **SKU** -- Article reference number
- 🔗 **EAN** -- European Article Number (barcode) from JSON-LD
- ⭐ **Rating** -- Aggregate customer rating score
- 💬 **Review count** -- Total number of customer reviews
- 🖼️ **Image URL** -- Primary product image
- 📝 **Description** -- Product description text
- 📂 **Categories** -- Full breadcrumb path (e.g., "Werkzeug > Elektrowerkzeuge > Bohrmaschinen")
- 🔧 **Specs** -- Technical specifications from product property tables (dimensions, weight, power, materials)

### How to scrape Globus Baumarkt

#### Search by keyword

```json
{
    "searchQuery": "rasenmäher",
    "maxResults": 100
}
````

Popular German search terms: `"bohrmaschine"` (drill), `"gartenmöbel"` (garden furniture), `"farbe"` (paint), `"schrauben"` (screws), `"werkzeugkoffer"` (toolbox), `"holz"` (timber), `"dämmstoffe"` (insulation).

#### Scrape a specific category page

```json
{
    "categoryUrl": "https://www.globus-baumarkt.de/garten/gartenmoebel/",
    "maxResults": 500
}
```

#### Input reference

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | String | German keyword (default: `"bohrmaschine"`) |
| `categoryUrl` | String | A globus-baumarkt.de category page URL |
| `maxResults` | Integer | Product limit (default: 100, max: 50,000) |
| `proxyConfiguration` | Object | Proxy settings -- datacenter proxies usually work fine |

**Tip:** The scraper automatically detects product detail pages by the `/p/` URL pattern and extracts structured JSON-LD data combined with HTML spec tables for maximum data coverage.

### Output

```json
[
    {
        "name": "Einhell Akku-Rasenmäher GE-CM 36/37 Li",
        "brand": "Einhell",
        "price": 219.00,
        "currency": "EUR",
        "originalPrice": 259.00,
        "sku": "3413155",
        "ean": "4006825655926",
        "rating": 4.4,
        "reviewCount": 156,
        "imageUrl": "https://www.globus-baumarkt.de/media/catalog/einhell-ge-cm-36-37.jpg",
        "description": "Kraftvoller Akku-Rasenmäher für Flächen bis 400 m2, 37 cm Schnittbreite, 6-fache zentrale Schnitthöhenverstellung",
        "category": "Garten > Rasenpflege > Rasenmäher",
        "categories": ["Garten", "Rasenpflege", "Rasenmäher"],
        "specs": {
            "Schnittbreite": "37 cm",
            "Schnitthöhe": "25-75 mm",
            "Fangkorb": "45 l",
            "Akkuspannung": "36 V (2x 18V)"
        },
        "url": "https://www.globus-baumarkt.de/p/einhell-akku-rasenmaeher-ge-cm-36-37-li/",
        "scrapedAt": "2026-04-03T09:15:00.000Z"
    },
    {
        "name": "fischer Dübel SX 8x40 Dose mit 80 Stück",
        "brand": "fischer",
        "price": 8.99,
        "currency": "EUR",
        "rating": 4.9,
        "reviewCount": 328,
        "imageUrl": "https://www.globus-baumarkt.de/media/catalog/fischer-sx-8x40.jpg",
        "description": "Universaldübel für vielfältige Befestigungen in Beton, Vollziegel und Naturstein",
        "category": "Befestigung > Dübel",
        "categories": ["Befestigung", "Dübel"],
        "specs": {
            "Durchmesser": "8 mm",
            "Länge": "40 mm",
            "Material": "Nylon",
            "Inhalt": "80 Stück"
        },
        "url": "https://www.globus-baumarkt.de/p/fischer-duebel-sx-8x40-dose-80-stueck/",
        "scrapedAt": "2026-04-03T09:15:18.000Z"
    },
    {
        "name": "Alpina Wandfarbe Weiss matt 10 L",
        "brand": "Alpina",
        "price": 39.99,
        "currency": "EUR",
        "ean": "4001244745012",
        "rating": 4.6,
        "reviewCount": 89,
        "imageUrl": "https://www.globus-baumarkt.de/media/catalog/alpina-wandfarbe-10l.jpg",
        "description": "Hochdeckende Innenfarbe für Wand und Decke, tropfgehemmt, schnelltrocknend",
        "category": "Farben & Lacke > Wandfarben",
        "categories": ["Farben & Lacke", "Wandfarben"],
        "specs": {
            "Inhalt": "10 L",
            "Ergiebigkeit": "ca. 60 m2",
            "Glanzgrad": "matt",
            "Trockenzeit": "4 Stunden"
        },
        "url": "https://www.globus-baumarkt.de/p/alpina-wandfarbe-weiss-matt-10l/",
        "scrapedAt": "2026-04-03T09:15:30.000Z"
    }
]
```

Export to **JSON**, **CSV**, **Excel**, **XML**, or **RSS** directly from the Apify dataset.

### How much does it cost?

The scraper uses CheerioCrawler (fast HTTP requests) with JSON-LD extraction, keeping costs very low.

| Scenario | Products | Estimated cost |
|----------|----------|----------------|
| Quick keyword search | 50 | ~$0.03 |
| Category deep dive | 200 | ~$0.10 |
| Multi-category export | 1,000 | ~$0.50 |
| Large catalog crawl | 5,000 | ~$2.50 |

The Apify free tier easily handles regular monitoring runs. No browser is launched, so compute usage is minimal.

### Can I integrate?

Connect Globus Baumarkt product data to your existing stack:

- **Webhooks** -- Trigger downstream processes when scraping completes
- **Google Sheets** -- Auto-populate spreadsheets with product data for team access
- **Slack / Microsoft Teams** -- Alert on price drops, new products, or stock changes
- **Zapier / Make (Integromat)** -- Route data to 5,000+ apps without writing code
- **Amazon S3 / Google Cloud Storage** -- Dump results to cloud buckets for data pipelines
- **SQL databases** -- Push directly to PostgreSQL, MySQL, or BigQuery
- **REST API** -- Full programmatic access (see below)

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/globus-baumarkt-scraper").call(run_input={
    "searchQuery": "gartenmöbel",
    "maxResults": 200,
})

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

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/globus-baumarkt-scraper").call({
    searchQuery: "gartenmöbel",
    maxResults: 200,
});

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

### FAQ

**What makes Globus Baumarkt interesting for price comparison?**
Globus Baumarkt operates fewer but larger stores than chains like OBI or Toom. Their buying power and warehouse-style approach often leads to different pricing, especially on building materials and bulk items. This makes their data valuable as a regional benchmark.

**Does the scraper extract product specifications?**
Yes. Technical specs are pulled from product property tables on detail pages. This includes dimensions, materials, power ratings, weight, and other product-specific attributes stored in a structured `specs` object.

**Can I use filtered or sorted URLs?**
Absolutely. Apply any filters on globus-baumarkt.de (brand, price range, rating, sort order), copy the resulting URL, and paste it as `categoryUrl`. The scraper will respect the filters encoded in the URL.

**How fast is it?**
At a max concurrency of 3, expect roughly 100 products per minute including full detail page visits for specs and descriptions.

**Can I compare Globus prices with other European countries?**
Yes, that is one of the most popular use cases. Pair this scraper with our French (Bricorama, Brico Depot, Leroy Merlin), Nordic (Byggmax, Jula, K-Rauta), and Benelux (Gamma, Praxis, Brico) scrapers for pan-European price intelligence.

**Is the data in German?**
All product names, descriptions, spec labels, and categories are in German exactly as they appear on globus-baumarkt.de.

### Limitations

- Data is exclusively in German from globus-baumarkt.de
- Spec extraction depends on the product page having a structured property table -- some products have fewer technical details than others
- Each product detail page is visited individually for full data; large runs (5,000+) take proportionally longer
- Store-specific pricing or local availability is not captured -- only the online catalog data
- Max concurrency is 3 to maintain reliability and avoid rate limiting

### Other DIY & hardware scrapers

Compare prices across the entire European hardware market with our scraper collection:

- [Gamma Scraper](https://apify.com/studio-amba/gamma-scraper) -- Netherlands
- [Leroy Merlin Scraper](https://apify.com/studio-amba/leroymerlin-scraper) -- France
- [Brico Scraper](https://apify.com/studio-amba/brico-scraper) -- Belgium
- [Praxis Scraper](https://apify.com/studio-amba/praxis-scraper) -- Netherlands
- [OBI Scraper](https://apify.com/studio-amba/obi-scraper) -- Germany
- [Hornbach Scraper](https://apify.com/studio-amba/hornbach-scraper) -- Germany/Europe
- [Bauhaus Scraper](https://apify.com/studio-amba/bauhaus-scraper) -- Germany/Europe
- [Castorama Scraper](https://apify.com/studio-amba/castorama-scraper) -- France/Poland
- [Hubo Scraper](https://apify.com/studio-amba/hubo-scraper) -- Belgium/Netherlands
- [Toom Scraper](https://apify.com/studio-amba/toom-scraper) -- Germany
- [Hagebau Scraper](https://apify.com/studio-amba/hagebau-scraper) -- Germany
- [Bricorama Scraper](https://apify.com/studio-amba/bricorama-scraper) -- France
- [Brico Depot Scraper](https://apify.com/studio-amba/bricodepot-scraper) -- France
- [Byggmax Scraper](https://apify.com/studio-amba/byggmax-scraper) -- Sweden
- [Bricomarche Scraper](https://apify.com/studio-amba/bricomarche-scraper) -- France
- [Clas Ohlson Scraper](https://apify.com/studio-amba/clasohlson-scraper) -- Scandinavia
- [Jula Scraper](https://apify.com/studio-amba/jula-scraper) -- Sweden
- [K-Rauta Scraper](https://apify.com/studio-amba/krauta-scraper) -- Finland

### Your feedback

Found a bug, missing field, or want a new feature? Let us know on the actor's Apify Store page or through the community forum. We maintain this scraper actively and ship fixes fast.

# Actor input Schema

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

Search for products by keyword (e.g., 'bohrmaschine', 'gartenmöbel').

## `categoryUrl` (type: `string`):

A globus-baumarkt.de category page URL to scrape.

## `maxResults` (type: `integer`):

Maximum number of products to return.

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

Proxy settings.

## Actor input object example

```json
{
  "searchQuery": "bohrmaschine",
  "maxResults": 100
}
```

# 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": "bohrmaschine"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/globus-baumarkt-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": "bohrmaschine" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/globus-baumarkt-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": "bohrmaschine"
}' |
apify call studio-amba/globus-baumarkt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Globus Baumarkt Scraper — German Hardware & DIY Products",
        "description": "Scrape products from Globus-Baumarkt.de — tool specs, building material prices, and garden equipment data from this German hardware and DIY chain.",
        "version": "0.1",
        "x-build-id": "dt18BxXEUzNrQfuBO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~globus-baumarkt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-globus-baumarkt-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/studio-amba~globus-baumarkt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-globus-baumarkt-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/studio-amba~globus-baumarkt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-globus-baumarkt-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'bohrmaschine', 'gartenmöbel')."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A globus-baumarkt.de category page URL to scrape."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
