# Action Scraper — European Discount Store Products & Prices (`studio-amba/action-scraper`) Actor

Scrape product data from Action.com — the European discount chain with 2,500+ stores across 12 countries. Fast extraction via Next.js RSC payload parsing.

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

## Pricing

from $4.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

## Action Scraper -- Europe's Biggest Discount Retailer at Your Fingertips

Scrape products, prices, deals, and availability from Action.com across 16 European locales. From household essentials to seasonal bargains, extract Action's entire catalog of affordable goods in structured JSON.

### What is Action Scraper?

Action is Europe's fastest-growing non-food discount retailer, operating over 2,500 stores in 12 countries. Their product range rotates constantly, with new items arriving weekly at rock-bottom prices. This scraper gives you programmatic access to that data.

Here's what people use it for:

- **Price monitoring at scale** -- Track Action's notoriously volatile pricing across Belgium, Netherlands, France, Germany, and 12 other markets. Spot when your competitor's products drop below the euro threshold.
- **Product discovery** -- Action's assortment changes weekly. Automated scraping catches new arrivals before they sell out, whether you're a reseller, a deal blogger, or just curious.
- **Cross-border price comparison** -- The same item can cost differently in Action Belgium vs Action France. Compare prices across all 16 locales in a single run.
- **Discount & deal tracking** -- Action's "deals" and "new arrivals" rotate fast. Build alerts for specific categories or price drops.
- **Retail competitive intelligence** -- If you sell household goods, DIY supplies, or seasonal items, Action's pricing sets the floor. Know what that floor is.

### What data does Action Scraper extract?

Every product comes with a rich set of fields:

- 🏷️ **Product name** and description
- 💰 **Current price** and original price (when on sale)
- 📊 **Price per unit** (e.g., "EUR 0.50/L")
- 🏪 **Stock status** -- in stock or not
- 🆕 **New arrival flag** -- freshly added items
- 🔥 **Deal flag** -- currently discounted
- 🖼️ **Product images** -- main image + all gallery images
- 📂 **Category breadcrumbs** -- full category hierarchy
- 🔢 **SKU and product ID** -- unique identifiers
- 💱 **Currency** -- EUR for most markets
- 🌍 **Language/locale** -- which country site the data came from

### How to scrape Action.com

The scraper supports three input modes. Pick the one that fits your use case.

#### Search by keyword

Find products matching a search term. Good for targeted extraction.

```json
{
    "searchQuery": "lamp",
    "locale": "nl-be",
    "maxResults": 50
}
````

#### Browse by category or product URL

Pass one or more Action.com URLs -- category pages or individual product pages.

```json
{
    "startUrls": [
        { "url": "https://www.action.com/nl-be/c/wonen/verlichting/" }
    ],
    "maxResults": 200
}
```

#### Full catalog scrape

Enable `scrapeFullCatalog` to grab every product from the sitemap. Action carries roughly 5,500 products per locale. This ignores `startUrls` and `searchQuery`.

```json
{
    "scrapeFullCatalog": true,
    "locale": "nl-nl",
    "maxResults": 5500
}
```

#### Locale options

Action operates in 16 locales. Set the `locale` field to target a specific country:

| Locale | Country |
|--------|---------|
| `nl-be` | Belgium (Dutch) |
| `fr-be` | Belgium (French) |
| `nl-nl` | Netherlands |
| `fr-fr` | France |
| `de-de` | Germany |
| `de-at` | Austria |
| `pl-pl` | Poland |
| `cs-cz` | Czech Republic |
| `es-es` | Spain |
| `it-it` | Italy |
| `fr-lu` | Luxembourg |
| `pt-pt` | Portugal |
| `sk-sk` | Slovakia |
| `ro-ro` | Romania |
| `hr-hr` | Croatia |
| `de-ch` / `fr-ch` | Switzerland |

**Tip:** Run the same search across multiple locales to compare regional pricing. Action's assortment and pricing vary significantly between countries.

### Output

Each product is returned as a JSON object. Here is a realistic example from Action Belgium:

```json
{
    "name": "LED bureaulamp met flexibele arm",
    "brand": "",
    "price": 4.29,
    "currency": "EUR",
    "url": "https://www.action.com/nl-be/p/3254891/led-bureaulamp-met-flexibele-arm/",
    "scrapedAt": "2025-04-03T10:30:00.000Z",
    "originalPrice": 5.95,
    "pricePerUnit": "EUR 4,29/stuk",
    "sku": "3254891",
    "productId": "prod-3254891",
    "inStock": true,
    "isNew": false,
    "isDeal": true,
    "imageUrl": "https://asset.action.com/image/upload/t_digital_product_image/w_640/led-bureaulamp.webp",
    "imageUrls": [
        "https://asset.action.com/image/upload/t_digital_product_image/w_640/led-bureaulamp.webp",
        "https://asset.action.com/image/upload/t_digital_product_image/w_640/led-bureaulamp-2.webp"
    ],
    "description": "Handige LED bureaulamp met flexibele arm en USB-aansluiting. Geschikt voor op kantoor of in de slaapkamer.",
    "category": "Wonen > Verlichting",
    "categories": ["Wonen", "Verlichting", "LED bureaulamp met flexibele arm"],
    "language": "nl"
}
```

### How much does it cost?

Action Scraper runs on the Apify platform. You pay only for compute and proxy usage.

| Scenario | Estimated cost |
|----------|---------------|
| 100 products (search or category) | ~$0.01 |
| 500 products (multiple categories) | ~$0.03 |
| Full catalog (~5,500 products) | ~$0.25 |
| Full catalog + proxy | ~$0.50 |

The scraper uses CheerioCrawler (no browser needed), so compute costs stay minimal. Proxy is optional but recommended for large runs.

### Can I integrate?

Apify integrates natively with the tools you already use:

- **Google Sheets** -- push scraped data directly into a spreadsheet
- **Webhooks** -- trigger your pipeline when a run finishes
- **Zapier / Make** -- connect Action data to 5,000+ apps
- **Slack** -- get notified about new deals or price drops
- **Amazon S3 / Google Cloud Storage** -- export datasets to cloud storage
- **PostgreSQL / MySQL** -- store results in your own database

### Can I use it as an API?

Yes. Call Action Scraper programmatically from any language.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/action-scraper").call(run_input={
    "searchQuery": "stofzuiger",
    "locale": "nl-be",
    "maxResults": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} -- EUR {item['price']}")
```

#### JavaScript

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

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

const run = await client.actor('studio-amba/action-scraper').call({
    searchQuery: 'stofzuiger',
    locale: 'nl-be',
    maxResults: 25,
});

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

### FAQ

**Does this scraper work without a proxy?**
Yes. Action.com is accessible via got-scraping's TLS fingerprinting without a proxy. However, for full catalog scrapes or high-frequency runs, a proxy improves reliability.

**How often does Action update their product catalog?**
Action adds new products weekly and rotates seasonal items frequently. Running the scraper daily or weekly captures most changes.

**Can I scrape multiple countries in one run?**
The `locale` field applies to a single run. To compare across countries, run the scraper once per locale. You can orchestrate this with the Apify API or scheduler.

**What happens if a product is out of stock?**
Out-of-stock products still appear in results with `inStock: false`. This is useful for tracking availability over time.

**Does the scraper handle pagination automatically?**
Yes. For search and category pages, pagination is followed automatically until `maxResults` is reached.

**Why are some product descriptions empty?**
Action's category and search pages include product data via React Server Components. Not all fields are present in the RSC payload. For full descriptions, the scraper falls back to product detail pages when using the sitemap mode.

### Limitations

- Action.com uses Cloudflare protection. While the scraper handles this via TLS fingerprinting, very aggressive scraping patterns may trigger rate limiting.
- Product availability data reflects online stock, not individual store inventory.
- Some fields (like `pricePerUnit`) are only available for certain product types.
- The `scrapeFullCatalog` mode scrapes from the sitemap and fetches individual product pages, which takes longer than category or search scraping.

### Other retail and fashion scrapers

Looking for data from other European retailers? Check out these scrapers from our collection:

- [Mytheresa Scraper](https://apify.com/studio-amba/mytheresa-scraper) -- Luxury fashion products and prices
- [Rituals Scraper](https://apify.com/studio-amba/rituals-scraper) -- Premium cosmetics and home fragrance
- [Kruidvat Scraper](https://apify.com/studio-amba/kruidvat-scraper) -- Drugstore, beauty, and health products
- [ICI PARIS XL Scraper](https://apify.com/studio-amba/iciparisxl-scraper) -- Belgian beauty and perfume retailer
- [AS Adventure Scraper](https://apify.com/studio-amba/asadventure-scraper) -- Outdoor and adventure gear
- [Bergfreunde Scraper](https://apify.com/studio-amba/bergfreunde-scraper) -- Climbing and hiking equipment
- [Intersport Scraper](https://apify.com/studio-amba/intersport-scraper) -- European sports retail
- [Helly Hansen Scraper](https://apify.com/studio-amba/hellyhansen-scraper) -- Outdoor and sailing apparel

### Your feedback

Found a bug? Missing a field? Want a feature? Open an issue on the actor's page or reach out through the Apify platform. We actively maintain this scraper and ship fixes fast.

# Actor input Schema

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

Category or product URLs from action.com. Example: https://www.action.com/nl-be/c/wonen/verlichting/ or https://www.action.com/nl-be/p/3220586/letterponsbord/

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

Search for products by keyword (e.g., 'lamp', 'stofzuiger'). Uses the site's search functionality.

## `locale` (type: `string`):

Which Action country site to scrape. Determines language and product availability.

## `scrapeFullCatalog` (type: `boolean`):

If enabled, scrapes all products from the sitemap (~5500 products). Ignores startUrls and searchQuery.

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

Maximum number of products to return.

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

Proxy settings. Action.com works without proxy via got-scraping, but proxy improves reliability at scale.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.action.com/nl-be/c/wonen/verlichting/"
    }
  ],
  "locale": "nl-be",
  "scrapeFullCatalog": false,
  "maxResults": 100
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.action.com/nl-be/c/wonen/verlichting/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/action-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 = { "startUrls": [{ "url": "https://www.action.com/nl-be/c/wonen/verlichting/" }] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/action-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 '{
  "startUrls": [
    {
      "url": "https://www.action.com/nl-be/c/wonen/verlichting/"
    }
  ]
}' |
apify call studio-amba/action-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Action Scraper — European Discount Store Products & Prices",
        "description": "Scrape product data from Action.com — the European discount chain with 2,500+ stores across 12 countries. Fast extraction via Next.js RSC payload parsing.",
        "version": "0.1",
        "x-build-id": "HoJyz6NXzDLsUZSxe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~action-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-action-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~action-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-action-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~action-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-action-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Category or product URLs from action.com. Example: https://www.action.com/nl-be/c/wonen/verlichting/ or https://www.action.com/nl-be/p/3220586/letterponsbord/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'lamp', 'stofzuiger'). Uses the site's search functionality."
                    },
                    "locale": {
                        "title": "Country / Language",
                        "enum": [
                            "nl-be",
                            "fr-be",
                            "nl-nl",
                            "fr-fr",
                            "de-de",
                            "de-at",
                            "pl-pl",
                            "cs-cz",
                            "es-es",
                            "it-it",
                            "fr-lu",
                            "pt-pt",
                            "sk-sk",
                            "ro-ro",
                            "hr-hr",
                            "de-ch",
                            "fr-ch"
                        ],
                        "type": "string",
                        "description": "Which Action country site to scrape. Determines language and product availability.",
                        "default": "nl-be"
                    },
                    "scrapeFullCatalog": {
                        "title": "Scrape Full Catalog",
                        "type": "boolean",
                        "description": "If enabled, scrapes all products from the sitemap (~5500 products). Ignores startUrls and searchQuery.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Action.com works without proxy via got-scraping, but proxy improves reliability at scale."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```