# Farmaline Scraper — Belgian Online Pharmacy Products (`studio-amba/farmaline-scraper`) Actor

Scrape 70,000+ products from Farmaline.be (Redcare Pharmacy) — Belgium's largest online pharmacy. OTC medicines, supplements, skincare, and baby care.

- **URL**: https://apify.com/studio-amba/farmaline-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 5 total users, 0 monthly users, 97.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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

## Farmaline Scraper

Extract product data, prices, stock levels, and pharmaceutical details from Belgium's largest online pharmacy with over 70,000 products.

### What is Farmaline Scraper?

Farmaline.be is Belgium's biggest online pharmacy, offering over 70,000 health, beauty, and wellness products. Now part of the Redcare Pharmacy group, it serves millions of customers across the Benelux region. This scraper gives you structured access to their entire catalog through Farmaline's internal search API, delivering fast and reliable results without browser emulation.

Whether you are building a pharmacy price comparison engine, tracking health product trends across the Belgian market, or conducting pharmaceutical research, this actor provides the data foundation you need.

**Common use cases:**

- **Pharmacy price comparison** — Compare OTC drug prices across Belgian pharmacies to find the best deals for consumers
- **Stock monitoring** — Track availability of specific medications and supplements and get notified when they come back in stock
- **Pharmaceutical market research** — Analyze pricing strategies, discount patterns, and product ranges across categories like supplements, skincare, and OTC medicines
- **Competitor intelligence** — Monitor how Farmaline prices its catalog versus other Belgian pharmacies like Multipharma or Viata
- **Health product analytics** — Study trends in dosage forms, active substances, and brand popularity in the Belgian pharmacy market

### What data does Farmaline Scraper extract?

- 💊 **Product name & brand** — Full product name and manufacturer
- 💰 **Current price & original price** — Including discount percentage and price-per-unit for accurate comparison
- 🏥 **Pharmaceutical details** — Dosage form, package size, active substances, and prescription status
- 📊 **Ratings & reviews** — Average customer rating and review count
- 📦 **Stock status** — Real-time availability information
- 🏷️ **Identifiers** — EAN barcode, SKU, and internal product ID
- 🗂️ **Categories** — Full category hierarchy (e.g., Geneesmiddelen > Pijn en koorts)
- 🌐 **Bilingual support** — Data available in both Dutch (NL) and French (FR)
- 🖼️ **Product images** — Direct image URLs

### How to scrape Farmaline.be

The scraper supports three main approaches:

#### Search by keyword
Enter a search term like "dafalgan", "vitamine D", or "zonnebrandcreme" to find matching products. This works exactly like the search bar on Farmaline.be.

#### Browse by category
Use the **Category** field with Farmaline's internal category names: `Geneesmiddelen`, `Supplementen`, `Beauty & Lichaamsverzorging`, or `Mama & Kind`.

#### Filter by brand
Set the **Brand** field to a specific manufacturer like `Dafalgan`, `Bioderma`, `Eucerin`, or `Metagenics` to get all products from that brand.

You can combine category and brand filters with a search query for precise results. The **Language** toggle switches between Dutch and French product data.

#### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | — | Search term (e.g., "paracetamol") |
| `category` | String | — | Category filter (e.g., "Geneesmiddelen") |
| `brand` | String | — | Brand filter (e.g., "Eucerin") |
| `maxResults` | Integer | 100 | Maximum products to return (up to 70,000) |
| `language` | String | `nl` | `nl` for Dutch, `fr` for French |
| `proxyConfiguration` | Object | — | Proxy settings for large runs |

**Tip:** Leave all filters empty and set `maxResults` to a high number to scrape the entire Farmaline catalog.

### Output

```json
{
    "name": "Dafalgan Forte 1g Filmomhulde Tabletten 30 Stuks",
    "brand": "Dafalgan",
    "price": 7.49,
    "originalPrice": 9.50,
    "discount": "-21%",
    "pricePerUnit": "0,25 EUR/stuk",
    "currency": "EUR",
    "ean": "5400265041640",
    "sku": "DAF-1G-30",
    "productId": "4164012",
    "inStock": true,
    "rating": 4.7,
    "reviewCount": 238,
    "url": "https://www.farmaline.be/nl/artikel/dafalgan-forte-1g-30-tabletten",
    "imageUrl": "https://www.farmaline.be/images/products/dafalgan-forte-1g-30.jpg",
    "description": "Dafalgan Forte 1g bevat paracetamol en wordt gebruikt voor de symptomatische behandeling van pijn en koorts.",
    "specs": {
        "Dosage Form": "Filmomhulde tabletten",
        "Package Size": "30 stuks",
        "Active Substances": "Paracetamol",
        "Prescription Required": "No"
    },
    "category": "Pijn en koorts",
    "categories": ["Geneesmiddelen", "Pijn en koorts", "Paracetamol"],
    "language": "nl",
    "scrapedAt": "2026-04-03T10:15:00.000Z"
}
````

### How much does it cost?

This actor hits Farmaline's internal Algolia search API directly, making it extremely fast and efficient. No browser rendering is needed.

| Volume | Estimated CU | Estimated Cost |
|--------|-------------|----------------|
| 100 products | ~0.01 CU | < $0.01 |
| 1,000 products | ~0.05 CU | ~$0.03 |
| 10,000 products | ~0.4 CU | ~$0.20 |
| 70,000 products (full catalog) | ~3 CU | ~$1.50 |

Costs depend on your Apify subscription plan. The actor is free to try on Apify's free tier.

### Can I integrate?

Yes. Export scraped data in any format (JSON, CSV, Excel, XML) or connect directly to your pipeline:

- **Google Sheets** — Auto-sync pharmacy prices to a spreadsheet
- **Webhooks** — Trigger your own API when a scrape finishes
- **Zapier / Make** — Connect to 5,000+ apps without code
- **Amazon S3 / Google Cloud Storage** — Store large datasets in the cloud
- **Slack / Email** — Get notified when prices drop or stock changes

### Can I use it as an API?

Absolutely. Call the actor programmatically and get structured pharmacy data back.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/farmaline-scraper").call(run_input={
    "searchQuery": "ibuprofen",
    "maxResults": 50,
    "language": "nl",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} — 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/farmaline-scraper').call({
    searchQuery: 'ibuprofen',
    maxResults: 50,
    language: 'nl',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.name} — EUR ${item.price} (${item.pricePerUnit || 'N/A'})`);
});
```

### FAQ

**Can I scrape prescription medicines?**
The scraper returns data for all products listed on Farmaline, including prescription-only medicines. The `specs.Prescription Required` field tells you whether a product needs a prescription. Note that prescription medicines cannot be purchased online in Belgium — Farmaline lists them for information purposes only.

**Does the scraper work in both Dutch and French?**
Yes. Set the `language` input to `nl` (Dutch) or `fr` (French). Product names, descriptions, and categories are fully localized. Both languages return the same products.

**How often does pricing data update?**
Farmaline updates prices in their Algolia index in near real-time. The data you scrape reflects the current live prices on the website.

**Can I get the price-per-unit for comparison?**
Yes. The `pricePerUnit` field contains the per-unit price (e.g., "0,25 EUR/stuk" or "7,49 EUR/100ml"), which is essential for comparing products with different package sizes.

**What is the maximum number of products I can scrape?**
Farmaline's catalog contains approximately 70,000 products. You can scrape the entire catalog in a single run by setting `maxResults` to 70000.

**Does the actor handle rate limits?**
Yes. Built-in retry logic handles temporary API errors. For very large runs (50,000+ products), enabling proxy rotation is recommended.

**What product categories does Farmaline cover?**
Farmaline's catalog includes: Geneesmiddelen (medicines), Supplementen (supplements), Beauty & Lichaamsverzorging (beauty and body care), Mama & Kind (mother and child), Dier (pet care), Voeding (nutrition), and more. The `categories` field in the output gives you the full category hierarchy for each product.

### Tips for pharmacy price comparison

If you are building a Belgian pharmacy price comparison tool, here is how to get the most value from Farmaline data:

1. **Use EAN codes as the join key** — The `ean` field is the universal product identifier. Match Farmaline products to the same products on Viata, Multipharma, or Shop Apotheke using EAN.
2. **Normalize with price-per-unit** — A box of 30 tablets and a box of 100 tablets are different products but treat the same condition. The `pricePerUnit` field lets you compare apples to apples.
3. **Track discounts over time** — Farmaline runs frequent promotions. Schedule daily runs and store the `discount` and `originalPrice` fields to build a historical pricing database.
4. **Filter by active substance** — Use the `specs.Active Substances` field to group products by what they actually contain (e.g., all paracetamol products regardless of brand).

### Limitations

- Farmaline occasionally changes their Algolia API keys, which may require actor updates
- Product descriptions are sometimes truncated in the search API — detail page scraping would be needed for full descriptions
- Review text content is not included (only aggregate rating and count)
- Some product images may require HTTPS prefix adjustment
- Data reflects the Belgian market only (farmaline.be)

### Other pharmacy scrapers

Looking for pharmacy data from other sources? Check out our complete pharmacy scraper collection:

- [dm Scraper](https://apify.com/studio-amba/dm-scraper) — Germany's largest drugstore chain (beauty, health, household)
- [Shop Apotheke Scraper](https://apify.com/studio-amba/shopapotheke-scraper) — Europe's leading online pharmacy (DE/AT/CH/BE/FR/IT)
- [Viata Scraper](https://apify.com/studio-amba/viata-scraper) — Belgian online pharmacy with wellness and beauty 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

We continuously improve our scrapers. If you encounter issues, have feature requests, or need help integrating Farmaline data into your workflow, please [open an issue](https://console.apify.com/actors/studio-amba/farmaline-scraper/issues) or reach out through the Apify platform. Your feedback helps us build better tools.

# Actor input Schema

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

Search for products by name or keyword (e.g., 'dafalgan', 'vitamine D', 'zonnebrandcrème'). Leave empty to browse by category or scrape everything.

## `category` (type: `string`):

Filter by product category using the Algolia primaryCategory facet (e.g., 'Geneesmiddelen', 'Supplementen', 'Beauty & Lichaamsverzorging', 'Mama & Kind'). Leave empty for all categories.

## `brand` (type: `string`):

Filter by brand/manufacturer (e.g., 'Dafalgan', 'Bioderma', 'Eucerin', 'Metagenics', 'A.Vogel'). Leave empty for all brands.

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

Maximum number of products to return.

## `language` (type: `string`):

Language for product data. Dutch and French return the same products with localized names and descriptions.

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

Proxy settings. Not strictly required for this site, but recommended for very large runs.

## Actor input object example

```json
{
  "maxResults": 100,
  "language": "nl"
}
```

# Actor output Schema

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/farmaline-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/farmaline-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 '{}' |
apify call studio-amba/farmaline-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Farmaline Scraper — Belgian Online Pharmacy Products",
        "description": "Scrape 70,000+ products from Farmaline.be (Redcare Pharmacy) — Belgium's largest online pharmacy. OTC medicines, supplements, skincare, and baby care.",
        "version": "0.1",
        "x-build-id": "J7CjSbBk49QJd9Dkz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~farmaline-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-farmaline-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~farmaline-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-farmaline-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~farmaline-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-farmaline-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 for products by name or keyword (e.g., 'dafalgan', 'vitamine D', 'zonnebrandcrème'). Leave empty to browse by category or scrape everything."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter by product category using the Algolia primaryCategory facet (e.g., 'Geneesmiddelen', 'Supplementen', 'Beauty & Lichaamsverzorging', 'Mama & Kind'). Leave empty for all categories."
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Filter by brand/manufacturer (e.g., 'Dafalgan', 'Bioderma', 'Eucerin', 'Metagenics', 'A.Vogel'). Leave empty for all brands."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 70000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "nl",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for product data. Dutch and French return the same products with localized names and descriptions.",
                        "default": "nl"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Not strictly required for this site, but recommended for very large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
