# Foodpanda Restaurant Discovery & Full Menu Scraper (`crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu`) Actor

Find Foodpanda restaurants near a point or city, or pull them by URL, with rating, cuisines, delivery fee, ETA and full nested menus with prices and dietary tags. Covers Singapore, Bangladesh, Pakistan, Hong Kong and Malaysia.

- **URL**: https://apify.com/crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu.md
- **Developed by:** [crawlyth forge](https://apify.com/crawlyth-forge) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Foodpanda Restaurant Discovery & Full Menu Scraper

Foodpanda serves food, groceries and convenience goods across Asia. This actor works two ways: give it restaurant page links to pull complete details and menus, or give it a location and let it page through every matching vendor inside a radius.

No login, cookies, browser or proxy setup is needed. The actor talks to Foodpanda's public listing and restaurant APIs directly and only falls back to an Apify datacenter proxy if a direct request is rejected.

### What this actor does

- **URL mode** — paste restaurant page URLs and get full vendor details plus the complete menu with prices.
- **Discovery mode** — use a latitude/longitude pair, a Foodpanda city listing URL, or a city name to find vendors near that point.
- **Real filters** — cuisine, rating/distance/delivery-time sort, discount, free delivery, new vendors, super vendors, delivery provider and vendor type are applied by Foodpanda, not bolted on afterwards.
- **Deep pagination** — discovery keeps requesting the next page until `maxRestaurants` is reached or Foodpanda runs out of matches inside the radius.
- **Ten markets** — Singapore, Bangladesh, Pakistan, Hong Kong, Malaysia, Philippines, Taiwan, Cambodia, Myanmar and Laos.
- **Local-language text** — optionally request vendor and menu names in the country's local language where Foodpanda offers them.
- Fields Foodpanda does not report for a vendor or item are omitted from that record instead of being filled with placeholders.

### Output per vendor

- `vendorCode` — Foodpanda's short vendor code
- `vendorUrl` — working canonical restaurant page link
- `name`, `description`, `rating`, `reviewCount`
- `cuisines`, `foodCharacteristics`, `isHalal`, `isVegetarian`
- `vendorType` — restaurants, convenience, supermarket, etc.
- `isOpen`, `isNew`, `isSuperVendor`, `isDeliveryEnabled`, `isPickupEnabled`
- `address`, `addressLine2`, `city`, `postcode`, `country`, `latitude`, `longitude`
- `deliveryFee`, `minimumOrder`, `estimatedDeliveryTime`, `currency`
- `heroImageUrl`, `logoUrl`
- `menu` — array of `{categoryName, items[]}`, present when menu data was fetched
- `menuCategoryCount`, `menuItemCount`, `itemsWithImageCount`, `itemsWithDescCount` — always present, `0` when the menu was not fetched
- `phone`, `timezone`, `scrapedAt`

Each entry inside `menu[].items[]` has:

- `itemId`, `name`, `description`
- `price`, `originalPrice` (when discounted), `currency`
- `imageUrl`
- `isAvailable`
- `dietaryAttributes` — e.g. `spicy`, `vegetarian`
- `isAlcoholic`, `isCustomizable`, `isBundle`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `restaurantUrls` | array | – | Restaurant page URLs (URL mode); the country comes from the domain |
| `latitude` | number | – | Search-centre latitude (Discovery mode); requires `longitude` and `country` |
| `longitude` | number | – | Search-centre longitude (Discovery mode); requires `latitude` and `country` |
| `cityPageUrl` | string | – | A Foodpanda city/listing URL; country and coordinates are read from it (Discovery mode) |
| `city` | string | – | City name resolved via the built-in lookup (Discovery mode); requires `country` |
| `country` | string | – | `sg`, `bd`, `pk`, `hk`, `my`, `ph`, `tw`, `kh`, `mm`, or `la` — required for coordinate or city-name discovery |
| `radiusKm` | number | `3` | Search radius around the resolved location, in km (0.5–50) |
| `maxRestaurants` | integer | `50` | Maximum vendors to scrape in Discovery mode (1–500); pagination continues until this is reached or results run out |
| `cuisines` | array | – | Keep only these cuisines; accepts names, slugs or Foodpanda cuisine IDs, and multiple values are combined |
| `sortBy` | string | `recommended` | Result order: `recommended`, `rating`, `distance`, or `delivery_time` |
| `deliveryProvider` | string | `any` | `any`, `platform` (Foodpanda riders), or `vendor` (own fleet) |
| `hasDiscount` | boolean | `false` | Keep only vendors with a current discount |
| `hasFreeDelivery` | boolean | `false` | Keep only vendors with free delivery |
| `isNew` | boolean | `false` | Keep only vendors Foodpanda marks as new |
| `isSuperVendor` | boolean | `false` | Keep only Foodpanda super vendors |
| `includeMenu` | boolean | – | Fetch the full menu per vendor. Defaults to `true` in URL mode and `false` in Discovery mode when left unset |
| `maxItemsPerRestaurant` | integer | `200` | Maximum menu items pulled per vendor, when menu fetching is on (1–2000) |
| `language` | string | `english` | `english` or `local` — local language text where Foodpanda offers it |
| `vendorTypes` | array | `["restaurant"]` | Keep only these vendor types: `restaurant`, `grocery`, `convenience`; pass an empty array to get all types |

#### Example: fetch two restaurants with full menus

```json
{
  "restaurantUrls": [
    "https://www.foodpanda.sg/restaurant/m3jj/mcdonalds-ang-mo-kio",
    "https://www.foodpanda.pk/restaurant/u7is/broadway-pizza-ii-chundrigar"
  ],
  "includeMenu": true
}
```

#### Example: top-rated Asian restaurants around a coordinate

```json
{
  "latitude": 1.3521,
  "longitude": 103.8198,
  "country": "sg",
  "radiusKm": 4,
  "maxRestaurants": 100,
  "cuisines": ["Asian"],
  "sortBy": "rating",
  "includeMenu": false
}
```

#### Example: free-delivery grocery vendors in a named city

```json
{
  "city": "Karachi",
  "country": "pk",
  "vendorTypes": ["grocery"],
  "hasFreeDelivery": true,
  "maxRestaurants": 30
}
```

#### Example: page through an entire city centre

```json
{
  "city": "Taipei",
  "country": "tw",
  "radiusKm": 8,
  "maxRestaurants": 500,
  "sortBy": "distance",
  "includeMenu": true,
  "maxItemsPerRestaurant": 50
}
```

### Use cases

- **Menu database building** — collect menus with item-level prices across many restaurants in one run.
- **Delivery fee monitoring** — compare delivery fees and minimum order values across a city.
- **Competitor tracking** — watch a competitor's menu, pricing, discounts or open status change over time.
- **Neighborhood discovery** — list every vendor within walking distance of an address, filtered by cuisine or delivery type.
- **Market research** — compare assortment, pricing and local-language catalogues across Foodpanda's Asian markets.

### FAQ

**What's the difference between URL mode and Discovery mode?**
URL mode fetches the exact restaurants you list. Discovery mode searches near a point, a named city, or a Foodpanda city page, applies your filters, and pages through results inside the radius.

**Do I need to supply both latitude/longitude and a city?**
No — pick one way to locate the search: coordinates, a city page URL, or a city name plus country.

**Why didn't a restaurant I expected show up in Discovery mode?**
Discovery only searches the radius around one resolved point and only returns what Foodpanda's own listing returns for that area. Increase `radiusKm`, loosen a filter, or switch to URL mode with the restaurant's exact page link.

**How do cuisine filters work?**
Foodpanda names cuisines per market. Enter the name shown in the Foodpanda app (for example `Asian`, `Italian`, `Bakery`), its slug, or its numeric Foodpanda ID. Unknown values are reported in the log and produce no results rather than silently returning unfiltered data.

**How many results can one run return?**
`maxRestaurants` goes up to 500 and the actor pages until Foodpanda stops returning vendors inside the radius. Dense city centres may have thousands of matches, so raise the radius and limit together for broad sweeps; splitting a city by cuisine or vendor type is the reliable way to cover more than 500.

**Why is `menu` missing from a record?**
It's omitted when `includeMenu` was off for that run, or when Foodpanda returns no menu for that vendor — `menuCategoryCount` and `menuItemCount` are still returned as `0` either way.

**Can I pull grocery or convenience-store vendors instead of restaurants?**
Yes — set `vendorTypes` to `["grocery"]` and/or `["convenience"]`, or leave it empty to get every type.

**What currency are prices and fees shown in?**
Each market's own currency: SGD, BDT, PKR, HKD, MYR, PHP, TWD, USD (Cambodia), MMK or LAK, matching the `currency` field on that record.

**Do I need proxies, cookies or an account?**
No. The actor reads publicly available Foodpanda data without credentials. It chooses its own connection path automatically; nothing needs to be configured.

**Which cities does the built-in city lookup cover?**
Singapore; Dhaka and Chittagong; Karachi, Lahore and Islamabad; Hong Kong and Kowloon; Kuala Lumpur, Penang and Johor Bahru; Manila, Quezon City and Cebu City; Taipei, Kaohsiung and Taichung; Phnom Penh and Siem Reap; Yangon and Mandalay; Vientiane and Luang Prabang. For any other city, use coordinates or a Foodpanda city page URL.

**Is this affiliated with Foodpanda or Delivery Hero?**
No. This is an independent, third-party actor built on publicly accessible Foodpanda data.

# Actor input Schema

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

URL mode: one or more Foodpanda restaurant page URLs. The country is detected from the domain. Example: https://www.foodpanda.sg/restaurant/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 the built-in lookup table. Examples: Singapore, Karachi, Dhaka, Taipei, Manila, Phnom Penh, Yangon, Vientiane. 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. The actor keeps paging through Foodpanda results until it reaches this number or runs out of matches.

## `cuisines` (type: `array`):

Discovery mode: keep only vendors matching these cuisines. Use cuisine names, slugs or Foodpanda cuisine IDs (e.g. Asian, italian, 39). Multiple values are combined. Leave empty for all cuisines.

## `sortBy` (type: `string`):

Discovery mode: order in which Foodpanda returns vendors.

## `deliveryProvider` (type: `string`):

Discovery mode: keep vendors delivered by Foodpanda riders, by the vendor's own fleet, or both.

## `hasDiscount` (type: `boolean`):

Discovery mode: keep only vendors currently offering a discount.

## `hasFreeDelivery` (type: `boolean`):

Discovery mode: keep only vendors currently offering free delivery.

## `isNew` (type: `boolean`):

Discovery mode: keep only vendors Foodpanda marks as new.

## `isSuperVendor` (type: `boolean`):

Discovery mode: keep only Foodpanda super vendors.

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

Whether to fetch the full menu for each vendor. 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 vendor. Only applies when Include Menu is enabled.

## `language` (type: `string`):

Language for vendor and menu text where Foodpanda offers a localised version (for example Traditional Chinese in Taiwan, Khmer in Cambodia). English is the safe default everywhere.

## `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/m3jj/mcdonalds-ang-mo-kio"
  ],
  "radiusKm": 3,
  "maxRestaurants": 5,
  "sortBy": "recommended",
  "deliveryProvider": "any",
  "hasDiscount": false,
  "hasFreeDelivery": false,
  "isNew": false,
  "isSuperVendor": false,
  "maxItemsPerRestaurant": 10,
  "language": "english",
  "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/m3jj/mcdonalds-ang-mo-kio"
    ],
    "radiusKm": 3,
    "maxRestaurants": 5,
    "sortBy": "recommended",
    "deliveryProvider": "any",
    "hasDiscount": false,
    "hasFreeDelivery": false,
    "isNew": false,
    "isSuperVendor": false,
    "maxItemsPerRestaurant": 10,
    "language": "english",
    "vendorTypes": [
        "restaurant"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu").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/m3jj/mcdonalds-ang-mo-kio"],
    "radiusKm": 3,
    "maxRestaurants": 5,
    "sortBy": "recommended",
    "deliveryProvider": "any",
    "hasDiscount": False,
    "hasFreeDelivery": False,
    "isNew": False,
    "isSuperVendor": False,
    "maxItemsPerRestaurant": 10,
    "language": "english",
    "vendorTypes": ["restaurant"],
}

# Run the Actor and wait for it to finish
run = client.actor("crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/m3jj/mcdonalds-ang-mo-kio"
  ],
  "radiusKm": 3,
  "maxRestaurants": 5,
  "sortBy": "recommended",
  "deliveryProvider": "any",
  "hasDiscount": false,
  "hasFreeDelivery": false,
  "isNew": false,
  "isSuperVendor": false,
  "maxItemsPerRestaurant": 10,
  "language": "english",
  "vendorTypes": [
    "restaurant"
  ]
}' |
apify call crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlyth-forge/foodpanda-restaurant-discovery-and-full-menu"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tnGusg3Celgcmgg4R/builds/KUjiGbhEkosB5ycQw/openapi.json
