# MediaMarkt Germany Scraper (`solidcode/mediamarkt-de-scraper`) Actor

\[💰 $1.8 / 1K] Scrape products from MediaMarkt.de: price, original price, discount, brand, EAN, rating, review count, images, delivery and pickup availability, seller and energy label. Search by keyword or paste MediaMarkt URLs.

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

## Pricing

from $1.80 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## MediaMarkt Germany Scraper

Pull live product data from MediaMarkt.de at scale — current and original prices, discount percentages, EAN/GTIN barcodes, EU energy-efficiency labels, aggregate ratings, and delivery plus in-store pickup availability for every result. Search by keyword or paste any MediaMarkt search, brand, category, or campaign URL. Built for price-intelligence teams, e-commerce analysts, and deal-tracking platforms who need fresh MediaMarkt Germany data without building and maintaining their own collector.

### Why This Scraper?

- **EAN/GTIN barcode on every product** — match MediaMarkt rows directly to your own catalog, a competitor feed, or a manufacturer SKU list without fuzzy name matching.
- **Original price, current price, and discount percentage together** — every row carries the crossed-out strike price and the computed discount %, so genuine deals are obvious at a glance, not reverse-engineered later.
- **EU energy-efficiency label captured** — the official A-to-G energy class on appliances and electronics, ideal for compliance, eco-filtering, and product comparison.
- **Delivery *and* in-store pickup availability** — separate flags plus human-readable status text for both home delivery and click-and-collect, not a single vague "in stock".
- **Aggregate rating and review count** — the average customer score and total number of reviews on each product, ready for quality ranking and sentiment baselining.
- **Marketplace seller details** — when a product is sold by a third-party seller, you get the seller name, ID, and seller rating alongside MediaMarkt's own first-party items.
- **Four sort modes and a EUR price-range filter** — collect by Relevance, Price: Low to High, Price: High to Low, or Top Rated, and clamp results to a minimum and maximum euro price.
- **Keyword search or four kinds of pasted URL** — run plain keyword searches, or replay a MediaMarkt search, brand, category, or campaign listing URL exactly as it appears in your browser.

### Use Cases

**Price Intelligence**
- Track current and original prices across MediaMarkt's catalog over time
- Calculate true discount depth using the strike price on every row
- Compare your own pricing against a major German electronics retailer
- Spot price changes on flagship phones, TVs, and consoles between runs

**Competitive Monitoring**
- Monitor a competitor brand's full MediaMarkt lineup from one brand URL
- Map a product category by breadcrumb trail to see assortment breadth
- Watch marketplace third-party sellers entering MediaMarkt's catalog
- Benchmark availability — what ships, what is pickup-only, what is sold out

**Deal & Promotion Tracking**
- Surface every product with a strike price and a double-digit discount
- Track promo badges and campaign-page assortments during sale events
- Build a "best deals today" feed sorted by discount percentage
- Alert on price drops for a watchlist of EANs across runs

**Catalog & Data Enrichment**
- Enrich an existing product database with EAN, energy class, and imagery
- Match MediaMarkt rows to your inventory by EAN/GTIN barcode
- Feed structured electronics data into dashboards and BI tools
- Build comparison shopping and product-research tools for German shoppers

**Market Research**
- Measure how brands rank by rating and review volume in a category
- Analyze energy-efficiency class distribution across an appliance segment
- Quantify how much of a category is first-party vs. marketplace
- Map price bands within a product type using the price-range filter

### Getting Started

#### Simple Keyword Search

The fastest way to start — one keyword, 100 products:

```json
{
    "searchQueries": ["iphone 15"],
    "maxResults": 100
}
````

#### Filtered Search (Price Range + Sort)

Collect mid-range OLED TVs, cheapest first:

```json
{
    "searchQueries": ["oled tv"],
    "minPrice": 500,
    "maxPrice": 1500,
    "sortBy": "price-asc",
    "maxResults": 200
}
```

#### Multiple Keywords and a Pasted URL

Mix several searches with a MediaMarkt brand or category URL, sorted by best-rated:

```json
{
    "searchQueries": ["bluetooth kopfhörer", "soundbar"],
    "startUrls": [
        "https://www.mediamarkt.de/de/search.html?query=samsung+ssd"
    ],
    "sortBy": "top-rated",
    "minPrice": 50,
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["iphone 15"]` | Keywords to search on MediaMarkt.de, such as "iPhone 15" or "OLED TV". Each keyword runs its own search. Leave empty if you are pasting URLs. |
| `startUrls` | string\[] | `[]` | MediaMarkt.de search, brand, category, or campaign listing URLs. A search URL's keyword and filters are replayed exactly — the most precise option. Category and brand pages are scoped on a best-effort basis. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | null | Only include products priced at or above this amount, in euros. Leave empty for no minimum. |
| `maxPrice` | integer | null | Only include products priced at or below this amount, in euros. Leave empty for no maximum. |
| `sortBy` | select | `Relevance` | Order in which products are collected: Relevance, Price: Low to High, Price: High to Low, or Top Rated. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of products to return per search keyword or URL. Set to `0` for unlimited. |

### Output

Each result is a single flat product row. Here is a representative item:

```json
{
    "productId": "2895012",
    "productName": "APPLE iPhone 15 (128 GB) Schwarz",
    "brand": "APPLE",
    "ean": "0195949037962",
    "url": "https://www.mediamarkt.de/de/product/_apple-iphone-15-128-gb-schwarz-2895012.html",
    "price": 699.0,
    "strikePrice": 949.0,
    "currency": "EUR",
    "discountPercentage": 26.0,
    "shippingCost": 0.0,
    "isMarketplaceProduct": false,
    "sellerId": null,
    "sellerName": null,
    "sellerRating": null,
    "mainImage": "https://assets.mmsrg.com/isr/166325/c1/-/example/iphone-15.png",
    "images": [],
    "averageRating": 4.7,
    "reviewCount": 1284,
    "isAvailableForDelivery": true,
    "isAvailableForPickup": true,
    "isAvailableAndBuyable": true,
    "deliveryStatus": "AVAILABLE",
    "deliveryDisplayStatus": "Lieferung in 1-2 Werktagen",
    "pickupStatus": "AVAILABLE",
    "pickupDisplayStatus": "Abholung im Markt möglich",
    "breadcrumbs": ["Smartphones & Handys", "Smartphones", "Apple iPhone"],
    "badges": ["Top-Angebot"],
    "energyEfficiency": "A",
    "searchQuery": "iphone 15",
    "sourceUrl": null,
    "scrapedAt": "2026-06-25T14:30:00.123456+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | MediaMarkt product/article identifier |
| `productName` | string | Full product title |
| `brand` | string | Manufacturer / brand name |
| `ean` | string | EAN/GTIN barcode when present |
| `url` | string | Canonical product page URL |
| `mainImage` | string | Primary product image URL |
| `images` | string\[] | Additional image URLs (reserved; the main image is the reliable source) |
| `breadcrumbs` | string\[] | Category breadcrumb trail |
| `badges` | string\[] | Promo and label badges shown on the product |
| `energyEfficiency` | string | EU energy-efficiency class (e.g. "A") |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current price in euros |
| `strikePrice` | number | Original / crossed-out price in euros |
| `currency` | string | Currency code (always "EUR") |
| `discountPercentage` | number | Discount versus the strike price |
| `shippingCost` | number | Delivery cost when shown |
| `isMarketplaceProduct` | boolean | Sold by a third-party marketplace seller |
| `sellerId` | string | Marketplace seller identifier |
| `sellerName` | string | Marketplace seller name |
| `sellerRating` | number | Marketplace seller rating |

#### Ratings & Availability

| Field | Type | Description |
|-------|------|-------------|
| `averageRating` | number | Aggregate customer rating |
| `reviewCount` | integer | Total number of customer reviews |
| `isAvailableForDelivery` | boolean | Home delivery availability |
| `isAvailableForPickup` | boolean | In-store pickup availability |
| `isAvailableAndBuyable` | boolean | Whether the product is currently purchasable (listed and orderable, distinct from delivery/pickup availability) |
| `deliveryStatus` | string | Raw delivery status code |
| `deliveryDisplayStatus` | string | Human-readable delivery status |
| `pickupStatus` | string | Raw pickup status code |
| `pickupDisplayStatus` | string | Human-readable pickup status |

#### Source & Timestamp

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The keyword that produced this row (when from a search) |
| `sourceUrl` | string | The listing URL that produced this row (when from a pasted URL) |
| `scrapedAt` | string | ISO timestamp of extraction |

### Tips for Best Results

- **Start small to validate.** Set `maxResults` to 25–50 on your first run to confirm the fields match your needs, then scale up.
- **Split big catalogs into narrower searches.** A single MediaMarkt search returns up to roughly 360 products. To pull a deep category, run several tighter keywords (e.g. "samsung soundbar" instead of "audio") or break one search into stacked price bands.
- **Use price ranges to slice past the per-search limit.** Splitting "laptop" into `0–500`, `500–1000`, and `1000+` euro runs collects far more of the category than one broad search ever can.
- **Paste a search URL for pixel-perfect replay.** A `search.html?query=` URL reproduces the exact keyword, filters, and sort from your browser — the most precise way to capture a specific MediaMarkt result set.
- **Match by EAN, not name.** Every row carries the EAN/GTIN barcode, so join MediaMarkt data to your own catalog on the barcode rather than the product title for clean, reliable matching.
- **Sort by Top Rated for quality research.** Combine `sortBy: "top-rated"` with a category keyword to surface the best-reviewed products first.
- **Filter to genuine deals.** Sort by Price: Low to High inside a price band, then keep only rows where `strikePrice` is present and `discountPercentage` is high to build a clean promotions feed.

### Pricing

**From $1.80 per 1,000 results** — undercuts comparable MediaMarkt extractors while bundling EAN barcodes, energy labels, and full pricing on every row. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.22 | $0.21 | $0.19 | $0.18 |
| 1,000 | $2.15 | $2.05 | $1.90 | $1.80 |
| 10,000 | $21.50 | $20.50 | $19.00 | $18.00 |
| 100,000 | $215.00 | $205.00 | $190.00 | $180.00 |

A "result" is any product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate price intelligence, competitive monitoring, market research, and catalog enrichment. Users are responsible for complying with applicable laws and MediaMarkt's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose. Collect only publicly available product information and respect reasonable request rates.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on MediaMarkt.de, such as 'iPhone 15' or 'OLED TV'. Each keyword runs its own search. Leave empty if you are pasting URLs below.

## `startUrls` (type: `array`):

Paste MediaMarkt.de search, brand, category, or campaign listing URLs. A search URL's keyword and filters are replayed exactly — this is the most precise option. Category and brand page URLs are scoped on a best-effort basis. Leave empty if you are using search keywords above.

## `minPrice` (type: `integer`):

Only include products priced at or above this amount, in euros. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Only include products priced at or below this amount, in euros. Leave empty for no maximum.

## `sortBy` (type: `string`):

Order in which products are collected.

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

Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Note: MediaMarkt limits any single search to about 360 products — to collect more, split into narrower keywords or stacked price ranges.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone 15"
  ],
  "startUrls": [],
  "sortBy": "relevance",
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped products with key fields.

# 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 = {
    "searchQueries": [
        "iphone 15"
    ],
    "startUrls": [],
    "sortBy": "relevance",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/mediamarkt-de-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 = {
    "searchQueries": ["iphone 15"],
    "startUrls": [],
    "sortBy": "relevance",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/mediamarkt-de-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 '{
  "searchQueries": [
    "iphone 15"
  ],
  "startUrls": [],
  "sortBy": "relevance",
  "maxResults": 100
}' |
apify call solidcode/mediamarkt-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MediaMarkt Germany Scraper",
        "description": "[💰 $1.8 / 1K] Scrape products from MediaMarkt.de: price, original price, discount, brand, EAN, rating, review count, images, delivery and pickup availability, seller and energy label. Search by keyword or paste MediaMarkt URLs.",
        "version": "1.0",
        "x-build-id": "jEpLdaVzu5lY0WBZk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~mediamarkt-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-mediamarkt-de-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/solidcode~mediamarkt-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-mediamarkt-de-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/solidcode~mediamarkt-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-mediamarkt-de-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search on MediaMarkt.de, such as 'iPhone 15' or 'OLED TV'. Each keyword runs its own search. Leave empty if you are pasting URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "MediaMarkt URLs",
                        "type": "array",
                        "description": "Paste MediaMarkt.de search, brand, category, or campaign listing URLs. A search URL's keyword and filters are replayed exactly — this is the most precise option. Category and brand page URLs are scoped on a best-effort basis. Leave empty if you are using search keywords above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include products priced at or above this amount, in euros. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include products priced at or below this amount, in euros. Leave empty for no maximum."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "top-rated"
                        ],
                        "type": "string",
                        "description": "Order in which products are collected.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Note: MediaMarkt limits any single search to about 360 products — to collect more, split into narrower keywords or stacked price ranges.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```