# Rohlik Scraper - Czech, German & Austrian Online Grocery (`studio-amba/rohlik-scraper`) Actor

Scrape grocery products, prices, stock, and categories from Rohlik.cz, Knuspr.de, and Gurkerl.at. Supports search and category browsing.

- **URL**: https://apify.com/studio-amba/rohlik-scraper.md
- **Developed by:** [Studio Amba](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 usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Rohlik Scraper - Grocery Products & Prices from Central Europe's Leading Online Supermarket

Extract grocery product data, prices, stock availability, and categories from [Rohlik.cz](https://www.rohlik.cz) (Czech Republic), [Knuspr.de](https://www.knuspr.de) (Germany), and [Gurkerl.at](https://www.gurkerl.at) (Austria) -- the Rohlik Group's online supermarkets covering Central Europe.

### What is Rohlik Scraper?

Rohlik Scraper collects structured product data from the Rohlik Group's grocery platforms. It uses Rohlik's internal REST API to extract product details, pricing, stock levels, and full category paths -- delivering clean, structured data without needing to parse unreliable HTML.

Rohlik Group is Central Europe's fastest-growing online grocery platform. Founded in Prague in 2014, it processes millions of orders annually across three brands: Rohlik.cz (Czech Republic, the flagship), Knuspr.de (Germany, focused on Munich and Berlin), and Gurkerl.at (Austria, focused on Vienna). With 20,000+ products per market and rapid delivery (as fast as 90 minutes), their product catalog is one of the richest grocery data sources in the region.

**Popular use cases:**

- **Grocery price monitoring** -- Track prices across Czech, German, and Austrian markets. Detect promotions, seasonal pricing shifts, and cross-border price differences.
- **Competitor intelligence** -- Compare Rohlik's product range and pricing against Kosik, Tesco Online, REWE, and other Central European grocery platforms.
- **Market research** -- Analyze product availability, brand distribution, and category structure across three Central European markets.
- **Supply chain analysis** -- Monitor stock levels and product availability patterns to understand supply chain dynamics.
- **Food industry research** -- Study product ranges, brand penetration, and pricing strategies in the fast-growing online grocery segment.

### How to scrape Rohlik data

#### Option 1: Search by keyword

Set `searchQuery` to any product name or keyword in the target language. Use Czech terms for Rohlik.cz, German terms for Knuspr.de and Gurkerl.at.

**Czech examples:** `"mléko"` (milk), `"chléb"` (bread), `"máslo"` (butter), `"kuřecí prsa"` (chicken breast)

**German examples:** `"Milch"` (milk), `"Brot"` (bread), `"Butter"` (butter), `"Hackfleisch"` (ground meat)

#### Option 2: Browse by category

Set `categoryId` to a Rohlik category ID. Find these in category page URLs on the site -- they follow the pattern `/c{ID}-{slug}`.

**Common category IDs (same across all three markets):**
- `300101000` -- Bakery & pastries
- `300102000` -- Fruits & vegetables
- `300103000` -- Meat & fish
- `300104000` -- Dairy & eggs
- `300105000` -- Deli & ready meals
- `300106000` -- Beverages
- `300107000` -- Frozen food
- `300108000` -- Household & cleaning
- `300109000` -- Baby & kids

#### Option 3: Default mode

Run with empty input `{}` to get bakery products from Rohlik.cz. The scraper uses a sensible default search query to always return data.

#### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `country` | Enum | `CZ` | Target market: `CZ` (rohlik.cz), `DE` (knuspr.de), `AT` (gurkerl.at) |
| `searchQuery` | String | -- | Search for products by keyword (native language recommended) |
| `categoryId` | String | -- | Category ID from the site URL (e.g., `300102000` for Fruits) |
| `maxResults` | Integer | 100 | Maximum products to return (up to 100,000) |
| `proxyConfiguration` | Object | -- | Proxy settings for reliability |

**Tips:**
- When both `searchQuery` and `categoryId` are provided, search takes priority.
- Category mode is faster and more reliable since it uses the structured API directly.
- For large catalog dumps, use category mode with a high `maxResults`.
- Prices are in CZK for Czech Republic, EUR for Germany and Austria.
- The same category IDs work across all three markets.

### What data does Rohlik Scraper extract?

Each product includes:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Rohlíkův tukový rohlík"` |
| `brand` | String | `"BEZ KOMPROMISU"` |
| `price` | Number | `4.50` |
| `currency` | String | `"CZK"` |
| `originalPrice` | Number | `5.90` |
| `pricePerUnit` | String | `"90 CZK/kg"` |
| `discount` | String | `"-15%"` |
| `inStock` | Boolean | `true` |
| `productId` | String | `"1465504"` |
| `category` | String | `"Rohlíky"` |
| `categories` | Array | `["Pekárna a cukrárna", "Slané pečivo", "Rohlíky"]` |
| `textualAmount` | String | `"50 g"` |
| `countryOfOrigin` | String | `"Česká republika"` |
| `imageUrl` | String | CDN URL of product image |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO timestamp |

### Output example

```json
[
  {
    "name": "Pekárna Brod rohlík jemný tukový",
    "brand": "Pekárna Brod",
    "price": 2.90,
    "currency": "CZK",
    "pricePerUnit": "67.44 CZK/kg",
    "inStock": true,
    "productId": "1286399",
    "category": "Rohlíky",
    "categories": ["Pekárna a cukrárna", "Slané pečivo", "Rohlíky"],
    "textualAmount": "43 g",
    "countryOfOrigin": "Česká republika",
    "imageUrl": "https://cdn.rohlik.cz/images/grocery/products/1286399/1286399-1432042251.jpg",
    "url": "https://www.rohlik.cz/1286399-pekarna-brod-rohlik-jemny-tukovy",
    "scrapedAt": "2026-06-07T10:30:15.000Z"
  },
  {
    "name": "Rohlíkův rohlíček světlý se sezamem banketka",
    "brand": "BEZ KOMPROMISU",
    "price": 3.90,
    "currency": "CZK",
    "pricePerUnit": "195 CZK/kg",
    "inStock": true,
    "productId": "1425550",
    "category": "Rohlíky",
    "categories": ["Pekárna a cukrárna", "Slané pečivo", "Rohlíky"],
    "textualAmount": "20 g",
    "countryOfOrigin": "Česká republika",
    "imageUrl": "https://cdn.rohlik.cz/images/grocery/products/1425550/1425550-1666004519233.jpg",
    "url": "https://www.rohlik.cz/1425550-rohlikuv-rohlicek-svetly-se-sezamem-banketka",
    "scrapedAt": "2026-06-07T10:30:15.000Z"
  },
  {
    "name": "Bageta malá světlá",
    "brand": "La Lorraine",
    "price": 3.90,
    "currency": "CZK",
    "pricePerUnit": "78 CZK/kg",
    "inStock": true,
    "productId": "1356867",
    "category": "Bagety a veky",
    "categories": ["Pekárna a cukrárna", "Slané pečivo", "Bagety a veky"],
    "textualAmount": "50 g",
    "countryOfOrigin": "Česká republika",
    "imageUrl": "https://cdn.rohlik.cz/images/grocery/products/1356867/1356867-1608937245240.jpg",
    "url": "https://www.rohlik.cz/1356867-bageta-mala-svetla",
    "scrapedAt": "2026-06-07T10:30:15.000Z"
  }
]
````

### How much does it cost?

Rohlik Scraper uses direct API calls (no browser needed) which keeps costs very low.

| Scenario | Products | Estimated cost | Time |
|----------|----------|---------------|------|
| Quick search | 20 | ~$0.005 | ~5 sec |
| Category browse | 100 | ~$0.01 | ~10 sec |
| Large category | 500 | ~$0.05 | ~30 sec |
| Full catalog dump | 5,000 | ~$0.30 | ~5 min |

The API-based approach is significantly faster and cheaper than browser-based scraping.

### Can I integrate?

Rohlik Scraper connects to the full Apify integration ecosystem:

- **Apify API** -- Trigger runs programmatically, stream results in real-time
- **Webhooks** -- Notify your systems when scraping completes
- **Google Sheets** -- Auto-export grocery data for team access
- **Zapier / Make** -- Build no-code automations triggered by new product data
- **Slack alerts** -- Get notified when tracked product prices change
- **Airbyte / BigQuery / Snowflake** -- Stream to your data warehouse for analytics
- **Scheduled runs** -- Set up daily price monitoring with Apify Schedules
- **Direct download** -- CSV, JSON, XML, or Excel export from the Apify Console

### Can I use it as an API?

Use Rohlik Scraper as a Central European grocery product API. Start runs, poll for results, and process data in your application.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/rohlik-scraper").call(run_input={
    "country": "CZ",
    "searchQuery": "mléko",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    stock = "In stock" if item.get("inStock") else "Out of stock"
    print(f"{item['name']} — {item['price']} {item['currency']} ({stock})")
```

#### JavaScript

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

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

const run = await client.actor("studio-amba/rohlik-scraper").call({
  country: "CZ",
  categoryId: "300102000",
  maxResults: 200,
});

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

items.forEach((item) => {
  const discount = item.discount ? ` (${item.discount})` : "";
  console.log(`${item.name} — ${item.price} ${item.currency}${discount}`);
});
```

### FAQ

#### What is the difference between Rohlik.cz, Knuspr.de, and Gurkerl.at?

They are all part of the Rohlik Group but operate as separate brands in different markets. Rohlik.cz is the Czech original (founded 2014), Knuspr.de serves Germany (Munich, Berlin), and Gurkerl.at serves Austria (Vienna). They share the same technology platform but have different product catalogs and pricing.

#### Do I need to create an account to use this scraper?

No. This scraper accesses publicly available product data and pricing. No login or cookies are required.

#### Why do some products show no price?

Some products are "premium only" (available only to Rohlik Premium subscribers) or temporarily unavailable. The scraper captures the standard public price when available.

#### Can I scrape all 20,000+ products from a single market?

Yes. Use category mode with a high `maxResults` value. For a complete catalog dump, you may want to iterate through multiple top-level categories. The API supports pagination, so there is no hard limit.

#### What currencies are used?

Czech Republic (CZ) uses CZK (Czech koruna). Germany (DE) and Austria (AT) use EUR.

### Limitations

- **Search relies on SSR HTML** -- Search mode extracts product IDs from server-rendered HTML, which may return fewer results than the full search index. For comprehensive data, prefer category mode.
- **Premium pricing not included** -- Rohlik Premium member prices (typically 10-15% lower) are tracked separately by Rohlik and not included in the standard price field.
- **Product descriptions** -- The product details API does not include full text descriptions. Product names and category paths provide the main textual information.
- **Cloudflare protection** -- Rohlik uses Cloudflare. Using residential proxies for the target country is recommended for reliability.
- **Rate limiting** -- Very aggressive scraping may trigger rate limits. The scraper uses moderate pacing by default.

### Other Central European e-commerce scrapers

Build a complete view of Central European online retail with companion scrapers:

- **[Kosik Scraper](https://apify.com/studio-amba/kosik-scraper)** -- Czech online grocery competitor
- **[Tesco Scraper](https://apify.com/studio-amba/tesco-scraper)** -- Tesco online grocery across multiple markets
- **[Alza Scraper](https://apify.com/studio-amba/alza-scraper)** -- Czech electronics and general merchandise

### Your feedback

Rohlik updates their platform frequently. If you notice any data quality issues, missing fields, or broken runs, let us know through the Apify Console. We monitor and update this scraper to keep pace with platform changes.

# Actor input Schema

## `country` (type: `string`):

Which Rohlik Group site to scrape. Rohlik.cz (Czech Republic), Knuspr.de (Germany), or Gurkerl.at (Austria).

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

Search for products by name or keyword. Use native-language terms for best results (e.g., 'mleko' for Czech, 'Milch' for German).

## `categoryId` (type: `string`):

Rohlik category ID to browse (e.g., '300101000' for Bakery, '300102000' for Fruits & Vegetables). Find IDs in category page URLs: /c{ID}-{slug}. Ignored if searchQuery is set.

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

Maximum number of products to return.

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

Proxy settings. Recommended for reliable scraping. Use residential proxies for the target country.

## Actor input object example

```json
{
  "country": "CZ",
  "searchQuery": "mléko",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}
```

# 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 = {
    "country": "CZ",
    "searchQuery": "mléko",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CZ"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/rohlik-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 = {
    "country": "CZ",
    "searchQuery": "mléko",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CZ",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/rohlik-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 '{
  "country": "CZ",
  "searchQuery": "mléko",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}' |
apify call studio-amba/rohlik-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rohlik Scraper - Czech, German & Austrian Online Grocery",
        "description": "Scrape grocery products, prices, stock, and categories from Rohlik.cz, Knuspr.de, and Gurkerl.at. Supports search and category browsing.",
        "version": "0.1",
        "x-build-id": "ik6w79cwNU2WNlypZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~rohlik-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-rohlik-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~rohlik-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-rohlik-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~rohlik-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-rohlik-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": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "CZ",
                            "DE",
                            "AT"
                        ],
                        "type": "string",
                        "description": "Which Rohlik Group site to scrape. Rohlik.cz (Czech Republic), Knuspr.de (Germany), or Gurkerl.at (Austria).",
                        "default": "CZ"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by name or keyword. Use native-language terms for best results (e.g., 'mleko' for Czech, 'Milch' for German)."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Rohlik category ID to browse (e.g., '300101000' for Bakery, '300102000' for Fruits & Vegetables). Find IDs in category page URLs: /c{ID}-{slug}. Ignored if searchQuery is set."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for reliable scraping. Use residential proxies for the target country."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
