# DE/AT Pharmacy Price & Stock Monitor (`zhorex/pharmacy-price-monitor`) Actor

PZN-keyed OTC shelf data from Europe's largest online pharmacy (DE + AT): price, list-price breach, discount, availability and the marketplace seller undercutting the shop. Delta mode returns only price moves, RRP breaches and stock flips.

- **URL**: https://apify.com/zhorex/pharmacy-price-monitor.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 article shelf row (per pzn)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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

## DE/AT Pharmacy Price & Stock Monitor — PZN-Keyed Shelf Data (2026)

Track what Europe's largest online pharmacy actually charges, article by article, across the **German and Austrian** storefronts. Every row is keyed on the **PZN** — the German/Austrian pharmaceutical article number — so the same product lines up across markets, sellers and your own ERP with no name matching.

Per article you get: selling price, the struck-through **list price and the percentage breach against it**, discount, price per unit, **availability**, how many marketplace sellers are on the listing and **which one is undercutting the shop**, pack size, form, rating and the product URL.

No login. No API key to obtain. No browser. Clean JSON / CSV / Excel, billed per row you receive.

### Three ways to use it

| Mode | What it does |
|---|---|
| **Brand watch** | Every article of a brand — `DOPPELHERZ` (335 articles DE), `ABTEI` (148), `VOLTAREN`. One request covers up to 1,000 articles, so a brand is one request, not one per SKU |
| **PZN watch** | The exact article numbers you own or track, batched 40 per request |
| **Category slice** | A raw index filter for a whole segment, e.g. `prescriptionMedicine:false AND marketplace:false` |

### Delta mode — and why out-of-stock only exists here

With `deltaMode: true`, the first run records a baseline and every later run returns **only what changed**:

| `changeType` | Meaning |
|---|---|
| `price_up` / `price_down` | Selling price moved, with `priceChange` and `priceChangePct` |
| `rrp_breach_opened` | The article crossed **under** its list price — the dated evidence a Preispflege file is built from |
| `rrp_breach_closed` | It came back up to or above list |
| `out_of_stock` / `back_in_stock` | Availability flipped |
| `new` | Article seen for the first time on this stream |
| `disappeared` | Tracked article absent from a slice this run swept |

**The availability point is not marketing.** The storefront's search index exposes `inStock` as a value you can read but offers **no stock facet and no way to filter on it** — `filters=inStock:false` returns zero hits. So "went out of stock at 14:00 on Tuesday" can only be derived by comparing today's row against stored state. A competitor who starts next month cannot reconstruct the transitions they missed, and neither can this Actor: the history begins the day your schedule does.

Articles that did not change are **not returned and not charged**. And a baseline run is billed at the ordinary row rate, never at the alert rate — starting a monitor should not cost eight times as much as running it.

```json
{
    "mode": "pzn_watch",
    "pzns": ["17268563", "11559302"],
    "markets": ["DE", "AT"],
    "includeMarketplaceOffers": true,
    "deltaMode": true,
    "deltaStateKey": "my-brand-de-at"
}
````

### Example row

```json
{
    "pzn": "11559302",
    "productName": "Abtei Beta-Carotin Plus Hautaktive B-Vitamine",
    "brand": "ABTEI",
    "market": "DE",
    "price": 4.89,
    "referencePrice": 4.95,
    "rrpBreach": true,
    "rrpBreachPct": 1.21,
    "discountPct": 0.0,
    "pricePerUnit": "0,10 € / 1 St",
    "netPrice": 4.57,
    "inStock": true,
    "packSize": "50 St",
    "pharmaForm": "Kapseln",
    "averageRating": 4.9,
    "ratingCount": 25,
    "lowestOfferPrice": 4.89,
    "lowestOfferSeller": "Shop Apotheke",
    "undercutByMarketplace": false,
    "offerSellerCount": 1,
    "productUrl": "https://www.shop-apotheke.com/beauty/11559302/abtei-beta-carotin-plus-hautaktive-b-vitamine.htm",
    "scrapedAt": "2026-07-25T20:30:00Z"
}
```

### Who buys this

| Buyer | Job |
|---|---|
| **OTC brand and trade-marketing teams** | Dated per-article evidence of who is selling under the recommended price, and by how much — the file you need before a price-maintenance conversation |
| **Distributors and wholesalers** | Availability and price corridors across DE and AT on the articles you supply |
| **Pharmacy chains and e-pharmacies** | Competitive repricing against the market leader's actual shelf, not its advertised RRP |
| **Consumer-health analysts and funds** | Assortment breadth, discount depth and stock-out frequency as a demand and supply-chain read |
| **Market researchers** | A PZN-keyed panel that joins to IQVIA-style data without fuzzy matching |

### Sizing your run (and your bill)

Rows = **articles × markets**, and one request returns up to 1,000 articles.

| Setup | Requests | Rows | At $0.006/row |
|---|---|---|---|
| One brand (ABTEI, 148 articles), DE | 1 | 148 | $0.89 |
| Doppelherz DE + AT (543 articles) | 2 | 543 | $3.26 |
| 200 own PZNs × 2 markets, daily cron **with delta** | 10/day | only what moved | typically a small fraction |
| Doppelherz-scale daily monitor, 22 business days | ~44 | mostly alerts | see below |

A brand team watching 543 articles daily is 543 rows on day one and then only the movers — which on this shelf is a small minority of articles per day, so the recurring cost tracks the market's actual volatility rather than your catalogue size.

### Pricing

| Event | Price | What it is |
|---|---|---|
| `sku-price-check` | **$0.006** | One article row, full field set. Also the rate for newly tracked articles on a baseline run |
| `shelf-alert` | **$0.04** | One genuine change: price move, list-price breach opening or closing, or a stock flip — with its previous values |

Slices that fail are pushed as error records with the reason and are **never charged**.

### Limitations, stated plainly

- **The index exposes the first 5,000 matches of any single query.** Volume comes from slicing (per brand, per category, per market), not from paging deeper. The Actor refuses to page past the window and tells you when a slice is larger than what it can return.
- **`referencePrice` is not present on every article.** Only some carry a struck-through list price; where the storefront shows none, turning on marketplace offers recovers one from the sellers' own strike prices (flagged as `referencePriceSource`). Where neither exists, the breach fields are `null` rather than guessed.
- **This is one retailer's shelf** — the market leader's, across two countries. It is not a multi-pharmacy index. `medpex` in particular is behind a challenge and is deliberately not scraped.
- **No history before your first run.** Nobody can retro-fetch yesterday's price or stock state.
- **Credentials:** the storefront publishes read-only search credentials for its own product index; this Actor ships the last verified pair and re-reads the storefront each run in case they change. If they are ever rotated, runs fail **loudly** with an explicit message — not silently with zero rows — and the fix is a rebuild.
- **No personal data.** Articles, prices, sellers and stock states only. No customers, no prescriptions, no reviewers.

### FAQ

**Do I need a proxy?** No. The search endpoint answers ordinary datacenter IPs with no challenge and no rate limiting observed.

**Why is `inStock` false on so many articles?** Because it genuinely is — on the brand slices tested, a large share of articles were unavailable. That is the signal, not a bug.

**Can I monitor prescription medicines?** They are in the index (`prescriptionOnly: true`) but their pricing is regulated and far less interesting; `filterExpression: prescriptionMedicine:false` keeps them out.

**Austria too?** Yes — `markets: ["DE", "AT"]`. The same PZN is often priced differently in each, which is the cross-border corridor signal.

### Other scrapers by Zhorex

- [Hostelworld Rate & Availability Monitor](https://apify.com/zhorex/hostelworld-rate-monitor) — the same delta-monitor pattern for accommodation rates
- [Resy Availability & Scarcity Monitor](https://apify.com/zhorex/resy-availability-monitor) — forward-dated restaurant availability

### Legal

This Actor reads publicly visible commercial product data: article numbers, names, prices, discounts, stock states and seller identities of businesses. It collects no personal data. Respect the storefront's terms and applicable law in your jurisdiction, and use the data for analysis rather than redistribution.

# Actor input Schema

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

'Brand watch' pulls every article of a brand — the volume path, and how you map a competitor's whole range. 'PZN watch' takes the exact article numbers you own, which is what a brand or trade team actually monitors. 'Category slice' takes a raw index filter for analysts who want a whole segment.

## `brands` (type: `array`):

Brand tokens, exact and case-insensitive (they are stored upper-case in the index): DOPPELHERZ, ABTEI, VOLTAREN, BEPANTHEN, NUROFEN, ASPIRIN. One request covers up to 1,000 articles of a brand, so a brand is one request, not one per article.

## `pzns` (type: `array`):

Pharmazentralnummern to track, e.g. 17268563. The PZN is the German/Austrian pharmaceutical article number, so it joins the same article across storefronts and sellers with no name matching. Batched 40 per request.

## `filterExpression` (type: `string`):

A raw index filter, e.g. `prescriptionMedicine:false AND marketplace:false` or `categoryCodes:...`. Note the result window: any single filter exposes at most 5,000 articles, so slice narrowly (per brand, per category) rather than trying to page through a whole catalogue.

## `markets` (type: `array`):

DE (shop-apotheke.com) and/or AT (shop-apotheke.at). The same PZN is often priced differently in each, which is itself the signal for cross-border price-corridor work.

## `includeMarketplaceOffers` (type: `boolean`):

Adds the per-seller offer table for each article: how many sellers, the cheapest offer and who is making it, the price spread, and whether the shop's own price is being undercut. This is the answer to 'who is breaking my price', and it also recovers a reference price for articles where the storefront shows none. Costs one extra request per 40 articles.

## `maxRowsPerSlice` (type: `integer`):

Ceiling per brand / PZN batch / filter. The index only ever exposes the first 5,000 matches of a query, so values above that cannot be reached by paging — narrow the slice instead.

## `deltaMode` (type: `boolean`):

Turn this on for a scheduled monitor. The first run records a baseline (billed at the ordinary row rate, not the alert rate); every later run returns and bills ONLY what moved: price up or down, a list-price breach opening or closing, and stock flips. Out-of-stock is only detectable this way — the search index has no stock filter at all, so availability changes can only be derived by comparing against stored state.

## `deltaStateKey` (type: `string`):

Names an independent delta stream so several monitors don't collide (e.g. 'my-brand-de' vs 'competitors-at'). Only used when Delta mode is on.

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

Not needed: the search endpoint answers ordinary datacenter IPs with no challenge and no rate limiting observed. Leave it off unless you specifically want your traffic routed.

## Actor input object example

```json
{
  "mode": "brand_watch",
  "brands": [
    "DOPPELHERZ",
    "ABTEI"
  ],
  "pzns": [
    "17268563",
    "11559302"
  ],
  "filterExpression": "prescriptionMedicine:false AND marketplace:false",
  "markets": [
    "DE",
    "AT"
  ],
  "includeMarketplaceOffers": true,
  "maxRowsPerSlice": 1000,
  "deltaMode": false,
  "deltaStateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "mode": "brand_watch",
    "brands": [
        "ABTEI"
    ],
    "markets": [
        "DE"
    ],
    "includeMarketplaceOffers": true,
    "maxRowsPerSlice": 1000,
    "deltaStateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/pharmacy-price-monitor").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 = {
    "mode": "brand_watch",
    "brands": ["ABTEI"],
    "markets": ["DE"],
    "includeMarketplaceOffers": True,
    "maxRowsPerSlice": 1000,
    "deltaStateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/pharmacy-price-monitor").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 '{
  "mode": "brand_watch",
  "brands": [
    "ABTEI"
  ],
  "markets": [
    "DE"
  ],
  "includeMarketplaceOffers": true,
  "maxRowsPerSlice": 1000,
  "deltaStateKey": "default"
}' |
apify call zhorex/pharmacy-price-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DE/AT Pharmacy Price & Stock Monitor",
        "description": "PZN-keyed OTC shelf data from Europe's largest online pharmacy (DE + AT): price, list-price breach, discount, availability and the marketplace seller undercutting the shop. Delta mode returns only price moves, RRP breaches and stock flips.",
        "version": "0.1",
        "x-build-id": "l8SyGetBMpZf4m1Wh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~pharmacy-price-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-pharmacy-price-monitor",
                "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/zhorex~pharmacy-price-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-pharmacy-price-monitor",
                "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/zhorex~pharmacy-price-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-pharmacy-price-monitor",
                "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": [
                            "brand_watch",
                            "pzn_watch",
                            "category_slice"
                        ],
                        "type": "string",
                        "description": "'Brand watch' pulls every article of a brand — the volume path, and how you map a competitor's whole range. 'PZN watch' takes the exact article numbers you own, which is what a brand or trade team actually monitors. 'Category slice' takes a raw index filter for analysts who want a whole segment.",
                        "default": "brand_watch"
                    },
                    "brands": {
                        "title": "Brands",
                        "type": "array",
                        "description": "Brand tokens, exact and case-insensitive (they are stored upper-case in the index): DOPPELHERZ, ABTEI, VOLTAREN, BEPANTHEN, NUROFEN, ASPIRIN. One request covers up to 1,000 articles of a brand, so a brand is one request, not one per article.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pzns": {
                        "title": "PZNs (article numbers)",
                        "type": "array",
                        "description": "Pharmazentralnummern to track, e.g. 17268563. The PZN is the German/Austrian pharmaceutical article number, so it joins the same article across storefronts and sellers with no name matching. Batched 40 per request.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterExpression": {
                        "title": "Filter expression (category-slice mode)",
                        "type": "string",
                        "description": "A raw index filter, e.g. `prescriptionMedicine:false AND marketplace:false` or `categoryCodes:...`. Note the result window: any single filter exposes at most 5,000 articles, so slice narrowly (per brand, per category) rather than trying to page through a whole catalogue."
                    },
                    "markets": {
                        "title": "Markets",
                        "type": "array",
                        "description": "DE (shop-apotheke.com) and/or AT (shop-apotheke.at). The same PZN is often priced differently in each, which is itself the signal for cross-border price-corridor work.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "DE"
                        ]
                    },
                    "includeMarketplaceOffers": {
                        "title": "Include marketplace seller offers",
                        "type": "boolean",
                        "description": "Adds the per-seller offer table for each article: how many sellers, the cheapest offer and who is making it, the price spread, and whether the shop's own price is being undercut. This is the answer to 'who is breaking my price', and it also recovers a reference price for articles where the storefront shows none. Costs one extra request per 40 articles.",
                        "default": false
                    },
                    "maxRowsPerSlice": {
                        "title": "Max articles per slice",
                        "minimum": 1,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Ceiling per brand / PZN batch / filter. The index only ever exposes the first 5,000 matches of a query, so values above that cannot be reached by paging — narrow the slice instead.",
                        "default": 5000
                    },
                    "deltaMode": {
                        "title": "Delta mode — only what CHANGED",
                        "type": "boolean",
                        "description": "Turn this on for a scheduled monitor. The first run records a baseline (billed at the ordinary row rate, not the alert rate); every later run returns and bills ONLY what moved: price up or down, a list-price breach opening or closing, and stock flips. Out-of-stock is only detectable this way — the search index has no stock filter at all, so availability changes can only be derived by comparing against stored state.",
                        "default": false
                    },
                    "deltaStateKey": {
                        "title": "Delta stream name",
                        "type": "string",
                        "description": "Names an independent delta stream so several monitors don't collide (e.g. 'my-brand-de' vs 'competitors-at'). Only used when Delta mode is on.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional — not required)",
                        "type": "object",
                        "description": "Not needed: the search endpoint answers ordinary datacenter IPs with no challenge and no rate limiting observed. Leave it off unless you specifically want your traffic routed.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
