# Food Panda Scraper (`shahidirfan/food-panda-scraper`) Actor

Extract restaurant data, menus, pricing, and ratings from FoodPanda instantly. Scrape delivery times, customer reviews, and store information at scale. Perfect for market analysis, competitive intelligence, and food delivery research.

- **URL**: https://apify.com/shahidirfan/food-panda-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Foodpanda Restaurants Scraper

Extract rich restaurant and menu data from Foodpanda Pakistan. Collect listing results, restaurant metadata, cuisines, ratings, fees, delivery estimates, menus, products, and review samples from Foodpanda URLs at scale. It is built for restaurant research, delivery monitoring, competitor tracking, and structured menu analysis.

### Features

- **Accepts multiple Foodpanda URL types** — Works with listing URLs, homepage query URLs, and restaurant detail URLs
- **Flexible input modes** — Run with URL, keyword, or location (city name or lat,lng)
- **Keyword-aware collection** — Filters restaurants by names, cuisines, tags, and menu items
- **Pagination support** — Continues through listing pages until your requested result count is reached
- **Rich restaurant output** — Saves ratings, fees, delivery times, availability, images, and location data
- **Menu extraction** — Includes menus, categories, and product-level data for each restaurant
- **Review enrichment** — Adds review counts and review samples when available
- **Clean dataset structure** — Omits null-only fields from output items

### Use Cases

#### Market Research
Track which restaurants dominate a cuisine, location, or delivery segment. Compare pricing signals, service speed, and review volume across competitors.

#### Menu Intelligence
Build structured menu datasets for product analysis, price comparisons, and assortment tracking. Identify common menu categories, bundled offers, and popular product naming patterns.

#### Delivery Monitoring
Measure delivery fee and delivery time changes over repeated runs. Spot restaurants that go offline, reopen, or change service conditions.

#### Lead Generation
Collect restaurant names, links, cuisine tags, and location details for outreach databases or local business intelligence workflows.

#### Review Analysis
Capture review volume and review samples to support sentiment studies, quality benchmarking, and restaurant scoring pipelines.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `url` | String | No | `https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86` | Foodpanda Pakistan listing URL, homepage query URL, or restaurant detail URL |
| `keyword` | String | No | — | Optional keyword filter applied to restaurant names, cuisines, tags, and menu items |
| `location` | String | No | — | Optional location input. Supports city names (`Islamabad`, `Lahore`, `Karachi`) or coordinates in `lat,lng` format |
| `results_wanted` | Integer | No | `20` | Maximum number of restaurants to save |
| `max_pages` | Integer | No | `3` | Maximum number of listing pages to request |
| `proxyConfiguration` | Object | No | Apify Residential Proxy | Proxy settings for stable collection |

### Output Data

Each item in the dataset contains:

| Field | Type | Description |
|-------|------|-------------|
| `vendor_code` | String | Foodpanda restaurant identifier |
| `name` | String | Restaurant name |
| `url` | String | Restaurant URL on Foodpanda |
| `city` | String | Restaurant city |
| `address` | String | Restaurant address when available |
| `cuisines` | Array | Cuisine names |
| `cuisines_text` | String | Cuisine names as a comma-separated string |
| `rating` | Number | Restaurant rating |
| `review_count` | Integer | Number of reviews |
| `delivery_time` | String | Delivery time text |
| `delivery_fee` | String | Delivery fee text or value |
| `minimum_order` | String | Minimum order amount |
| `price_range` | String | Price range label |
| `is_open` | Boolean | Current availability |
| `hero_image` | String | Main restaurant image |
| `menu_count` | Integer | Number of menus |
| `menu_item_count` | Integer | Number of menu items |
| `menu_categories` | Array | Structured menu categories and products |
| `review_sample` | Array | Review samples when available |
| `source_url` | String | Input URL used for the run |

### Usage Examples

#### Listing URL Extraction

Collect restaurants from a Foodpanda listing page:

```json
{
	"url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
	"results_wanted": 20,
	"max_pages": 3
}
````

#### Homepage Query URL

Use a homepage query URL with cuisine filters:

```json
{
	"url": "https://www.foodpanda.pk/?expedition=delivery&vertical=restaurants&cuisines=86",
	"results_wanted": 15,
	"max_pages": 2
}
```

#### Keyword Filtering

Filter the listing by keyword while keeping structured restaurant output:

```json
{
	"url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants",
	"keyword": "burger",
	"results_wanted": 10,
	"max_pages": 3
}
```

#### Location-Only Run

Run without URL by using only a location:

```json
{
	"location": "Lahore",
	"results_wanted": 30,
	"max_pages": 6
}
```

#### Coordinates + Keyword Run

Run without URL by using coordinates and keyword:

```json
{
	"location": "33.700483,73.036273",
	"keyword": "biryani",
	"results_wanted": 50,
	"max_pages": 10
}
```

#### Restaurant Detail URL

Collect a single restaurant with its menus and review sample:

```json
{
	"url": "https://www.foodpanda.pk/restaurant/jf6n/desi-plate"
}
```

#### Proxy Configuration

For reliable production runs, use residential proxies:

```json
{
	"url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
	"results_wanted": 20,
	"proxyConfiguration": {
		"useApifyProxy": true,
		"apifyProxyGroups": ["RESIDENTIAL"]
	}
}
```

### Sample Output

```json
{
	"vendor_code": "kz9k",
	"name": "Chips and Chopsticks - G-9",
	"url": "https://www.foodpanda.pk/restaurant/kz9k/chips-and-chopsticks-g-9",
	"city": "Islamabad",
	"cuisines": ["Chinese"],
	"cuisines_text": "Chinese",
	"rating": 4.5,
	"review_count": 1000,
	"delivery_time": "From 25 min",
	"delivery_fee": "From Rs.154",
	"minimum_order": "Rs.200",
	"price_range": "Moderate",
	"is_open": true,
	"menu_count": 3,
	"menu_item_count": 42,
	"source_url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86"
}
```

### Tips for Best Results

#### Use Working Foodpanda URLs

- Prefer current listing or restaurant URLs from Foodpanda Pakistan
- Listing URLs with `lat` and `lng` are the most reliable for broader collection
- Restaurant detail URLs are best when you need one complete menu quickly

#### Keep QA and Smoke Tests Fast

- Start with `results_wanted: 20`
- Keep `max_pages` between `2` and `3` for daily validation
- Increase limits only after confirming the target URL is still stable

#### Use Keyword Filters Carefully

- Choose cuisine-aligned keywords when using cuisine-filtered URLs
- Broad keywords like `burger`, `pizza`, or `chinese` usually return more matches than brand names
- If keyword filtering is too narrow, increase `max_pages`

#### Use Residential Proxies in Production

- Residential proxies are recommended for repeated runs
- They improve stability when collecting many restaurants or menus
- Keep concurrency moderate when running at scale

### Integrations

Connect your data with:

- **Google Sheets** — Export restaurant and menu data for analysis
- **Airtable** — Build searchable restaurant and menu databases
- **BigQuery** — Load structured output into analytics pipelines
- **Slack** — Send alerts for rating, fee, or menu changes
- **Webhooks** — Forward data to custom services in real time
- **Make** — Automate downstream enrichment and reporting
- **Zapier** — Connect restaurant data to no-code workflows

#### Export Formats

- **JSON** — For nested menus and structured API usage
- **CSV** — For spreadsheet and tabular analysis
- **Excel** — For business reporting
- **XML** — For custom integrations

### Frequently Asked Questions

#### What Foodpanda URLs does this actor support?

It supports Foodpanda Pakistan listing URLs, homepage query URLs with restaurant filters, and restaurant detail URLs.

#### Can I scrape menus for each restaurant?

Yes. Restaurant output includes structured menu data whenever Foodpanda returns it for the restaurant.

#### Does keyword filtering search menu items too?

Yes. The keyword filter is checked against restaurant names, cuisines, tags, menu category names, and product names.

#### Can I collect more than one page of restaurants?

Yes. Use `max_pages` to control pagination and `results_wanted` to cap how many restaurants are saved.

#### Why are some fields missing in some records?

Foodpanda does not always expose every field for every restaurant. Empty values are omitted from the dataset instead of being saved as nulls.

#### Can I scrape a single restaurant page?

Yes. Provide a restaurant detail URL and the actor will collect one restaurant with its available menu data.

#### Do I need proxies?

For quick local checks you may not always need them, but residential proxies are recommended for stable production runs.

### Support

For issues or feature requests, contact support through the Apify Console.

#### Resources

- [Apify Documentation](https://docs.apify.com/)
- [API Reference](https://docs.apify.com/api/v2)
- [Scheduling Runs](https://docs.apify.com/schedules)

### Legal Notice

This actor is designed for legitimate data collection purposes. Users are responsible for ensuring compliance with website terms of service and applicable laws. Use collected data responsibly and with appropriate rate limits.

# Actor input Schema

## `url` (type: `string`):

A Foodpanda Pakistan listing URL, homepage query URL, or restaurant detail URL.

## `keyword` (type: `string`):

Optional keyword filter matched against restaurant names, cuisines, tags, and menu items.

## `location` (type: `string`):

Optional location selector. Supports city names (e.g., Islamabad, Lahore, Karachi) or lat,lng format (e.g., 33.700483,73.036273).

## `results_wanted` (type: `integer`):

Maximum number of restaurants to save.

## `max_pages` (type: `integer`):

Maximum number of listing API pages to request.

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

Use Apify Proxy for more reliable browser sessions.

## Actor input object example

```json
{
  "url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
  "keyword": "chinese",
  "location": "Islamabad",
  "results_wanted": 20,
  "max_pages": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
    "keyword": "chinese",
    "location": "Islamabad",
    "results_wanted": 20,
    "max_pages": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/food-panda-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 = {
    "url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
    "keyword": "chinese",
    "location": "Islamabad",
    "results_wanted": 20,
    "max_pages": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/food-panda-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 '{
  "url": "https://www.foodpanda.pk/restaurants/new?lng=73.036273&lat=33.700483&vertical=restaurants&cuisines=86",
  "keyword": "chinese",
  "location": "Islamabad",
  "results_wanted": 20,
  "max_pages": 3
}' |
apify call shahidirfan/food-panda-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Food Panda Scraper",
        "description": "Extract restaurant data, menus, pricing, and ratings from FoodPanda instantly. Scrape delivery times, customer reviews, and store information at scale. Perfect for market analysis, competitive intelligence, and food delivery research.",
        "version": "0.0",
        "x-build-id": "QsvaEboIsKLvVCl0p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~food-panda-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-food-panda-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/shahidirfan~food-panda-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-food-panda-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/shahidirfan~food-panda-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-food-panda-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": {
                    "url": {
                        "title": "Foodpanda URL",
                        "type": "string",
                        "description": "A Foodpanda Pakistan listing URL, homepage query URL, or restaurant detail URL."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional keyword filter matched against restaurant names, cuisines, tags, and menu items."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location selector. Supports city names (e.g., Islamabad, Lahore, Karachi) or lat,lng format (e.g., 33.700483,73.036273)."
                    },
                    "results_wanted": {
                        "title": "Results wanted",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of restaurants to save.",
                        "default": 20
                    },
                    "max_pages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listing API pages to request.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy for more reliable browser sessions.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
