# 🍴 Uber Eats Scraper (`scrapier/uber-eats-scraper`) Actor

Extract restaurant, menu, pricing, ratings, reviews, delivery fees, and location data from Uber Eats. Collect structured food delivery data at scale for market research, competitor analysis, price monitoring, lead generation, and business intelligence.

- **URL**: https://apify.com/scrapier/uber-eats-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Developer tools, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🍴 Uber Eats Scraper [PPR]

Fast, cost-effective **Uber Eats scraper** that turns a search query + location — or a list of store URLs — into clean, structured store and menu data. Built for scale, with an automatic anti-block proxy ladder and **pay-per-result** pricing, so you only pay for stores you actually get.

### ✨ Why Choose Us?

- 🎯 **Two ways to scrape** — search by **address (+ optional query)** *or* paste **store URLs** directly.
- 🛡️ **Self-healing connection** — starts **direct** (cheapest), and only escalates to **datacenter → residential** proxies when Uber Eats blocks. No fiddly config.
- 🍕 **Deep menu data** — full menu sections, items, prices, images, and optional **customizations** (modifiers / add-ons).
- ⚡ **Live results** — every store is saved the instant it's collected; a crash never loses progress.
- 💸 **Pay per result** — billed per store, not per minute.

### 🔑 Key Features

| Feature | Description |
|--------|-------------|
| 📍 Address search | Find stores near any address, optionally filtered by query |
| 🏪 Store verticals | Restaurants, grocery, convenience, pharmacy, alcohol, retail & more |
| 🔗 URL mode | Scrape specific Uber Eats store pages in bulk |
| 🍔 Menu extraction | Sections, items, prices, availability, tags, images |
| 🧩 Customizations | Optional full modifier/add-on trees per item |
| ⭐ Reviews & ratings | Store rating, review count, featured reviews |
| 🛡️ Proxy fallback | Direct → Datacenter → Residential, sticky once escalated |
| 🌐 55+ locales | Scrape Uber Eats across the US, EU, LATAM, APAC and more |

### 📥 Input

Choose **one** mode. If `urls` is provided, `address` and `query` are ignored.

```json
{
  "locale": "en-US",
  "address": "1600 Pennsylvania Avenue, Washington DC",
  "query": "Pizza",
  "storeType": "RESTAURANTS",
  "maxRows": 10,
  "urls": [],
  "getMenuCustomizations": false,
  "proxyConfiguration": { "useApifyProxy": true },
  "concurrency": 5,
  "maxRetries": 3
}
````

| Field | Type | Description |
|-------|------|-------------|
| `locale` | string | Uber Eats locale, e.g. `en-US`, `fr-FR`. Applies to both modes. |
| `address` | string | Delivery address to search around (search mode). |
| `query` | string | Optional search term (cuisine, brand, dish). |
| `storeType` | string | Vertical tab: `ALL`, `RESTAURANTS`, `GROCERY`, `PHARMACY`, … |
| `maxRows` | integer | Max stores in search mode (`0` = all). |
| `urls` | array | Uber Eats store URLs to scrape directly (bulk). |
| `getMenuCustomizations` | boolean | Fetch full customization trees per item. |
| `proxyConfiguration` | object | Apify Proxy used for the datacenter → residential fallback. |
| `concurrency` | integer | Stores scraped in parallel (1–20). |
| `maxRetries` | integer | Retries per blocked request (1–10). |

### 📤 Output

Each dataset item is one store:

```json
{
  "title": "District Detroit Pizza",
  "sanitizedTitle": "District Detroit Pizza",
  "phoneNumber": "+12025551234",
  "emails": [],
  "cuisineList": ["Pizza"],
  "location": { "address": "…", "city": "Washington", "country": "US", "latitude": 38.9, "longitude": -77.0 },
  "currencyCode": "USD",
  "rating": { "ratingValue": 4.8, "reviewCount": "260+" },
  "storeAvailablityStatus": "AVAILABLE",
  "isOpen": true,
  "etaRange": "Delivered in 20 to 30 min",
  "hours": [ … ],
  "categories": ["$", "Pizza"],
  "categoriesLink": [ … ],
  "menu": [ { "catalogName": "Pizzas", "catalogItems": [ … ] } ],
  "logoImageUrl": "https://…",
  "heroImageUrl": "https://…",
  "uuid": "…",
  "url": "https://ubereats.com/store/…",
  "merchantType": "MERCHANT_TYPE_RESTAURANT",
  "distance": { "text": "2.2 mi", "accessibilityText": "2.2 miles" },
  "supportedDiningModes": [ … ],
  "storeReviews": [ … ],
  "featuredReviews": [ … ]
}
```

### 🚀 How to Use (Apify Console)

1. Log in at [console.apify.com](https://console.apify.com) → **Actors**.
2. Open **🍴 Uber Eats Scraper \[PPR]**.
3. Either enter an **address** (and optional **query** + **store type**), **or** paste **store URLs**.
4. Click **Start**.
5. Watch stores stream into the **Output** tab in real time.
6. Export to **JSON / CSV / XLSX / Excel** when the run completes.

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"address":"1600 Pennsylvania Avenue, Washington DC","query":"Pizza","storeType":"RESTAURANTS","maxRows":10}'
```

### 🎯 Best Use Cases

- 📊 Competitor menu & price monitoring
- 🍽️ Restaurant & store discovery / market research
- 📈 Lead lists of local merchants by category and area
- 🗺️ Delivery coverage and ETA analysis across locations

### 💰 Pricing

**Pay per result** — you are billed a flat price for each store written to the dataset (the `apify-default-dataset-item` event). No charge for stores that fail to collect. Failed targets never cost you anything; partial runs still return everything collected so far.

### ❓ FAQ

**Do I need a proxy?** No. The scraper starts direct and only uses Apify Proxy if Uber Eats blocks it.

**Search returns fewer than `maxRows`?** Uber Eats only lists so many stores for a given area/query — that's the ceiling, not a bug.

**Why are some menus empty?** Some stores (e.g. certain alcohol/convenience listings) expose no public catalog; the store record is still returned.

**Which countries are supported?** Anywhere Uber Eats operates — pick the matching `locale` (55+ supported).

### 🛟 Support & Feedback

Open an issue on the Actor's **Issues** tab in Apify Console with your run ID and input, and we'll take a look.

***

*Data is collected only from publicly available Uber Eats pages. You are responsible for compliance with applicable laws and Uber's Terms of Service.*

# Actor input Schema

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

Select locale (default is en-US). Applies to both search and URL mode.

## `address` (type: `string`):

Delivery address to search in (e.g. Address, City, Zip Code). Required when not using URLs.

## `query` (type: `string`):

Query to search for (e.g. McDonald's, pizza). Optional when using address.

## `storeType` (type: `string`):

Uber Eats category tab to scrape. **Default: ALL** (the “All” tab). Use **RESTAURANTS** for restaurant-only results. Browse-only types (CONVENIENCE, PHARMACY, RETAIL, …) use the category feed and **ignore query**. Ignored when **URLs** is set.

## `maxRows` (type: `integer`):

Maximum number of restaurants/stores to scrape in search mode (0 = all). Not used in URL mode — result count equals the number of input URLs.

## `urls` (type: `array`):

List of Uber Eats store page URLs to scrape. When provided, address and query are ignored. Supports bulk input.

## `getMenuCustomizations` (type: `boolean`):

When enabled, the scraper loads full customization trees for each menu item (modifiers, add-ons, sizes, etc.).

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

Apify Proxy used for the automatic Datacenter → Residential fallback ladder when Uber Eats blocks direct requests.

## Actor input object example

```json
{
  "locale": "en-US",
  "address": "71 Avenue Du Général Leclerc, Paris",
  "query": "Pizza",
  "storeType": "ALL",
  "maxRows": 10,
  "urls": [
    "https://www.ubereats.com/store/mcdonalds-paris-alesia/eHoH6Q_2RRikwI-xKk7qaQ"
  ],
  "getMenuCustomizations": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "locale": "en-US",
    "address": "1600 Pennsylvania Avenue, Washington DC",
    "query": "Pizza",
    "maxRows": 10,
    "getMenuCustomizations": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/uber-eats-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 = {
    "locale": "en-US",
    "address": "1600 Pennsylvania Avenue, Washington DC",
    "query": "Pizza",
    "maxRows": 10,
    "getMenuCustomizations": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/uber-eats-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 '{
  "locale": "en-US",
  "address": "1600 Pennsylvania Avenue, Washington DC",
  "query": "Pizza",
  "maxRows": 10,
  "getMenuCustomizations": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapier/uber-eats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🍴 Uber Eats Scraper",
        "description": "Extract restaurant, menu, pricing, ratings, reviews, delivery fees, and location data from Uber Eats. Collect structured food delivery data at scale for market research, competitor analysis, price monitoring, lead generation, and business intelligence.",
        "version": "0.1",
        "x-build-id": "NwZQWmFs5KQOsFrmP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~uber-eats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-uber-eats-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/scrapier~uber-eats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-uber-eats-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/scrapier~uber-eats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-uber-eats-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": {
                    "locale": {
                        "title": "🗺️ Locale",
                        "enum": [
                            "en-US",
                            "es-GT",
                            "es-CL",
                            "en-CA",
                            "en-ZA",
                            "es-EC",
                            "it-CH",
                            "en-CH",
                            "en-AU",
                            "en-GB",
                            "es-CR",
                            "fr-CA",
                            "es-ES",
                            "en-PL",
                            "en-SV",
                            "pt-PT",
                            "en-IE",
                            "en-LK",
                            "en-BE",
                            "en-NZ",
                            "es-PA",
                            "en-JP",
                            "pl-PL",
                            "sv-SE",
                            "fr-BE",
                            "fr-FR",
                            "en-NL",
                            "en-IT",
                            "es-DO",
                            "en-TW",
                            "ja-JP",
                            "en-FR",
                            "it-IT",
                            "en-EC",
                            "en-MX",
                            "en-CR",
                            "en-PT",
                            "en-DO",
                            "en-ES",
                            "en-SE",
                            "en-CL",
                            "en-GT",
                            "en-KE",
                            "de-CH",
                            "es-SV",
                            "nl-BE",
                            "de-DE",
                            "fr-CH",
                            "en-PA",
                            "zh-TW",
                            "nl-NL",
                            "es-MX",
                            "en-DE",
                            "fr-LU",
                            "de-LU"
                        ],
                        "type": "string",
                        "description": "Select locale (default is en-US). Applies to both search and URL mode.",
                        "default": "en-US"
                    },
                    "address": {
                        "title": "📍 Delivery address",
                        "type": "string",
                        "description": "Delivery address to search in (e.g. Address, City, Zip Code). Required when not using URLs."
                    },
                    "query": {
                        "title": "🔎 Search query",
                        "type": "string",
                        "description": "Query to search for (e.g. McDonald's, pizza). Optional when using address."
                    },
                    "storeType": {
                        "title": "🏪 Store type (vertical)",
                        "enum": [
                            "ALL",
                            "RESTAURANTS",
                            "GROCERY",
                            "CONVENIENCE",
                            "ALCOHOL",
                            "PHARMACY",
                            "PRESCRIPTIONS",
                            "PERSONAL_CARE",
                            "BABY",
                            "SPECIALITY_FOODS",
                            "PET_SUPPLIES",
                            "FLOWERS",
                            "RETAIL",
                            "BEAUTY",
                            "ELECTRONICS",
                            "SHOP"
                        ],
                        "type": "string",
                        "description": "Uber Eats category tab to scrape. **Default: ALL** (the “All” tab). Use **RESTAURANTS** for restaurant-only results. Browse-only types (CONVENIENCE, PHARMACY, RETAIL, …) use the category feed and **ignore query**. Ignored when **URLs** is set.",
                        "default": "ALL"
                    },
                    "maxRows": {
                        "title": "📈 Maximum number of stores",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of restaurants/stores to scrape in search mode (0 = all). Not used in URL mode — result count equals the number of input URLs.",
                        "default": 0
                    },
                    "urls": {
                        "title": "🔗 Store URLs",
                        "type": "array",
                        "description": "List of Uber Eats store page URLs to scrape. When provided, address and query are ignored. Supports bulk input.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "getMenuCustomizations": {
                        "title": "🧩 Fetch menu customizations",
                        "type": "boolean",
                        "description": "When enabled, the scraper loads full customization trees for each menu item (modifiers, add-ons, sizes, etc.).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy used for the automatic Datacenter → Residential fallback ladder when Uber Eats blocks direct requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```