# Shop Apotheke Scraper — European Online Pharmacy Products (`studio-amba/shopapotheke-scraper`) Actor

Scrape pharmacy products from Europe's largest online pharmacy. Supports 6 countries: Germany, Austria, France, Belgium, Italy, and Switzerland.

- **URL**: https://apify.com/studio-amba/shopapotheke-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Shop Apotheke Scraper

Scrape pharmaceutical products, prices, ratings, and medical details from Shop Apotheke — Europe's largest online pharmacy operating across 6 countries.

### What is Shop Apotheke Scraper?

Shop Apotheke (part of Redcare Pharmacy) is Europe's biggest online pharmacy, serving customers in Germany, Austria, Switzerland, Belgium, France, and Italy through localized storefronts. With millions of products ranging from prescription medicines to beauty care, it is the dominant player in European online pharmaceutical retail.

This scraper handles both search result pages and individual product detail pages, extracting rich pharmaceutical data including active substances, dosage forms, PZN numbers, and price-per-unit information that is critical for drug price comparison.

**Common use cases:**

- **Pan-European drug price comparison** — Compare medicine prices across 6 countries from a single actor, identifying regional pricing differences
- **Pharmaceutical competitive intelligence** — Track how Shop Apotheke prices OTC medicines against local pharmacies in each market
- **Medical product research** — Build datasets of active substances, dosage forms, and pack sizes for pharmaceutical analysis
- **E-pharmacy market monitoring** — Study the growth and pricing dynamics of Europe's largest online pharmacy
- **Health product sourcing** — Identify products with the best price-per-unit across different package sizes and formulations

### What data does Shop Apotheke Scraper extract?

- 💊 **Product name & manufacturer** — Full product name with pharmaceutical manufacturer
- 💰 **Price, original price & price-per-unit** — Current price, list/AVP price, and normalized unit price
- 🏥 **Pharmaceutical data** — Active substances, dosage form (tablets, capsules, cream, etc.), and pack size
- 📋 **PZN & EAN** — German Pharmazentralnummer and EAN barcode for precise product identification
- 📦 **Stock availability** — Whether the product is currently in stock
- ⭐ **Ratings & reviews** — Customer rating and review count
- 🗂️ **Category & breadcrumbs** — Product category extracted from breadcrumb navigation
- 🖼️ **Product images** — Primary product image URL
- 🌍 **6 country domains** — DE, AT, CH, BE, FR, IT

### How to scrape Shop Apotheke

Three approaches depending on your needs:

#### Search by keyword
Set `searchQuery` to any term — "ibuprofen", "vitamin d", "allergie" — and the scraper fetches matching results from the search page. Works in the language of the selected country.

#### Provide specific URLs
Use `startUrls` to pass category pages (e.g., `https://www.shop-apotheke.com/arzneimittel/schmerzmittel/`) or individual product URLs. The scraper auto-detects whether each URL is a listing page or a product detail page.

#### Select your country
Switch between six country stores with the `country` input: `de` (Germany), `at` (Austria), `ch` (Switzerland), `be` (Belgium), `fr` (France), or `it` (Italy). Each country has its own domain, language, and pricing.

#### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | `ibuprofen` | Search term (e.g., "paracetamol", "allergie") |
| `startUrls` | Array | — | Category or product URLs to scrape |
| `maxResults` | Integer | 100 | Maximum products to return (up to 10,000) |
| `country` | String | `de` | Country store: `de`, `at`, `ch`, `be`, `fr`, `it` |
| `proxyConfiguration` | Object | Apify Proxy | Proxy settings (recommended) |

**Tip:** When scraping the Belgian store (shop-pharmacie.be), set `country` to `be`. The domain and language automatically adjust to French.

### Output

```json
{
    "name": "Ibuprofen-ratiopharm 400 mg akut Schmerztabletten",
    "brand": "ratiopharm",
    "price": 4.29,
    "originalPrice": 6.97,
    "currency": "EUR",
    "sku": "IBUR400-50",
    "pzn": "00266040",
    "ean": "4047024662087",
    "inStock": true,
    "rating": 4.8,
    "reviewCount": 1847,
    "imageUrl": "https://www.shop-apotheke.com/images/ibuprofen-ratiopharm-400mg.jpg",
    "description": "Zur kurzzeitigen symptomatischen Behandlung von leichten bis maessig starken Schmerzen.",
    "category": "Arzneimittel > Schmerzmittel > Ibuprofen",
    "manufacturer": "ratiopharm GmbH",
    "activeSubstances": "Ibuprofen",
    "packSize": "50 St",
    "dosageForm": "Filmtabletten",
    "pricePerUnit": "0,09 EUR / St",
    "scrapedAt": "2026-04-03T10:15:00.000Z"
}
````

### How much does it cost?

The scraper uses a combination of Algolia SSR data extraction and Cheerio page parsing. Search result pages are efficient; individual product pages take slightly more resources.

| Volume | Estimated CU | Estimated Cost |
|--------|-------------|----------------|
| 100 products | ~0.05 CU | ~$0.03 |
| 500 products | ~0.2 CU | ~$0.10 |
| 1,000 products | ~0.4 CU | ~$0.20 |
| 5,000 products | ~2 CU | ~$1.00 |

Proxy usage increases costs slightly. Actual prices depend on your Apify plan.

### Can I integrate?

Yes. All standard Apify integrations work out of the box:

- **Google Sheets** — Push pharmacy product data directly into spreadsheets
- **Webhooks** — Get notified when a scrape completes or when specific conditions are met
- **Zapier / Make / n8n** — Build automated workflows connecting pharmacy data to your tools
- **Amazon S3 / Google Cloud** — Archive large pharmaceutical datasets in cloud storage
- **REST API** — Fetch results programmatically from any language or platform
- **Slack / Email alerts** — Monitor price drops on specific medications

### Can I use it as an API?

Yes. Run the scraper from your code and process results programmatically.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/shopapotheke-scraper").call(run_input={
    "searchQuery": "paracetamol",
    "country": "de",
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} — {item['dosageForm']} — EUR {item['price']} ({item.get('pricePerUnit', 'N/A')})")
```

#### JavaScript

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

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

const run = await client.actor('studio-amba/shopapotheke-scraper').call({
    searchQuery: 'paracetamol',
    country: 'de',
    maxResults: 100,
});

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

### FAQ

**Can I compare drug prices across countries?**
Yes. Run the scraper once per country (de, at, ch, be, fr, it) with the same search query, then compare the results. The PZN or EAN fields let you match the same product across different storefronts.

**What is a PZN number?**
The Pharmazentralnummer (PZN) is a unique 8-digit identifier for pharmaceutical products in Germany. It is the standard way to identify a specific medicine in a specific pack size and dosage form. The scraper extracts PZN when available.

**Does it scrape prescription-only medicines?**
The scraper extracts data for all products listed on Shop Apotheke, including prescription medicines. However, prescription medicines on Shop Apotheke typically show an AVP (pharmacy retail price) rather than a discounted price.

**How does Shop Apotheke differ from shop-pharmacie.be?**
They are the same company. The Belgian storefront operates under the domain shop-pharmacie.be with French-language content. Set `country` to `be` to scrape the Belgian version.

**Can I extract the full product description and ingredient list?**
For search results, you get a short description. For individual product pages (provided via `startUrls`), the scraper extracts the full JSON-LD product data including complete descriptions.

**What is the difference between price and originalPrice?**
`price` is the current selling price. `originalPrice` is the manufacturer's recommended retail price (UVP) or the official pharmacy retail price (AVP). The difference represents the discount Shop Apotheke offers.

**What volume of products does Shop Apotheke carry?**
The German store alone lists over 100,000 products, making it by far the largest online pharmacy in Europe. Product ranges include OTC medicines, prescription medicines, health supplements, baby care, beauty, personal hygiene, and medical devices. The Belgian and French stores have somewhat smaller catalogs but still cover the most popular pharmaceutical product categories.

### Tips for pharmaceutical data analysis

Shop Apotheke's rich pharmaceutical metadata enables powerful analysis workflows:

1. **Cross-country price arbitrage** — Run the scraper for the same product (matched by PZN or EAN) across all 6 countries. Medicine prices vary significantly between Germany, Austria, and Belgium.
2. **Generic vs. branded comparison** — Use the `activeSubstances` field to find all products containing the same active ingredient. Compare prices between branded originals (e.g., Nurofen) and generics (e.g., Ibuprofen-ratiopharm).
3. **Dosage form analysis** — The `dosageForm` field lets you segment by form factor: tablets, capsules, creams, syrups, drops. This is valuable for understanding consumer preferences and pricing by delivery method.
4. **Pack size optimization** — Combine `packSize` with `pricePerUnit` to find which package sizes offer the best value for specific medications.

### Limitations

- Shop Apotheke uses Next.js with server-side rendering; some Algolia data extraction depends on the page structure remaining stable
- Very large pagination runs (5,000+ results for a single search) may encounter rate limiting
- Product detail pages require more compute than search result extraction
- Proxy usage is recommended to avoid occasional blocks on high-volume scraping
- The Belgian and French stores may have slightly different page structures than the German store

### Other pharmacy scrapers

Building a comprehensive pharmacy data pipeline? Combine this scraper with our other pharmacy actors:

- [Farmaline Scraper](https://apify.com/studio-amba/farmaline-scraper) — Belgium's largest online pharmacy (70,000+ products, bilingual NL/FR)
- [dm Scraper](https://apify.com/studio-amba/dm-scraper) — Germany's largest drugstore chain (beauty, health, household)
- [Viata Scraper](https://apify.com/studio-amba/viata-scraper) — Belgian online pharmacy with health and wellness products
- [Apotheek.be Scraper](https://apify.com/studio-amba/apotheek-scraper) — Belgian pharmacy directory with locations and opening hours
- [Matas Scraper](https://apify.com/studio-amba/matas-scraper) — Denmark's leading beauty and pharmacy retailer
- [Multipharma Scraper](https://apify.com/studio-amba/multipharma-scraper) — One of Belgium's largest pharmacy chains

### Your feedback

Have questions about pharmaceutical data extraction? Found an issue with a specific country store? Need help matching products across pharmacies? [Open an issue](https://console.apify.com/actors/studio-amba/shopapotheke-scraper/issues) or message us on Apify. We actively maintain all our pharmacy scrapers.

# Actor input Schema

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

Search term to find products (e.g., 'ibuprofen', 'vitamin d', 'shampoo')

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

Category or product URLs to scrape. Overrides search query if provided.

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

Maximum number of products to scrape

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

Country store to scrape (affects domain and language)

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

Apify proxy configuration

## Actor input object example

```json
{
  "searchQuery": "ibuprofen",
  "startUrls": [],
  "maxResults": 100,
  "country": "de",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "ibuprofen",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/shopapotheke-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "ibuprofen",
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/shopapotheke-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "ibuprofen",
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/shopapotheke-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shop Apotheke Scraper — European Online Pharmacy Products",
        "description": "Scrape pharmacy products from Europe's largest online pharmacy. Supports 6 countries: Germany, Austria, France, Belgium, Italy, and Switzerland.",
        "version": "0.1",
        "x-build-id": "q48SBfhfIYR05PETD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~shopapotheke-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-shopapotheke-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~shopapotheke-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-shopapotheke-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~shopapotheke-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-shopapotheke-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find products (e.g., 'ibuprofen', 'vitamin d', 'shampoo')"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Category or product URLs to scrape. Overrides search query if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to scrape",
                        "default": 100
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "de",
                            "at",
                            "fr",
                            "be",
                            "it",
                            "ch"
                        ],
                        "type": "string",
                        "description": "Country store to scrape (affects domain and language)",
                        "default": "de"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
