# Foodpanda Scraper — Restaurants, Menus & Leads (`scrapesage/foodpanda-scraper`) Actor

Scrape Foodpanda restaurants, full menus and prices, plus restaurant B2B leads: name, phone, company UEN, address, geo, cuisines, rating, reviews, delivery fees and opening hours. Search any area by country and location or paste restaurant URLs. Monitor mode returns only new & changed restaurants.

- **URL**: https://apify.com/scrapesage/foodpanda-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 restaurant scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Foodpanda Scraper — Restaurants, Full Menus & Prices (+ Restaurant Leads)

Extract **complete restaurant data from [Foodpanda](https://www.foodpanda.com)** — the full restaurant list for any city or neighbourhood with **ratings, cuisines, delivery fees and exact geo-coordinates**, every restaurant's **complete menu with item prices and variations**, and the fields that turn each listing into a **ready-to-contact B2B lead**: phone number, registered company name and **UEN/business registration number**, full address and website.

No login, no cookies, no browser — fast JSON extraction with 99%+ reliability across **Singapore, Malaysia, Thailand, the Philippines, Hong Kong, Taiwan** and more.

### Why this Foodpanda scraper?

Most food-delivery scrapers grab a few visible cards and stop. This actor reads Foodpanda's own vendor and menu APIs directly and ships the **richest dataset in the category** — including the lead-gen fields nobody else returns:

| Data | Typical scrapers | This actor |
|---|---|---|
| Restaurant name, rating, reviews, cuisines | ✅ | ✅ |
| Exact address, postal code, lat/lng | partial | ✅ |
| **Phone number** | ❌ | ✅ |
| **Company legal name + UEN / registration no.** | ❌ | ✅ |
| Website, delivery fee, minimum order, delivery time | partial | ✅ |
| Price level, promotions, premium/new flags | ❌ | ✅ |
| **Full menu** — categories, items, descriptions, prices, variations | ❌ | ✅ opt-in |
| Opening hours, payment types | ❌ | ✅ opt-in |
| Monitor mode — only new & changed restaurants | ❌ | ✅ |

### Use cases

- **Restaurant lead generation** — every listing is a vetted F&B business with phone, company UEN, address and cuisine. Build prospect lists for POS/SaaS vendors, suppliers, marketing agencies, delivery/packaging, fintech and franchising. Filter by rating, cuisine, or area.
- **Menu & price intelligence** — pull full menus with item-level prices to benchmark competitors, track price changes, and power menu-aggregation or recommendation apps.
- **Market research & expansion** — map restaurant density, cuisine mix, ratings and delivery economics by city or neighbourhood across Southeast Asia.
- **Q-commerce & grocery** — switch the vertical to scrape shops and dark stores too.
- **Monitoring** — schedule recurring runs to capture new openings and changes (ratings, promotions, delivery status) in a market over time.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Foodpanda Scraper**, pick a **Location** (e.g. *Singapore*) — or paste restaurant URLs — choose whether to pull full menus, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchLocation": "singapore",
    "vertical": "restaurants",
    "searchQuery": "",
    "maxItems": 200,
    "scrapeMenus": true,
    "monitorMode": false
}
````

- **searchLocation** — a city/area preset (Singapore, Orchard, Jurong East, Kuala Lumpur, Bangkok, Manila, Hong Kong, Taipei, …). Each preset sets the country and coordinates for you. Choose **Custom** to enter your own `latitude`/`longitude` + `country`.
- **latitude / longitude** — optional override to search around a precise point (e.g. a specific neighbourhood).
- **searchQuery** — optional keyword to filter by name or cuisine (`sushi`, `halal`, `McDonald's`).
- **vertical** — `restaurants` (default), `shop`, or `darkstores` (grocery).
- **startUrls** — paste Foodpanda restaurant URLs to scrape only those (with full menus).
- **maxItems** *(default 100)* — cap across the run (0 = no limit; a dense city returns 3,000+).
- **scrapeMenus** *(default true)* — enrich each restaurant with its full menu (categories, items, prices, variations), opening hours, payment types and accurate minimum order. Turn off for a fast, cheap listing-only run.
- **monitorMode** *(default false)* — only output new & changed restaurants since the previous run for the same input (state persists across runs — pairs perfectly with Schedules).
- **proxyConfiguration** — proxy settings (Singapore residential proxy by default).

### Output

One record per restaurant (`type: "restaurant"`), with a full `menuCategories` array when menu scraping is on:

```json
{
    "type": "restaurant",
    "vendorCode": "xb4y",
    "name": "Haidilao Express (Plaza Singapura)",
    "url": "https://foodpanda.sg/restaurant/xb4y/haidilao-express-plaza-singapura",
    "cuisines": ["Chinese", "Asian"],
    "rating": 4.7,
    "reviewCount": 64,
    "priceRange": "$$$",
    "phone": "+6585068421",
    "legalName": "Singapore Hai Di Lao Dining Pte Ltd",
    "uen": "201201446C",
    "address": "68 Orchard Rd, #04-01 20, Plaza Singapura, Singapore 238839",
    "postalCode": "238839",
    "latitude": 1.3003,
    "longitude": 103.8449,
    "country": "sg",
    "currency": "SGD",
    "minimumOrderAmount": 10,
    "deliveryFee": 0,
    "minimumDeliveryTimeMins": 30,
    "isPromoted": false,
    "isPremium": true,
    "tags": ["Featured", "Free Delivery"],
    "openingHours": [{ "day": "Monday", "slots": [{ "from": "11:30", "to": "23:59", "type": "delivering" }] }],
    "menuItemCount": 68,
    "menuPriceMin": 2.2,
    "menuPriceMax": 18.99,
    "menuCategories": [
        { "category": "Set Meal", "items": [{ "name": "Tomato Tender Fish Rice Bowl", "price": 16.99, "variations": [{ "name": null, "price": 16.99 }] }] }
    ],
    "scrapedAt": "2026-06-12T12:00:00.000Z"
}
```

#### What to expect (field coverage)

| Field group | Coverage |
|---|---|
| name, cuisines, rating, reviews, address, postcode, lat/lng, delivery fee, min order | ~100% |
| phone, price level, chain, promotions | ~95–100% |
| company legal name + UEN | present when the restaurant published its business registration (very common for SG/MY) |
| full menu, opening hours, payment types *(with `scrapeMenus`)* | ~98% |
| website | present when the restaurant listed one |

A blank field means the restaurant didn't publish it — never that scraping failed.

### Automate & schedule

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run daily/weekly with **Monitor mode** to capture new openings and changes.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger CRM import, Slack alerts or email sequences the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/foodpanda-scraper').call({
    searchLocation: 'singapore',
    vertical: 'restaurants',
    maxItems: 200,
    scrapeMenus: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} restaurants`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new restaurant leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored area adds restaurants.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list the top-rated halal restaurants near Orchard with their phone numbers and menu prices" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **local-business & lead-gen stack**:

- **[SGCarMart Used Car Scraper](https://apify.com/scrapesage/sgcarmart-used-car-scraper)** — Singapore used-car listings, prices and dealer leads.
- **[MyCareersFuture Scraper](https://apify.com/scrapesage/mycareersfuture-scraper)** — Singapore jobs with salaries and hiring-company leads.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads (ticket prices, emails, socials).
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — speakers, sessions and sponsors as B2B leads.
- **[Bark Listing Scraper](https://apify.com/scrapesage/bark-listing-scraper)** — service-provider leads from Bark.
- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices and availability.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence on Meta & Instagram.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — and more on the [scrapesage profile](https://apify.com/scrapesage).

### Tips

- **Cover a whole city**: set `maxItems: 0` and pick a central preset; the actor paginates every restaurant the location returns (3,000+ in central Singapore). Use neighbourhood presets or custom coordinates to focus tightly.
- **Restaurant leads**: even with `scrapeMenus` off you get name, phone, UEN, address, cuisine and rating — a complete prospect list. Turn menus on when you also need item-level prices.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with **Monitor mode** to track new openings and changes without re-pulling everything.
- **Other countries**: pick a regional preset, or choose **Custom** and set `latitude`/`longitude` + `country` (Foodpanda covers SG, MY, TH, PH, HK, TW, KH, LA, MM, BD, PK).

### FAQ

**Does it need a Foodpanda login or API key?** No login. The actor uses Foodpanda's public web API key (pre-filled); you can override it if Foodpanda ever rotates it.

**Where do the phone number and UEN come from?** From the restaurant's own public Foodpanda profile, where merchants list their contact number and registered business details. They're absent only when the merchant didn't publish them.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I find restaurants in a specific neighbourhood?** Pick the nearest preset, or choose **Custom** and paste the exact `latitude`/`longitude` (Foodpanda lists vendors that deliver to that point).

**Does Monitor mode conflict with Apify Schedules?** No — they're complementary. The Schedule decides *when* a run starts; Monitor mode decides *which* restaurants are new or changed within that run (state persists in a named key-value store).

**Is scraping Foodpanda legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. PDPA/GDPR for personal data) and Foodpanda's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchLocation` (type: `string`):

City/area to scrape restaurants around. Each preset sets the country and coordinates for you. Choose <code>Custom</code> to enter your own latitude/longitude and country below.

## `latitude` (type: `string`):

Optional. Latitude to search around. Overrides the preset location's coordinates. Required when Location is <code>Custom</code>.

## `longitude` (type: `string`):

Optional. Longitude to search around. Overrides the preset location's coordinates. Required when Location is <code>Custom</code>.

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

Foodpanda country code, used only when Location is <code>Custom</code> (presets set this automatically).

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

Optional keyword to filter restaurants by name or cuisine (e.g. <code>sushi</code>, <code>halal</code>, <code>McDonald's</code>). Leave blank to scrape all restaurants in the location.

## `vertical` (type: `string`):

Which Foodpanda vertical to scrape.

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

Optional. Paste Foodpanda restaurant URLs (e.g. <code>https://www.foodpanda.sg/restaurant/xb4y/haidilao-express</code>) to scrape only those restaurants (with full menus).

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

Maximum number of restaurants to scrape. Use 0 for no limit (a dense city can return 3,000+).

## `scrapeMenus` (type: `boolean`):

Open each restaurant to enrich it with the full menu (every category and item with name, description, price and variations), opening hours, accurate minimum order, payment types and active deals. Turn off for a fast, cheap run with the (still rich) listing fields only — name, phone, UEN, address, geo, cuisines, rating and delivery info.

## `monitorMode` (type: `boolean`):

Only output restaurants that are new or have changed (e.g. rating, delivery status, promotions) since the previous run for the same input. State persists across runs, so this pairs perfectly with Apify Schedules to track a market over time without re-pulling unchanged restaurants. Leave off to always return every match.

## `monitorTrackChanges` (type: `boolean`):

When monitor mode is on, re-emit a restaurant when its rating, delivery availability or promotions change, tagged <code>changed</code>. Turn off to treat only brand-new restaurants as changes.

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

Maximum number of requests fetched in parallel.

## `apiKey` (type: `string`):

The public Foodpanda/Delivery Hero web API key. The default works; only change it if Foodpanda rotates it.

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

Proxy settings. Foodpanda's APIs are best reached from a residential IP in (or near) the target country — Singapore residential proxies are used by default.

## Actor input object example

```json
{
  "searchLocation": "singapore",
  "country": "sg",
  "vertical": "restaurants",
  "maxItems": 100,
  "scrapeMenus": true,
  "monitorMode": false,
  "monitorTrackChanges": true,
  "maxConcurrency": 8,
  "apiKey": "volo",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SG"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped restaurant records (with optional full menus) as JSON items in the default dataset.

# 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 = {
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = { "maxItems": 100 }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
  "maxItems": 100
}' |
apify call scrapesage/foodpanda-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Foodpanda Scraper — Restaurants, Menus & Leads",
        "description": "Scrape Foodpanda restaurants, full menus and prices, plus restaurant B2B leads: name, phone, company UEN, address, geo, cuisines, rating, reviews, delivery fees and opening hours. Search any area by country and location or paste restaurant URLs. Monitor mode returns only new & changed restaurants.",
        "version": "0.1",
        "x-build-id": "n412M5eMdXTg1sAxd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~foodpanda-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~foodpanda-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-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/scrapesage~foodpanda-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-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": {
                    "searchLocation": {
                        "title": "Location",
                        "enum": [
                            "singapore",
                            "singapore-orchard",
                            "singapore-jurong-east",
                            "singapore-tampines",
                            "singapore-woodlands",
                            "kuala-lumpur",
                            "penang",
                            "johor-bahru",
                            "bangkok",
                            "chiang-mai",
                            "manila",
                            "cebu",
                            "hong-kong",
                            "taipei",
                            "kaohsiung",
                            "phnom-penh",
                            "custom"
                        ],
                        "type": "string",
                        "description": "City/area to scrape restaurants around. Each preset sets the country and coordinates for you. Choose <code>Custom</code> to enter your own latitude/longitude and country below.",
                        "default": "singapore"
                    },
                    "latitude": {
                        "title": "Latitude (override)",
                        "type": "string",
                        "description": "Optional. Latitude to search around. Overrides the preset location's coordinates. Required when Location is <code>Custom</code>."
                    },
                    "longitude": {
                        "title": "Longitude (override)",
                        "type": "string",
                        "description": "Optional. Longitude to search around. Overrides the preset location's coordinates. Required when Location is <code>Custom</code>."
                    },
                    "country": {
                        "title": "Country (for Custom location)",
                        "enum": [
                            "sg",
                            "my",
                            "th",
                            "ph",
                            "hk",
                            "tw",
                            "kh",
                            "la",
                            "mm",
                            "bd",
                            "pk"
                        ],
                        "type": "string",
                        "description": "Foodpanda country code, used only when Location is <code>Custom</code> (presets set this automatically).",
                        "default": "sg"
                    },
                    "searchQuery": {
                        "title": "Search keyword (optional)",
                        "type": "string",
                        "description": "Optional keyword to filter restaurants by name or cuisine (e.g. <code>sushi</code>, <code>halal</code>, <code>McDonald's</code>). Leave blank to scrape all restaurants in the location."
                    },
                    "vertical": {
                        "title": "Vertical",
                        "enum": [
                            "restaurants",
                            "shop",
                            "darkstores"
                        ],
                        "type": "string",
                        "description": "Which Foodpanda vertical to scrape.",
                        "default": "restaurants"
                    },
                    "startUrls": {
                        "title": "Restaurant URLs",
                        "type": "array",
                        "description": "Optional. Paste Foodpanda restaurant URLs (e.g. <code>https://www.foodpanda.sg/restaurant/xb4y/haidilao-express</code>) to scrape only those restaurants (with full menus).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max restaurants",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of restaurants to scrape. Use 0 for no limit (a dense city can return 3,000+).",
                        "default": 100
                    },
                    "scrapeMenus": {
                        "title": "Scrape full menus",
                        "type": "boolean",
                        "description": "Open each restaurant to enrich it with the full menu (every category and item with name, description, price and variations), opening hours, accurate minimum order, payment types and active deals. Turn off for a fast, cheap run with the (still rich) listing fields only — name, phone, UEN, address, geo, cuisines, rating and delivery info.",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new & changed)",
                        "type": "boolean",
                        "description": "Only output restaurants that are new or have changed (e.g. rating, delivery status, promotions) since the previous run for the same input. State persists across runs, so this pairs perfectly with Apify Schedules to track a market over time without re-pulling unchanged restaurants. Leave off to always return every match.",
                        "default": false
                    },
                    "monitorTrackChanges": {
                        "title": "Flag changes",
                        "type": "boolean",
                        "description": "When monitor mode is on, re-emit a restaurant when its rating, delivery availability or promotions change, tagged <code>changed</code>. Turn off to treat only brand-new restaurants as changes.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum number of requests fetched in parallel.",
                        "default": 8
                    },
                    "apiKey": {
                        "title": "Foodpanda API key",
                        "type": "string",
                        "description": "The public Foodpanda/Delivery Hero web API key. The default works; only change it if Foodpanda rotates it.",
                        "default": "volo"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Foodpanda's APIs are best reached from a residential IP in (or near) the target country — Singapore residential proxies are used by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "SG"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```