# Resto.be Scraper — Belgian Restaurant Data & Reviews (`studio-amba/resto-scraper`) Actor

Scrape restaurant data from Resto.be — names, addresses, cuisine types, ratings, Michelin stars, Gault\&Millau scores, and opening hours for Belgian restaurants.

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

## Pricing

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

## Resto.be Scraper -- Belgian Restaurants, Michelin Stars & Gault Millau Scores

Scrape restaurant listings from [Resto.be](https://www.resto.be) -- Belgium's largest restaurant guide featuring over 20,000 restaurants with ratings, cuisine types, Michelin stars, Gault Millau scores, contact details, opening hours, and payment information.

### What is Resto.be Scraper?

Resto.be is Belgium's most comprehensive restaurant directory. It covers the entire country -- from Michelin-starred fine dining in Brussels to neighbourhood bistros in Namur and frituren in Ostend. What makes Resto.be valuable is its combination of user ratings with professional guide scores: Michelin stars and Gault Millau points are displayed alongside consumer reviews, creating the most complete picture of Belgian dining available anywhere.

This actor scrapes restaurant detail pages, extracting structured data from both JSON-LD markup and HTML parsing. It supports pagination through city and region listing pages to collect data at scale. What people build with it:

- **Restaurant market intelligence** -- food industry suppliers, real estate developers, and franchise operators analyse the Belgian restaurant landscape by city, cuisine type, and quality tier to identify market gaps and expansion opportunities.
- **Fine dining databases** -- luxury travel platforms and concierge services build curated databases of Michelin and Gault Millau rated restaurants across Belgium.
- **Competitive analysis** -- restaurant owners and restaurant groups benchmark themselves against nearby competitors on ratings, pricing, and cuisine offerings.
- **Food tourism planning** -- tour operators and travel agencies build Belgian gastronomic itineraries using restaurant locations, cuisine types, and quality ratings.
- **Data journalism** -- journalists and researchers analyse patterns in Belgian dining -- which cities have the most Michelin stars, how cuisines distribute across regions, where new restaurants concentrate.

### What data does Resto.be Scraper extract?

Each restaurant record includes:

- :fork_and_knife: **Name** -- the restaurant name
- :house: **Address** -- street address, postal code, and city
- :world_map: **Coordinates** -- latitude and longitude for mapping
- :telephone: **Phone** -- contact number
- :globe_with_meridians: **Website** -- the restaurant's own website URL
- :stew: **Cuisine types** -- array of cuisine categories (Belgisch, Frans, Italiaans, Japans, etc.)
- :money_with_wings: **Price range** -- price category indicator
- :star: **Rating** -- consumer rating score
- :writing_hand: **Review count** -- number of user reviews
- :medal: **Michelin stars** -- 1, 2, or 3 Michelin stars when applicable
- :trophy: **Gault Millau score** -- score out of 20 from the Gault Millau guide
- :credit_card: **Payment methods** -- accepted payment options
- :sparkles: **Features** -- amenities and services (terrace, parking, private dining, etc.)
- :clock1: **Opening hours** -- structured by day of week
- :memo: **Description** -- the restaurant's profile text
- :framed_picture: **Image** -- main restaurant photo

### How to scrape Belgian restaurants

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `startUrls` | Array | No | City or region listing pages, e.g. `https://www.resto.be/restaurant/bruxelles` |
| `searchQuery` | String | No | City name or cuisine: `"bruxelles"`, `"gent"`, `"italian"` |
| `maxResults` | Integer | No | Maximum restaurants to return (default: 100, max: 50,000) |
| `language` | String | No | `"fr"` (default, www.resto.be), `"nl"` (nl.resto.be), `"en"` (en.resto.be) |
| `proxyConfiguration` | Object | No | Proxy settings (recommended for 1,000+ restaurants) |

**Tips:**

- Start with a specific city for focused results: `searchQuery: "bruxelles"` or `searchQuery: "gent"`.
- For a complete Belgian restaurant database, run multiple times with different cities or set a high `maxResults` from the main listing page.
- Use `language: "nl"` for Dutch-language descriptions and cuisine names, `"fr"` for French.
- The actor handles pagination automatically via the `window.RESTO.pager` data or "suivant/volgende" links.

### Output

```json
{
    "name": "Comme Chez Soi",
    "address": "Place Rouppe 23",
    "city": "Bruxelles",
    "postalCode": "1000",
    "latitude": 50.8432,
    "longitude": 4.3465,
    "phone": "+32 2 512 29 21",
    "website": "https://www.commechezsoi.be",
    "cuisine": ["Gastronomique", "Francaise", "Belge"],
    "priceRange": "$$$$",
    "rating": 9.2,
    "reviewCount": 187,
    "michelinStars": 2,
    "gaultMillauScore": 18.5,
    "paymentMethods": ["Visa", "Mastercard", "American Express"],
    "features": ["Terras", "Parking", "Prive-eetruimte"],
    "openingHours": {
        "Dinsdag": "12:00-14:00, 19:00-22:00",
        "Woensdag": "12:00-14:00, 19:00-22:00",
        "Donderdag": "12:00-14:00, 19:00-22:00",
        "Vrijdag": "12:00-14:00, 19:00-22:00",
        "Zaterdag": "19:00-22:00"
    },
    "description": "Comme Chez Soi is een legendarisch Brusselse gastronomische adres in art nouveau stijl...",
    "imageUrl": "https://www.resto.be/media/restaurants/comme-chez-soi.jpg",
    "restoId": "12345",
    "url": "https://www.resto.be/restaurant/bruxelles/1000-centre/12345-comme-chez-soi",
    "language": "fr",
    "scrapedAt": "2026-04-03T13:00:00.000Z"
}
````

### How much does it cost?

Resto.be Scraper uses CheerioCrawler (no browser needed):

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 restaurants | ~0.03 | ~$0.015 |
| 500 restaurants | ~0.12 | ~$0.06 |
| 1,000 restaurants | ~0.25 | ~$0.13 |
| 5,000 restaurants | ~1.10 | ~$0.55 |

The actor first collects restaurant URLs from listing pages, then visits each detail page. Costs scale linearly.

### Can I integrate?

Push Belgian restaurant data into your tools:

- **Google Sheets** -- build a sortable restaurant database filtered by Michelin stars, city, or cuisine
- **Google Maps / Mapbox** -- plot restaurants on an interactive map using coordinates
- **Slack** -- weekly digest of newly added or updated restaurants in your city
- **Zapier / Make** -- trigger workflows when new Michelin-starred restaurants appear
- **PostgreSQL / MongoDB** -- feed a searchable restaurant API for your app
- **Power BI / Tableau** -- visualise the Belgian dining landscape by region and quality tier

### Can I use it as an API?

Yes. Build Belgian gastronomy intelligence into your product:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/resto-scraper").call(run_input={
    "searchQuery": "bruxelles",
    "language": "fr",
    "maxResults": 500,
})

for restaurant in client.dataset(run["defaultDatasetId"]).iterate_items():
    stars = f" {'*' * restaurant['michelinStars']}" if restaurant.get('michelinStars') else ""
    print(f"{restaurant['name']}{stars} - {', '.join(restaurant.get('cuisine', []))}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/resto-scraper").call({
    searchQuery: "gent",
    language: "nl",
    maxResults: 300,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const starred = items.filter((r) => r.michelinStars > 0);
console.log(`Found ${starred.length} Michelin-starred restaurants in Gent`);
starred.forEach((r) => console.log(`  ${"*".repeat(r.michelinStars)} ${r.name}`));
```

### FAQ

**Does Resto.be cover all of Belgium?**
Yes. Resto.be covers Brussels, Flanders, and Wallonia. It is the most comprehensive Belgian restaurant directory available.

**Are Michelin stars and Gault Millau scores always present?**
Only for restaurants that have received these awards. The vast majority of restaurants will not have Michelin or Gault Millau data. The fields are only present when applicable.

**How accurate is the data?**
Resto.be data is maintained by restaurant owners and the platform team. Like any directory, some entries may be outdated (closed restaurants, changed hours). The `rating` and `reviewCount` reflect current platform data.

**Can I filter by Michelin stars only?**
Not as an input filter, but every result includes the `michelinStars` field. Scrape a city and filter the output for `michelinStars > 0`.

**Is there duplicate data between language versions?**
The same restaurants appear on www.resto.be (French), nl.resto.be (Dutch), and en.resto.be (English) with translated descriptions but the same underlying data.

**What is the `restoId` field?**
A numeric identifier extracted from the URL, useful for deduplication when scraping multiple cities or language versions.

### Limitations

- Some restaurant detail pages may not have JSON-LD structured data, falling back to less precise HTML parsing.
- Opening hours and payment methods depend on whether the restaurant owner has kept their Resto.be profile up to date.
- Gault Millau scores are extracted from page content with pattern matching. Unusual formatting may be missed.
- Large city scrapes (all of Brussels, all of Antwerp) require proxy configuration to avoid rate limiting.
- The actor does not extract individual user reviews -- only aggregate ratings and review counts.

### Related Belgian and food scrapers

- [HelloFresh Scraper](https://apify.com/studio-amba/hellofresh-scraper) -- Belgian meal kit recipes, ingredients, and nutrition data
- [UiTinVlaanderen Scraper](https://apify.com/studio-amba/uitinvlaanderen-scraper) -- Flemish cultural events (food festivals, culinary events)
- [VDAB Scraper](https://apify.com/studio-amba/vdab-scraper) -- Flemish job listings (restaurant industry hiring)
- [NMBS Scraper](https://apify.com/studio-amba/nmbs-scraper) -- train connections to reach restaurants across Belgium

### Your feedback

Want to track restaurant openings and closings, need individual review text, or found a parsing issue? Open an issue on GitHub or contact us through the Apify platform. We prioritise improvements based on user demand.

# Actor input Schema

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

Resto.be city or region listing pages to scrape. Example: https://www.resto.be/restaurant/bruxelles or https://nl.resto.be/restaurant/gent

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

Search by city name or cuisine type (e.g., 'bruxelles', 'gent', 'italian'). Used to build listing URLs if no startUrls provided.

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

Maximum number of restaurants to return.

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

Language for restaurant data. French uses www.resto.be, Dutch uses nl.resto.be, English uses en.resto.be.

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

Proxy settings. Recommended for scraping more than 1,000 restaurants.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.resto.be/restaurant/bruxelles"
    }
  ],
  "maxResults": 100,
  "language": "fr"
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.resto.be/restaurant/bruxelles"
        }
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resto.be Scraper — Belgian Restaurant Data & Reviews",
        "description": "Scrape restaurant data from Resto.be — names, addresses, cuisine types, ratings, Michelin stars, Gault&Millau scores, and opening hours for Belgian restaurants.",
        "version": "0.1",
        "x-build-id": "dulCxaLbSCnm79Ocq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~resto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-resto-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~resto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-resto-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~resto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-resto-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": "City or Region Listing URLs",
                        "type": "array",
                        "description": "Resto.be city or region listing pages to scrape. Example: https://www.resto.be/restaurant/bruxelles or https://nl.resto.be/restaurant/gent",
                        "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 by city name or cuisine type (e.g., 'bruxelles', 'gent', 'italian'). Used to build listing URLs if no startUrls provided."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of restaurants to return.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "fr",
                            "nl",
                            "en"
                        ],
                        "type": "string",
                        "description": "Language for restaurant data. French uses www.resto.be, Dutch uses nl.resto.be, English uses en.resto.be.",
                        "default": "fr"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for scraping more than 1,000 restaurants."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```