# Foodpanda Restaurant & Menu Scraper (`crawlerbros/foodpanda-scraper`) Actor

Scrape Foodpanda restaurants by URL or location. Extracts name, rating, cuisines, delivery details, and full nested menus. Supports Singapore, Bangladesh, Pakistan, Hong Kong, and Malaysia.

- **URL**: https://apify.com/crawlerbros/foodpanda-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 9 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Foodpanda Restaurant & Menu Scraper

Extract restaurant data from Foodpanda — including menus, ratings, delivery details, cuisines, and locations — using direct API access. No browser, no cookies, no manual proxy configuration: a country-targeted Apify residential proxy is hardcoded and applied automatically (required for Foodpanda's PerimeterX bot protection).

### What is this?

The Foodpanda Scraper is an [Apify](https://apify.com) actor that scrapes restaurant and menu data from Foodpanda in two modes:

- **URL Mode** — Paste one or more Foodpanda restaurant URLs to get their full details and menus
- **Discovery Mode** — Enter a location (city, coordinates, or Foodpanda city page URL) and the actor finds all nearby restaurants within your chosen radius

Supported countries: Singapore · Bangladesh · Pakistan · Hong Kong · Malaysia

### What data does it extract?

| Field | Description |
|-------|-------------|
| `vendorCode` | Foodpanda's internal restaurant ID |
| `vendorUrl` | Direct link to the restaurant page |
| `name` | Restaurant name |
| `rating` | Aggregate star rating (e.g. 4.9) |
| `reviewCount` | Number of customer reviews |
| `cuisines` | Cuisine tags (e.g. Fast Food, Halal, Chicken) |
| `vendorType` | Vendor category (restaurant, grocery, etc.) |
| `isOpen` | Whether currently open for delivery |
| `address` | Full street address |
| `city` | City (when available) |
| `country` | Country code (sg, bd, pk, hk, my) |
| `latitude` / `longitude` | Venue coordinates |
| `deliveryFee` | Delivery fee in local currency |
| `minimumOrder` | Minimum order value |
| `estimatedDeliveryTime` | Delivery ETA (e.g. "30-45 min") |
| `currency` | Currency code (SGD, BDT, PKR, HKD, MYR) |
| `heroImageUrl` | Restaurant banner/logo image URL |
| `menu` | Full nested menu (when enabled) |
| `menuCategoryCount` | Number of menu categories |
| `menuItemCount` | Total menu items |
| `itemsWithImageCount` | Items that have images |
| `itemsWithDescCount` | Items that have descriptions |
| `scrapedAt` | Scrape timestamp (UTC ISO-8601) |

#### Menu item fields

| Field | Description |
|-------|-------------|
| `itemId` | Product ID |
| `name` | Item name |
| `description` | Item description |
| `price` | Price in local currency (e.g. 9.70) |
| `currency` | Currency code |
| `imageUrl` | Item image URL |
| `isAvailable` | Whether currently available |
| `dietaryAttributes` | Dietary tags (e.g. halal, vegetarian) |

### How to use

#### URL Mode

1. Open any Foodpanda restaurant page in your browser
2. Copy the URL (e.g. `https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio`)
3. Paste it into the **Restaurant URLs** field
4. Enable **Include Menu** if you want full menu data
5. Click **Start**

#### Discovery Mode

1. Leave **Restaurant URLs** empty
2. Set your location using one of:
   - **Latitude + Longitude + Country** — most precise
   - **City Page URL** — paste a Foodpanda city listing URL (e.g. `https://www.foodpanda.sg/restaurants/new/`)
   - **City + Country** — type a city name and select country
3. Set **Search Radius** (km) and **Max Restaurants**
4. Optionally filter by **Vendor Types** (restaurant, grocery, etc.)
5. Click **Start**

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `restaurantUrls` | string[] | — | One or more Foodpanda restaurant URLs (URL mode) |
| `latitude` | number | — | Decimal latitude (Discovery mode) |
| `longitude` | number | — | Decimal longitude (Discovery mode) |
| `country` | select | — | Country code: sg, bd, pk, hk, my (required with lat/lon or city) |
| `cityPageUrl` | string | — | Foodpanda city listing URL (Discovery mode) |
| `city` | string | — | City name, e.g. "Karachi", "Singapore", "Dhaka" (Discovery mode) |
| `radiusKm` | number | 3 | Search radius in km (0.5–50) |
| `maxRestaurants` | integer | 50 | Max restaurants to return (1–500) |
| `includeMenu` | boolean | true (URL) / false (Discovery) | Fetch full menu data |
| `maxItemsPerRestaurant` | integer | 200 | Max menu items per restaurant (1–2000) |
| `vendorTypes` | string[] | ["restaurant"] | Filter by type: restaurant, grocery, convenience |

### Example output

```json
{
  "vendorCode": "m3jj",
  "vendorUrl": "https://www.foodpanda.sg/restaurant/en/m3jj",
  "name": "McDonald's (Ang Mo Kio)",
  "rating": 4.9,
  "reviewCount": 11601,
  "cuisines": ["Fast Food", "Beverages", "Chicken", "Halal", "Western"],
  "vendorType": "restaurants",
  "isOpen": true,
  "address": "51 Ang Mo Kio Avenue 3, #01-09, AMK Hub, Singapore 569922",
  "country": "sg",
  "latitude": 1.3696,
  "longitude": 103.8487,
  "deliveryFee": 0.0,
  "minimumOrder": 25.0,
  "currency": "SGD",
  "heroImageUrl": "https://images.deliveryhero.io/image/fd-sg/...",
  "menu": [
    {
      "categoryName": "Burgers & Wraps",
      "items": [
        {
          "itemId": "12345",
          "name": "Big Mac",
          "description": "Two all-beef patties, special sauce...",
          "price": 9.70,
          "currency": "SGD",
          "imageUrl": "https://images.deliveryhero.io/image/...",
          "isAvailable": true,
          "dietaryAttributes": ["halal"]
        }
      ]
    }
  ],
  "menuCategoryCount": 8,
  "menuItemCount": 10,
  "itemsWithImageCount": 10,
  "itemsWithDescCount": 8,
  "scrapedAt": "2026-04-14T10:00:00Z"
}
````

### Supported countries

| Country | Code | Domain | Cities supported |
|---------|------|--------|-----------------|
| Singapore | `sg` | foodpanda.sg | Singapore |
| Bangladesh | `bd` | foodpanda.com.bd | Dhaka, Chittagong |
| Pakistan | `pk` | foodpanda.com.pk | Karachi, Lahore, Islamabad |
| Hong Kong | `hk` | foodpanda.com.hk | Hong Kong |
| Malaysia | `my` | foodpanda.com.my | Kuala Lumpur, Penang |

### Use cases

- **Menu database** — Build a database of restaurant menus for comparison or analysis
- **Competitor research** — Track competitor pricing, menu changes, and delivery fees over time
- **Delivery fee monitoring** — Monitor delivery fees and minimum orders across restaurants
- **Restaurant discovery** — Find all restaurants in a neighbourhood with their ratings and cuisines
- **Price intelligence** — Track menu item prices for market research and trend analysis
- **Food tech & AI** — Dataset creation for food recommendation systems and NLP projects

### FAQ

**Do I need a proxy?**
No configuration needed. A country-targeted Apify residential proxy is hardcoded and applied automatically — required for Foodpanda's PerimeterX bot protection.

**Do I need to log in or provide credentials?**
No. The actor uses Foodpanda's public API — no login required.

**How often can I run this?**
For large discovery runs (500+ restaurants), we recommend running no more than once per hour. The actor uses session-based rate limiting with built-in delays.

**Why is my restaurant not found in Discovery mode?**
Discovery mode searches within a radius around a single point. Try increasing `radiusKm` or use URL mode with the exact restaurant URL.

**Can I scrape grocery stores and convenience stores too?**
Yes — set `vendorTypes` to include `grocery` or `convenience`, or leave it empty to include all vendor types.

**What currency are prices in?**
Prices are in the local currency of the country: SGD for Singapore, BDT for Bangladesh, PKR for Pakistan, HKD for Hong Kong, MYR for Malaysia.

**Why are some menu items missing descriptions or images?**
Not all restaurants provide complete menu data. Items with missing descriptions or images will simply not have those fields in the output.

**Is menu data available for all restaurants?**
Most restaurants support menus, but some (especially grocery stores) may have limited menu data.

### Legal notice

This actor extracts publicly visible data from Foodpanda's website. Use it responsibly and in accordance with Foodpanda's Terms of Service. Do not use scraped data for unauthorized commercial purposes. The actor does not bypass authentication, access private data, or perform any action that would harm Foodpanda's infrastructure.

# Actor input Schema

## `restaurantUrls` (type: `array`):

URL mode: one or more Foodpanda restaurant page URLs. The actor auto-detects the country from the domain. Example: https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio

## `latitude` (type: `number`):

Discovery mode: decimal latitude of the search centre. Requires 'longitude' and 'country' to also be set.

## `longitude` (type: `number`):

Discovery mode: decimal longitude of the search centre. Requires 'latitude' and 'country' to also be set.

## `cityPageUrl` (type: `string`):

Discovery mode: a Foodpanda city or listing URL (e.g. https://www.foodpanda.sg/restaurants/new/). Country and coordinates are extracted automatically.

## `city` (type: `string`):

Discovery mode: city name resolved via built-in lookup table. Examples: Singapore, Karachi, Dhaka, Lahore, Kuala Lumpur, Hong Kong, Penang. Requires 'country' to also be set.

## `country` (type: `string`):

Required for Discovery mode with lat/lon or city name.

## `radiusKm` (type: `number`):

Discovery mode: radius around the resolved location in kilometres.

## `maxRestaurants` (type: `integer`):

Discovery mode: maximum number of vendors to scrape.

## `includeMenu` (type: `boolean`):

Whether to fetch full menu data for each restaurant. Defaults to true for URL mode and false for Discovery mode when not explicitly set.

## `maxItemsPerRestaurant` (type: `integer`):

Maximum number of menu items to extract per restaurant. Only applies when Include Menu is enabled.

## `vendorTypes` (type: `array`):

Discovery mode: filter by vendor type. Leave empty to include all types.

## Actor input object example

```json
{
  "restaurantUrls": [
    "https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio"
  ],
  "radiusKm": 3,
  "maxRestaurants": 5,
  "maxItemsPerRestaurant": 10,
  "vendorTypes": [
    "restaurant"
  ]
}
```

# Actor output Schema

## `restaurants` (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 = {
    "restaurantUrls": [
        "https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio"
    ],
    "radiusKm": 3,
    "maxRestaurants": 5,
    "maxItemsPerRestaurant": 10,
    "vendorTypes": [
        "restaurant"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/foodpanda-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 = {
    "restaurantUrls": ["https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio"],
    "radiusKm": 3,
    "maxRestaurants": 5,
    "maxItemsPerRestaurant": 10,
    "vendorTypes": ["restaurant"],
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/foodpanda-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 '{
  "restaurantUrls": [
    "https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio"
  ],
  "radiusKm": 3,
  "maxRestaurants": 5,
  "maxItemsPerRestaurant": 10,
  "vendorTypes": [
    "restaurant"
  ]
}' |
apify call crawlerbros/foodpanda-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Foodpanda Restaurant & Menu Scraper",
        "description": "Scrape Foodpanda restaurants by URL or location. Extracts name, rating, cuisines, delivery details, and full nested menus. Supports Singapore, Bangladesh, Pakistan, Hong Kong, and Malaysia.",
        "version": "1.0",
        "x-build-id": "T2FBgz4CPaiw48524"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~foodpanda-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-foodpanda-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/crawlerbros~foodpanda-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-foodpanda-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/crawlerbros~foodpanda-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-foodpanda-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": {
                    "restaurantUrls": {
                        "title": "Restaurant URLs",
                        "type": "array",
                        "description": "URL mode: one or more Foodpanda restaurant page URLs. The actor auto-detects the country from the domain. Example: https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio",
                        "items": {
                            "type": "string"
                        }
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Discovery mode: decimal latitude of the search centre. Requires 'longitude' and 'country' to also be set."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Discovery mode: decimal longitude of the search centre. Requires 'latitude' and 'country' to also be set."
                    },
                    "cityPageUrl": {
                        "title": "City Page URL",
                        "type": "string",
                        "description": "Discovery mode: a Foodpanda city or listing URL (e.g. https://www.foodpanda.sg/restaurants/new/). Country and coordinates are extracted automatically."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Discovery mode: city name resolved via built-in lookup table. Examples: Singapore, Karachi, Dhaka, Lahore, Kuala Lumpur, Hong Kong, Penang. Requires 'country' to also be set."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "sg",
                            "bd",
                            "pk",
                            "hk",
                            "my"
                        ],
                        "type": "string",
                        "description": "Required for Discovery mode with lat/lon or city name."
                    },
                    "radiusKm": {
                        "title": "Search Radius (km)",
                        "minimum": 0.5,
                        "maximum": 50,
                        "type": "number",
                        "description": "Discovery mode: radius around the resolved location in kilometres.",
                        "default": 3
                    },
                    "maxRestaurants": {
                        "title": "Max Restaurants",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Discovery mode: maximum number of vendors to scrape.",
                        "default": 50
                    },
                    "includeMenu": {
                        "title": "Include Menu",
                        "type": "boolean",
                        "description": "Whether to fetch full menu data for each restaurant. Defaults to true for URL mode and false for Discovery mode when not explicitly set."
                    },
                    "maxItemsPerRestaurant": {
                        "title": "Max Items Per Restaurant",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of menu items to extract per restaurant. Only applies when Include Menu is enabled.",
                        "default": 200
                    },
                    "vendorTypes": {
                        "title": "Vendor Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Discovery mode: filter by vendor type. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "restaurant",
                                "grocery",
                                "convenience"
                            ],
                            "enumTitles": [
                                "Restaurant",
                                "Grocery",
                                "Convenience Store"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
