# OBI Germany Product Scraper (`dromb/obi-germany`) Actor

Extract OBI Germany products, prices, availability, stores, and structured product details for monitoring, analysis, and data workflows.

- **URL**: https://apify.com/dromb/obi-germany.md
- **Developed by:** [Dmitriy Gyrbu](https://apify.com/dromb) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 dataset items

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OBI Germany Product Scraper

Extract OBI Germany products, prices, online availability, postcode availability, and store information as structured data. Use it for price monitoring, product research, local availability checks, catalogue enrichment, and retail market analysis.

This is an unofficial scraper and is not affiliated with, endorsed by, or operated by OBI.

### What you can extract

- Product identity, name, brand, canonical URL, images, seller, and marketplace status.
- Online, regular, comparison, and HEY OBI loyalty price fields kept separate when publicly available.
- Delivery and pickup availability for requested German postcodes.
- Store details by public store number.
- Store discovery by postcode, city, state, service, or coordinates.

### Supported modes

#### `search`

Search products by `query`. Optional controls include `maxResults`, `maxPages`, sponsored-result filtering, product detail enrichment, and postcode availability enrichment.

```json
{
  "mode": "search",
  "query": "bohrmaschine",
  "maxResults": 20,
  "maxPages": 2,
  "includeSponsored": false
}
````

#### `item`

Get product details for one or more OBI article IDs or approved `https://www.obi.de/p/...` URLs.

```json
{
  "mode": "item",
  "products": [{"articleId": "5188784"}]
}
```

#### `availability`

Check pickup and delivery availability for explicit products and German postcodes.

```json
{
  "mode": "availability",
  "products": [{"articleId": "5188784"}],
  "postalCodes": ["10115"],
  "quantity": 1
}
```

#### `store`

Retrieve one store by its public OBI `storeNumber`.

```json
{"mode": "store", "storeNumber": "374"}
```

#### `stores`

Find stores by location or service filters.

```json
{"mode": "stores", "city": "Niesky", "maxStores": 20}
```

### Output

Rows are written to the default Dataset with an explicit `recordType` such as `product`, `availability`, `store`, or `error`. Product rows keep seller, price, availability, identity, image, and source metadata in separate fields. Run totals, warnings, and request counts are available in the `OUTPUT` and `REQUEST_LEDGER_SUMMARY` records in the default key-value store.

You can export results as JSON, CSV, Excel, XML, RSS, or access them through the Apify API and integrations.

### Proxy and access behavior

Direct HTTP is the default and is currently proven for all supported modes. Apify proxy settings and custom proxy URLs are supported for blocked or location-sensitive runs. Proxy credentials are redacted from logs and request summaries. Browser fallback is intentionally disabled.

### Limits and data notes

- Prices and availability can change between requests and may depend on location or seller.
- `storeNumber` is the public input identifier; internal store IDs are returned only as metadata.
- HEY OBI loyalty prices are kept separate from regular and online prices.
- Opening hours are returned only when present in the confirmed public store source.
- Invalid individual products can produce structured error rows instead of discarding successful results.

### Pricing

The current price is displayed by Apify before a run. Dataset-result billing, when enabled, applies only to rows written to the default Dataset; failed retries and key-value summaries are not separate Dataset results.

# Actor input Schema

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

Single logical mode per run.

## `query` (type: `string`):

Product keyword for search mode.

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

Maximum number of product rows to return.

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

Maximum number of search result pages to request.

## `pageStart` (type: `integer`):

First search page to request.

## `storeNumber` (type: `string`):

Public OBI store number, for example 374. Internal store identifiers are output metadata only.

## `includeSponsored` (type: `boolean`):

Keep sponsored rows (always tagged via isSponsored).

## `includeFilters` (type: `boolean`):

Include parsed search filter metadata when available.

## `includeItemDetails` (type: `boolean`):

Enrich search results with product detail page data. This performs an additional request per product.

## `includeAvailability` (type: `boolean`):

Enrich rows with availability (requires postalCodes).

## `postalCodes` (type: `array`):

German postcodes. At least one is required when availability enrichment is enabled; maximum 50.

## `quantity` (type: `integer`):

Requested product quantity for availability checks.

## `products` (type: `array`):

Products for item or availability mode. Each entry must contain exactly one OBI article ID or OBI Germany product URL; maximum 1,000.

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

Single DE postal code filter (stores mode).

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

DE city filter (stores mode).

## `state` (type: `string`):

DE state filter (stores mode).

## `latitude` (type: `string`):

Latitude for stores mode. Enter a decimal number as text, for example 48.1372.

## `longitude` (type: `string`):

Longitude for stores mode. Enter a decimal number as text, for example 11.5756.

## `radiusKm` (type: `string`):

Search radius in kilometres. Enter a decimal number as text.

## `services` (type: `array`):

Optional store service filters.

## `activeOnly` (type: `boolean`):

Return only active stores.

## `maxStores` (type: `integer`):

Maximum number of stores to return.

## `includeOpeningHours` (type: `boolean`):

Include ordinary opening hours.

## `includeSpecialOpeningHours` (type: `boolean`):

Include special opening hours.

## `concurrency` (type: `integer`):

Maximum number of concurrent requests.

## `retries` (type: `integer`):

Number of retries for temporary upstream failures.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each upstream request in seconds.

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

Enable additional non-secret diagnostic logging.

## `proxy` (type: `object`):

Advanced access settings. Direct HTTP is used by default; Apify or custom proxy routing can be enabled when needed.

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

Standard Apify proxy selector. When advanced proxy is also provided, advanced proxy takes precedence. Direct HTTP remains the default.

## Actor input object example

```json
{
  "mode": "search",
  "query": "bohrmaschine",
  "concurrency": 4,
  "retries": 2,
  "requestTimeoutSecs": 25,
  "debug": false,
  "proxy": {},
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Normalized product, availability and store rows.

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

Bounded run status and row counts.

## `requestLedger` (type: `string`):

Request totals and retry statistics for the run.

# 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 = {
    "query": "schraube"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dromb/obi-germany").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 = { "query": "schraube" }

# Run the Actor and wait for it to finish
run = client.actor("dromb/obi-germany").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 '{
  "query": "schraube"
}' |
apify call dromb/obi-germany --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OBI Germany Product Scraper",
        "description": "Extract OBI Germany products, prices, availability, stores, and structured product details for monitoring, analysis, and data workflows.",
        "version": "0.2",
        "x-build-id": "fjVotDXVX0Agai8cd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dromb~obi-germany/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dromb-obi-germany",
                "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/dromb~obi-germany/runs": {
            "post": {
                "operationId": "runs-sync-dromb-obi-germany",
                "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/dromb~obi-germany/run-sync": {
            "post": {
                "operationId": "run-sync-dromb-obi-germany",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "item",
                            "availability",
                            "store",
                            "stores"
                        ],
                        "type": "string",
                        "description": "Single logical mode per run.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Query",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Product keyword for search mode."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of product rows to return."
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search result pages to request."
                    },
                    "pageStart": {
                        "title": "Page Start",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "First search page to request."
                    },
                    "storeNumber": {
                        "title": "Store Number",
                        "pattern": "^[0-9]{1,6}$",
                        "type": "string",
                        "description": "Public OBI store number, for example 374. Internal store identifiers are output metadata only."
                    },
                    "includeSponsored": {
                        "title": "Include Sponsored",
                        "type": "boolean",
                        "description": "Keep sponsored rows (always tagged via isSponsored)."
                    },
                    "includeFilters": {
                        "title": "Include Filters",
                        "type": "boolean",
                        "description": "Include parsed search filter metadata when available."
                    },
                    "includeItemDetails": {
                        "title": "Include Item Details",
                        "type": "boolean",
                        "description": "Enrich search results with product detail page data. This performs an additional request per product."
                    },
                    "includeAvailability": {
                        "title": "Include Availability",
                        "type": "boolean",
                        "description": "Enrich rows with availability (requires postalCodes)."
                    },
                    "postalCodes": {
                        "title": "Postal Codes",
                        "maxItems": 50,
                        "type": "array",
                        "description": "German postcodes. At least one is required when availability enrichment is enabled; maximum 50.",
                        "items": {
                            "type": "string",
                            "pattern": "^[0-9]{5}$"
                        }
                    },
                    "quantity": {
                        "title": "Quantity",
                        "minimum": 1,
                        "maximum": 999,
                        "type": "integer",
                        "description": "Requested product quantity for availability checks."
                    },
                    "products": {
                        "title": "Products",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Products for item or availability mode. Each entry must contain exactly one OBI article ID or OBI Germany product URL; maximum 1,000.",
                        "items": {
                            "type": "object",
                            "additionalProperties": false,
                            "properties": {
                                "articleId": {
                                    "type": "string",
                                    "pattern": "^[0-9]{4,12}$",
                                    "description": "OBI article number. NOT a guaranteed EAN.",
                                    "title": "Article Id"
                                },
                                "productUrl": {
                                    "type": "string",
                                    "pattern": "^https://www\\.obi\\.de/p/[0-9]+/.+$",
                                    "description": "Approved OBI Germany PDP host+path only.",
                                    "title": "Product Url"
                                }
                            }
                        }
                    },
                    "postalCode": {
                        "title": "Postal Code",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "Single DE postal code filter (stores mode)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "DE city filter (stores mode)."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "DE state filter (stores mode)."
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Latitude for stores mode. Enter a decimal number as text, for example 48.1372."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Longitude for stores mode. Enter a decimal number as text, for example 11.5756."
                    },
                    "radiusKm": {
                        "title": "Radius Km",
                        "type": "string",
                        "description": "Search radius in kilometres. Enter a decimal number as text."
                    },
                    "services": {
                        "title": "Services",
                        "type": "array",
                        "description": "Optional store service filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeOnly": {
                        "title": "Active Only",
                        "type": "boolean",
                        "description": "Return only active stores."
                    },
                    "maxStores": {
                        "title": "Max Stores",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of stores to return."
                    },
                    "includeOpeningHours": {
                        "title": "Include Opening Hours",
                        "type": "boolean",
                        "description": "Include ordinary opening hours."
                    },
                    "includeSpecialOpeningHours": {
                        "title": "Include Special Opening Hours",
                        "type": "boolean",
                        "description": "Include special opening hours."
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent requests.",
                        "default": 4
                    },
                    "retries": {
                        "title": "Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of retries for temporary upstream failures.",
                        "default": 2
                    },
                    "requestTimeoutSecs": {
                        "title": "Request Timeout Secs",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for each upstream request in seconds.",
                        "default": 25
                    },
                    "debug": {
                        "title": "Debug",
                        "type": "boolean",
                        "description": "Enable additional non-secret diagnostic logging.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Advanced access settings. Direct HTTP is used by default; Apify or custom proxy routing can be enabled when needed.",
                        "properties": {
                            "useApifyProxy": {
                                "type": "boolean",
                                "default": false,
                                "title": "Use Apify Proxy",
                                "description": "Route requests through Apify Proxy when direct access is unavailable."
                            },
                            "apifyProxyGroups": {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                },
                                "default": [],
                                "description": "Optional Apify Proxy groups. Leave empty to use the default datacenter group.",
                                "title": "Apify Proxy Groups"
                            },
                            "proxyCountryCode": {
                                "type": "string",
                                "default": "DE",
                                "title": "Proxy Country Code",
                                "description": "Two-letter country code used for location-aware proxy routing."
                            },
                            "proxyUrls": {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                },
                                "default": [],
                                "description": "Custom proxy URLs. Credentials are redacted from logs and request summaries.",
                                "title": "Proxy Urls"
                            },
                            "accessMethodPriority": {
                                "type": "array",
                                "items": {
                                    "type": "string",
                                    "enum": [
                                        "DIRECT_HTTP",
                                        "DATACENTER",
                                        "RESIDENTIAL",
                                        "CUSTOM",
                                        "BROWSER_FALLBACK"
                                    ]
                                },
                                "default": [
                                    "DIRECT_HTTP",
                                    "DATACENTER",
                                    "RESIDENTIAL",
                                    "CUSTOM"
                                ],
                                "title": "Access Method Priority",
                                "description": "Ordered access methods to try when a request is blocked or unavailable.",
                                "editor": "select"
                            },
                            "allowedProxyFallbacks": {
                                "type": "array",
                                "items": {
                                    "type": "string",
                                    "enum": [
                                        "DATACENTER",
                                        "RESIDENTIAL",
                                        "CUSTOM",
                                        "BROWSER_FALLBACK"
                                    ]
                                },
                                "default": [
                                    "DATACENTER",
                                    "RESIDENTIAL",
                                    "CUSTOM"
                                ],
                                "title": "Allowed Proxy Fallbacks",
                                "description": "Proxy methods that may be used after the preferred access method fails.",
                                "editor": "select"
                            },
                            "browserFallbackEnabled": {
                                "type": "boolean",
                                "default": false,
                                "description": "Enable browser-based fallback for pages that cannot be retrieved through HTTP access methods.",
                                "title": "Browser Fallback Enabled"
                            }
                        },
                        "default": {},
                        "additionalProperties": false
                    },
                    "proxyConfiguration": {
                        "title": "Apify proxy configuration",
                        "type": "object",
                        "description": "Standard Apify proxy selector. When advanced proxy is also provided, advanced proxy takes precedence. Direct HTTP remains the default.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
