# TheFork Restaurant Scraper - Reviews, Prices & Menus (`memo23/thefork-restaurant-scraper`) Actor

Scrape restaurants from TheFork — name, cuisine, price level, average price, rating & reviews, address, geo-coordinates, photos, MICHELIN distinction, deals and amenities. Paste a city/search or restaurant URL. One row per restaurant, optional detail enrichment. JSON/CSV out.

- **URL**: https://apify.com/memo23/thefork-restaurant-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Travel, E-commerce, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 restaurants

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

## TheFork Restaurant Scraper 🍽️

Extract **restaurants from TheFork** at scale — name, cuisine, price level, average price, rating & review count, full address, geo-coordinates, photos, MICHELIN distinction, deals, payment methods and amenities. Paste a **city / search page** to harvest every restaurant, or a **restaurant page** for a single detailed row. Optional detail enrichment adds the full description, chef, weekly opening hours, food requirements, MICHELIN link, parking & transport.

One flat row per restaurant. Clean JSON / CSV / Excel out. No login, no browser automation, no cookies to manage.

![How the TheFork Restaurant Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-thefork.png)

---

### Why use this scraper

- **Paste-a-URL simple.** Copy any TheFork city, cuisine, area or restaurant URL from your browser and drop it in. It's auto-classified — no config puzzles.
- **Everything on the card, already structured.** ~25 fields per restaurant straight from the search page (rating, price, cuisine, geo, photos, MICHELIN, deals) — no detail fetch required.
- **Optional deep enrichment.** Flip one toggle to add description, chef name, weekly opening hours, dietary options, MICHELIN guide link, parking and transport notes.
- **Residential-grade delivery.** Runs through a rotating residential pool that clears TheFork's bot protection reliably — fast pure-HTTP, no headless browser tax.
- **Fails loud, never silent.** If every request is blocked, the run errors instead of quietly returning zero rows.

---

### What it scrapes

| Category | Fields |
|---|---|
| Identity | `restaurantId`, `uuid`, `name`, `slug`, `restaurantUrl` |
| Dining | `cuisine`, `priceRangeLevel` (1–4), `averagePrice`, `currency` |
| Reputation | `rating` (out of 10), `reviewsCount`, `reviewSummary` |
| Location | `street`, `locality`, `zipCode`, `country`, `formattedAddress`, `latitude`, `longitude` |
| Media | `mainPhotoUrl`, `photos[]` |
| Signals | `michelin`, `distinctions[]`, `deals[]`, `paymentAccepted[]`, `tags[]`, `hasLoyaltyProgram`, `isBookable` |
| Detail (opt-in) | `description`, `chefName`, `foodRequirements[]`, `openingHours{}`, `michelinUrl`, `parking`, `transport`, `monthlyReviewsCount` |

---

### Supported inputs

Paste any mix into **`startUrls`** — they're auto-classified:

- **City / search pages** — `https://www.thefork.com/restaurants/london-c665790` (also cuisine, area and tag pages under `/restaurants/...`). Paginated into a restaurant list.
- **Restaurant pages** — `https://www.thefork.com/restaurant/the-lanesborough-grill-r597933`. Scraped as one fully-detailed row.

Works across TheFork's country sites (`.com`, `.co.uk`, `.fr`, `.es`, `.it`, …).

---

### Use cases

- **Market & competitor research** — map cuisine mix, price levels and ratings across a city or neighbourhood.
- **Lead lists for food-tech / suppliers** — geo-located restaurant directories with contact-ready addresses.
- **Review & reputation monitoring** — track rating and review-count movements over time.
- **MICHELIN / fine-dining datasets** — filter to distinctions for premium segmentation.
- **Real-estate & location analytics** — restaurant density and quality as a neighbourhood signal.

---

### How it works

1. You paste TheFork city/search and/or restaurant URLs.
2. Each **search page** is fetched and paginated (`?p=N`); the embedded `__NEXT_DATA__` JSON yields ~25 fully-structured restaurant objects per page.
3. Each **restaurant page** is parsed from its Apollo state into a single rich row.
4. With **Scrape restaurant detail pages** on, every search result is enriched from its own detail page.
5. Rows are de-duplicated by restaurant id and streamed to the dataset.

Requests go through a rotating residential proxy pool with automatic retry on bot-protection challenges — a blocked IP is swapped for a fresh one and the request re-tried.

---

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | London city page | TheFork search/city and/or restaurant URLs. |
| `scrapeDetails` | boolean | `false` | Also fetch each restaurant's detail page for description, chef, hours, dietary, MICHELIN link, parking & transport. |
| `maxItems` | integer | `1000` | Hard cap on rows for the whole run (one paid `restaurant` event each). |
| `maxItemsPerSearch` | integer | `2000` | Cap per search / city URL. |
| `maxConcurrency` | integer | `6` | Parallel requests (keep 4–8). |
| `maxRequestRetries` | integer | `15` | Per-request retry budget on bot-protection challenges. |
| `proxy` | object | Residential (GB) | Proxy for free-tier runs; paid runs use a built-in residential pool. |

---

### Output sample

```json
{
  "rowType": "restaurant",
  "restaurantId": "597933",
  "uuid": "7d024fe6-2cd1-4754-92f0-fa05bba8c9ea",
  "name": "The Lanesborough Grill",
  "slug": "the-lanesborough-grill",
  "restaurantUrl": "https://www.thefork.com/restaurant/the-lanesborough-grill-r597933",
  "cuisine": "British",
  "priceRangeLevel": 4,
  "averagePrice": 85,
  "currency": "GBP",
  "rating": 9.6,
  "reviewsCount": 1002,
  "street": "London",
  "locality": "London",
  "zipCode": "SW1X 7TA",
  "country": "United Kingdom",
  "formattedAddress": "London, SW1X 7TA, London",
  "latitude": 51.5023626,
  "longitude": -0.1524159,
  "mainPhotoUrl": "https://cdn.thefork.com/tf-lab/image/upload/restaurant/7d024fe6-…jpg",
  "photos": ["https://cdn.thefork.com/…", "…"],
  "michelin": true,
  "distinctions": ["MICHELIN", "TOPHOST"],
  "deals": ["Yums x2"],
  "paymentAccepted": ["Apple Pay", "Credit Card", "Mastercard", "Visa"],
  "hasLoyaltyProgram": true,
  "isBookable": true,
  "reviewSummary": "The Lanesborough Grill, located in a stunning historical building near Knightsbridge, offers a delightful dining experience…",
  "chefName": "Shay Cooper",
  "foodRequirements": ["Gluten free", "Vegan dishes", "Vegetarian dishes"],
  "openingHours": { "mon": ["07:00-10:30", "14:30-16:00", "18:30-21:30"] },
  "michelinUrl": "https://guide.michelin.com/gb/en/…",
  "sourceMode": "search",
  "scrapedAt": "2026-07-06T03:25:12.197Z"
}
````

***

### FAQ

**Do I need a TheFork account or API key?** No. Just paste URLs.

**How do I get a city URL?** Search your city on thefork.com and copy the URL from the address bar (it looks like `/restaurants/london-c665790`).

**How many restaurants per city?** TheFork exposes up to ~2,100 restaurants per geography (86 pages × 25). Use `maxItemsPerSearch` to cap.

**What's the difference between the two modes?** Search/city pages already carry ~25 fields per restaurant with no extra fetch. Turn on **Scrape restaurant detail pages** for the full description, chef, opening hours and dietary info (about 2× the requests).

**Which currencies?** Prices come back in each restaurant's local currency (`currency` field), e.g. GBP, EUR.

**Is it reliable against bot protection?** Yes — the actor uses residential IPs with automatic rotation and retry, and fails loudly rather than returning empty results.

***

### Support

Found a missing field or a page that won't parse? Open an issue on the actor's Issues tab with the exact URL — most fixes ship the same week.

***

### ⚠️ Disclaimer

This scraper collects only **publicly available** information from TheFork restaurant listing and search pages. It does not access private data, user accounts, or anything behind a login. Use the output responsibly and in compliance with TheFork's Terms of Service and applicable laws (including data-protection regulations such as GDPR). You are responsible for how you use the extracted data.

***

### SEO keywords

thefork scraper, thefork restaurant scraper, thefork data extraction, restaurant data scraper, thefork api, scrape thefork restaurants, restaurant listings scraper, michelin restaurants dataset, restaurant ratings scraper, thefork uk scraper, restaurant geo data, dining data extraction, thefork london restaurants, restaurant reviews data, food-tech lead lists

# Actor input Schema

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

Search & city pages like `https://www.thefork.com/restaurants/london-c665790` (also cuisine, area and tag pages under `/restaurants/...`) are paginated into a restaurant list. Restaurant pages like `https://www.thefork.com/restaurant/the-lanesborough-grill-r597933` are scraped as a single detailed row. Auto-classified.

## `scrapeDetails` (type: `boolean`):

For each restaurant found on a search/city page, also fetch its detail page to add the full description, chef name, weekly opening hours, food requirements (vegan / gluten-free / …), MICHELIN guide link, and parking & transport notes. Richer rows, but ~2× the requests. Off = the search-card fields (already ~25 per restaurant). Restaurant URLs you paste are always fully detailed.

## `maxItems` (type: `integer`):

Hard cap on rows across the entire run. Each row is one paid `restaurant` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerSearch` (type: `integer`):

Cap per search / city URL. TheFork returns 25 restaurants per page (up to ~2100 per geography). Default 2000.

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. TheFork is protected by DataDome — keep this moderate (4–8). Default 6.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on DataDome challenges (403), 429 and network errors. Each retry rotates to a fresh residential IP. Default 15 (DataDome is flaky per-IP — more retries help break through).

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.thefork.com/restaurants/london-c665790"
  ],
  "scrapeDetails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 2000,
  "maxConcurrency": 6,
  "maxRequestRetries": 15
}
```

# 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": [
        "https://www.thefork.com/restaurants/london-c665790"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/thefork-restaurant-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": ["https://www.thefork.com/restaurants/london-c665790"] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/thefork-restaurant-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": [
    "https://www.thefork.com/restaurants/london-c665790"
  ]
}' |
apify call memo23/thefork-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TheFork Restaurant Scraper - Reviews, Prices & Menus",
        "description": "Scrape restaurants from TheFork — name, cuisine, price level, average price, rating & reviews, address, geo-coordinates, photos, MICHELIN distinction, deals and amenities. Paste a city/search or restaurant URL. One row per restaurant, optional detail enrichment. JSON/CSV out.",
        "version": "0.1",
        "x-build-id": "igoiQlaLblXDuLr17"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~thefork-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-thefork-restaurant-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/memo23~thefork-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-thefork-restaurant-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/memo23~thefork-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-thefork-restaurant-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": "TheFork URLs (search / city / restaurant)",
                        "type": "array",
                        "description": "Search & city pages like `https://www.thefork.com/restaurants/london-c665790` (also cuisine, area and tag pages under `/restaurants/...`) are paginated into a restaurant list. Restaurant pages like `https://www.thefork.com/restaurant/the-lanesborough-grill-r597933` are scraped as a single detailed row. Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape restaurant detail pages",
                        "type": "boolean",
                        "description": "For each restaurant found on a search/city page, also fetch its detail page to add the full description, chef name, weekly opening hours, food requirements (vegan / gluten-free / …), MICHELIN guide link, and parking & transport notes. Richer rows, but ~2× the requests. Off = the search-card fields (already ~25 per restaurant). Restaurant URLs you paste are always fully detailed.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `restaurant` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max restaurants per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per search / city URL. TheFork returns 25 restaurants per page (up to ~2100 per geography). Default 2000.",
                        "default": 2000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. TheFork is protected by DataDome — keep this moderate (4–8). Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on DataDome challenges (403), 429 and network errors. Each retry rotates to a fresh residential IP. Default 15 (DataDome is flaky per-IP — more retries help break through).",
                        "default": 15
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```