# Foodpanda & Foodora Restaurants Scraper (`nice_dev/foodpanda-restaurants-scraper`) Actor

Scrape foodpanda and foodora restaurants for a whole city or country in 15 countries: phone, company name and number, address, GPS, rating, cuisines, delivery fees, promotions, plus menu and reviews on demand. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/nice_dev/foodpanda-restaurants-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.86 / 1,000 restaurants

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

### 🍽️ What is Foodpanda & Foodora Restaurants Scraper?

**Foodpanda & Foodora Restaurants Scraper** extracts **restaurants from [foodpanda](https://www.foodpanda.com) and [foodora](https://www.foodora.com)** in **15 countries**: **name, phone number, registered company name and number, address, GPS point, rating, cuisines, delivery fee and time, discounts and badges** of every restaurant of a city, of several cities or of a whole country — and on request its **full menu with prices, opening hours and offers**, and its **reviews**. It works as a **foodpanda API alternative**: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Choose a **country**, type a **city** (`Kuala Lumpur`, `Makati`, `Praha`) or tick **Whole country**, click **Start**, and download the restaurants in JSON, CSV or Excel. No login, nothing to set up: the whole city is covered, not only the restaurants that deliver to one address, and each restaurant is returned once. It is **fast: about 1,000 restaurants in 5 seconds** for **$0.89 per 1,000 restaurants** ($0.86 on the Gold plan), and about 100 restaurants in 2 minutes with their full menu (an option).

### 📋 What data can you extract from foodpanda and foodora?

One item per restaurant, 77 fields:

| Category | What you get |
| --- | --- |
| 🏷️ **Restaurant** | name, brand (foodpanda or foodora), code and page link, description, chain, logo and cover photo — `An Acai Affair (Haji Lane)` |
| ☎️ **Contact and company** | phone number, registered company name, company number (UEN in Singapore) — `+6580206914`, `202236694N` |
| 📍 **Address and map** | street address, postal code, city, latitude / longitude, time zone, distance from the searched city center or map point — `44 Haji Lane, 189237` |
| ⭐ **Rating** | average rating and exact number of ratings, also above a thousand (where the app shows `1000+`) — `5.0` from `688` |
| 🍣 **Cuisines and price level** | cuisines, main cuisine, dietary tags such as Halal or Vegetarian, price level — `Dessert, Healthy`, `$$` |
| 🛵 **Delivery** | delivery fee and its kind, delivery and pick-up time, minimum order, who delivers (the platform's riders or the restaurant's own) |
| 🎁 **Offers and badges** | free delivery, discount labels, Featured (paid placement), new on the platform, super vendor, premium, best in city, loyalty cashback |
| 🟢 **Status** | delivery available at the time of the run, pick-up offered, temporarily closed and why, pre-orders, online payment or cash only, prices with or without VAT |
| 📖 **Menu, hours and offers** (option) | menu categories, dishes with description, photo, price and price before discount, sizes, add-ons with their prices, sold out, alcohol; opening hours day by day, special days; offers and vouchers with code and conditions; small-order fee, service fee, regular delivery fee before discount; food license, registered address, kitchen busy |
| 💬 **Reviews** (option) | date, text, author name as shown, overall / food / rider scores, dishes ordered, likes, the restaurant's answer |
| 🔎 **Search** | the city, map point or URL whose search found the restaurant |

Every field, with an example, is listed in the **Output** section below.

The menu (with opening hours and offers) and the reviews are **options, off by default**: tick **Include menu, opening hours and offers** or **Include reviews** to add them (each is charged as its own event, see the pricing below). Without them, those fields are `null` (not asked), never an empty list.

Countries: **foodpanda** in Singapore, Malaysia, Taiwan, Hong Kong, the Philippines, Pakistan, Bangladesh, Cambodia, Laos and Myanmar; **foodora** in Sweden, Norway, Austria, Czechia and Hungary. Amounts are in the local currency (US dollars in Cambodia), given in the `currency` field. The site shows no phone number in the Philippines, Hong Kong and Pakistan, and few company numbers in Pakistan, Taiwan and Bangladesh.

### ✅ Why use Foodpanda & Foodora Restaurants Scraper?

- 🗺️ **A whole city, not one address**: foodpanda and foodora only list the restaurants that deliver to the address you type. The Actor covers the city from its center outwards until no new restaurant of that city appears, and returns each restaurant once.
- 🌏 **15 countries, 2 apps, one Actor**: several cities, map points or a whole country in one run, with a cap per city so that one big city cannot use up the whole budget.
- 📇 **Leads ready to use**: phone number, registered company name and company number are included in every restaurant, without any option, wherever the site shows them.
- 🎛️ **Filters of the app, free**: cuisines, dietary tags, price levels, delivery / pick-up / dine-in, shops, dark stores and grocery stores — plus the Actor's own: minimum rating, minimum number of ratings, phone required, free delivery, discount, marked new, open now, independent restaurants only, searched city only, keywords to keep or to exclude.
- 📖 **Menus and reviews on demand**: full menus with add-ons and prices before discount; reviews filtered by date, score, text, the restaurant's answer or keyword.
- 🔔 **Monitoring built in**: tick **Only new restaurants**, schedule the Actor, and each run returns (and charges) only the restaurants it has never delivered before.
- 🔌 API, scheduling, monitoring, integrations (Make, Zapier, n8n, Google Sheets…), proxy rotation and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to scrape foodpanda and foodora

1. Create a free Apify account.
2. Open **Foodpanda & Foodora Restaurants Scraper**, choose the **Country** and type a **City** (e.g. `Kuala Lumpur`, `Makati`, `Praha`) — or add **More cities**, a **Map point**, or tick **Whole country**.
3. Or paste foodpanda / foodora URLs into **Start URLs** (city pages, restaurant pages), or restaurant codes into **Restaurant codes**.
4. Tick the options you need (**Include menu, opening hours and offers**, **Include reviews**), set **Max restaurants** (20 in the form, 100 through the API when left out, 0 = no limit) — and **Max restaurants per city** when you run several cities — then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to scrape foodpanda and foodora?

This Actor uses **pay per event** pricing (the same amounts are in the **Pricing** tab): **$0.89 per 1,000 restaurants** on the Free plan, down to **$0.86 on the Gold plan**, plus **$0.01 per run start**. You pay for the restaurants saved, and for each option only when it delivers something. Prices are per 1,000 events, by Apify plan (a higher plan pays less):

| What you pay for | Event | Free | Bronze | Silver | Gold |
| --- | --- | --- | --- | --- | --- |
| Restaurant saved (contact and company, address and map, rating, cuisines, delivery, offers and badges, status) | `apify-default-dataset-item` | $0.89 | $0.88 | $0.87 | $0.86 |
| Menu, opening hours and offers of a restaurant, only with **Include menu, opening hours and offers** (once per restaurant saved with them) | `restaurant-details` | $2.69 | $2.68 | $2.67 | $2.66 |
| Review, only with **Include reviews** (once per review saved) | `review` | $1.39 | $1.29 | $1.19 | $1.09 |
| Restaurant read, then dropped by one of the Actor's own filters | `filter-check` | $0.039 | $0.029 | $0.019 | $0.01 |
| Run start | `apify-actor-start` | $0.01 per run | $0.01 per run | $0.01 per run | $0.01 per run |

Examples on the Free plan: the first 1,000 restaurants of a city ≈ $0.90, run start included; the same 1,000 restaurants with their menu, opening hours and offers ≈ $3.59.

The two options are **off by default**: nothing is charged for them unless you tick them. The filters the app applies itself (cuisines, dietary tags, price levels, order type, type of shop) cost nothing extra. The others (keywords, minimum rating, minimum number of ratings, phone required, free delivery, discount, marked new, open now, independent only, searched city only, excluded words) are checked by the Actor: a restaurant one of them drops is not saved, not counted in **Max restaurants**, and costs only the `filter-check` fee; a restaurant kept pays its normal price only. The review filters never drop a restaurant, and a review they leave out is not charged. Platform usage (compute, proxy) is included in the price.

### ⚙️ Input

```json
{
    "country": "my",
    "location": "Kuala Lumpur",
    "maxItems": 200
}
```

Several cities, a cap per city, the menus and opening hours:

```json
{
    "country": "se",
    "locations": ["Stockholm", "Uppsala"],
    "maxItemsPerQuery": 100,
    "includeMenu": true
}
```

Japanese restaurants of Singapore rated 4.5 or more, with their reviews of the last 30 days:

```json
{
    "country": "sg",
    "location": "Singapore",
    "cuisines": ["Japanese"],
    "minRating": 4.5,
    "includeReviews": true,
    "maxReviewsPerRestaurant": 50,
    "postedAfter": "30 days"
}
```

Or with your own URLs and restaurant codes:

```json
{
    "startUrls": [
        { "url": "https://www.foodpanda.my/city/georgetown" },
        { "url": "https://www.foodpanda.sg/restaurant/q99e/an-acai-affair-haji-lane" }
    ],
    "country": "sg",
    "vendorCodes": ["r0t3", "x7hc"],
    "includeMenu": true
}
```

Only the restaurants that are new since the last run (schedule it daily):

```json
{
    "country": "ph",
    "location": "Makati",
    "onlyNew": true,
    "maxItems": 0,
    "stateKey": "makati-new"
}
```

| Field | Notes |
| --- | --- |
| `country` | Country of the cities, map points and restaurant codes: `sg`, `my`, `tw`, `hk`, `ph`, `pk`, `bd`, `kh`, `la`, `mm` (foodpanda), `se`, `no`, `at`, `cz`, `hu` (foodora). A city that only exists in another of the 15 countries switches to it. |
| `location`, `locations` | City to cover entirely, in English or in the local language (`Kuala Lumpur`, `Praha`, `Wien`), its slug in a foodpanda / foodora URL (`kuala-lumpur`), or a point `1.2897,103.8501`; `locations` adds more (max 100). The city list of each country is described under Tips. An API call with no place, code or URL at all runs a small sample instead: 20 restaurants of the largest city of `country`. |
| `wholeCountry` | The whole selected country in one search: every city of the country is a starting point, and the search grows around each one that has restaurants. **City** is then ignored (the form pre-fills it with Singapore), and the other cities and points of that country are left out (already covered); a city of another country in **More cities** is still searched. |
| `coordinates`, `radiusKm`, `gridStepKm` | `coordinates`: a map point latitude,longitude (latitude first, `1.2897,103.8501`). `radiusKm` 0 = automatic: a city is covered until no new restaurant of that city appears (at most 40 km from its center), a map point gives the restaurants that deliver to it, as in the app; above 0 (up to 50 km): the restaurants located within that distance of the city center or of the point. `gridStepKm` (1-10, default 3): distance between two search points; smaller finds the restaurants with a very small delivery zone, with more requests. |
| `query`, `searchQueries` | Keep the restaurants whose name, chain or cuisine contains one of these words (`pizza`, `sushi`; case and accents ignored). The apps have no keyword search: the area is read once whatever the number of words, and each restaurant dropped is a `filter-check`. |
| `startUrls` | City pages (`https://www.foodpanda.my/city/kuala-lumpur`), restaurant pages (`https://www.foodpanda.sg/restaurant/q99e/an-acai-affair-haji-lane`) or results pages with a location in them, of the 15 countries. When this list or the restaurant codes are not empty, the location fields are ignored. |
| `vendorCodes` | Restaurant codes of the selected country: the short code after /restaurant/ in a restaurant URL (`q99e`). Each restaurant is read directly, without any search (max 1,000). |
| `maxItems`, `maxItemsPerQuery` | Stop after this many restaurants for the whole run (`0` = unlimited), and for EACH city, map point or start URL (`0` = no per-city cap). |
| `includeMenu` | Add the menu, opening hours, special days, offers and vouchers, small-order and service fees, regular delivery fee before discount, food license, registered address and whether the kitchen is busy (1 more request per restaurant; charged as its own event, see Pricing). |
| `language` | `en` = English, `local` = the main local language of the country (Chinese in Taiwan and Hong Kong, Malay in Malaysia, Swedish in Sweden…) for cuisine names and menus; restaurant names stay as the restaurant wrote them. |
| `cuisines`, `foodCharacteristics` | Only these cuisines (`Pizza`, `Japanese`, `Burgers`) or dietary tags (`Halal`, `Vegetarian`), by name as the app shows them; several = any of them. Applied by the app, free. A name the app does not know stops the run before anything is charged, with the list of valid names. |
| `budgets`, `vertical`, `expeditionType` | Applied by the app, free: price levels; restaurants or the other shops of the app (shops, dark stores such as pandamart, grocery stores); delivery, pick-up or dine-in. |
| `sortBy` | Applied by the app, free: the order in which the restaurants of each search point are read — `rating_desc`, `distance_asc`. The app's default order is shuffled at every call: with a cap, two runs keep different restaurants, while `rating_desc` and `distance_asc` keep the same ones. |
| `minRating`, `minReviewCount` | Restaurants rated at least this (0-5, restaurants without a rating are dropped), and with at least this many ratings. |
| `requirePhone`, `freeDeliveryOnly`, `withDiscountOnly`, `newRestaurantsOnly`, `openNowOnly`, `excludeChains`, `cityOnly` | Only the restaurants with a phone number, with free delivery, with a discount or free delivery, marked new by the app, taking orders now, not part of a chain, or of the searched city (the grid of a city also meets restaurants of neighbouring towns; with several cities, a restaurant of any of them is kept). Free delivery is often an offer for the first order only. |
| `excludeKeywords` | Drop the restaurants whose name, chain, cuisine or address contains one of these WHOLE words (case and accents ignored): "art" drops "Art Cafe", not "Smart Kitchen". Several words in one entry ("hot pot") must appear together. |
| `includeReviews`, `maxReviewsPerRestaurant` | Add the reviews of each restaurant, newest first (charged per review, see Pricing); at most this many per restaurant (default 20; 0 = all the reviews the site shows: foodpanda and foodora keep about the last 12 months of written reviews). |
| `postedAfter`, `postedBefore` | Dates of the REVIEWS: a date (`2026-09-01`, the whole day included; days are UTC days, so in Singapore `2026-09-01` runs from 08:00 that day to 08:00 the next) or a period before now (`7 days`, `2 weeks`, `1 month`; via the API also `24 hours`). Restaurants are never dropped by them. |
| `minReviewRating`, `maxReviewRating`, `onlyWithText`, `onlyWithBusinessReply`, `reviewKeywords` | Reviews with an overall score of at least / at most this (1-5, 0 = all), with a text, answered by the restaurant, or containing one of these words. They never drop a restaurant. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the restaurants never delivered under this memory key (`kl-pizza`); `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

```json
{
    "id": "o0lj",
    "vendorId": 13972,
    "url": "https://www.foodpanda.my/restaurant/o0lj/dominos-pizza-dang-wangi",
    "name": "Domino's Pizza (Dang Wangi)",
    "brand": "foodpanda",
    "country": "MY",
    "city": "Kuala Lumpur",
    "address": "No 22, Jalan Dang Wangi, Kuala Lumpur",
    "postalCode": "50100",
    "latitude": 3.15570998,
    "longitude": 101.69999695,
    "phone": "+601300888333",
    "legalName": "DOMMAL FOOD SERVICES SDN BHD",
    "chainName": "Domino's Pizza",
    "rating": 4.8,
    "reviewCount": 3865,
    "cuisines": [
        "Pizza",
        "Chicken",
        "Halal Resto",
        "Pasta"
    ],
    "primaryCuisine": "Pizza",
    "foodCharacteristics": [
        "Halal"
    ],
    "budget": 3,
    "priceRange": "$$$",
    "currency": "MYR",
    "minimumOrderAmount": 20,
    "deliveryFee": 5.9,
    "deliveryTimeMinutes": 59,
    "pickupTimeMinutes": 15,
    "hasDiscount": true,
    "discounts": [
        "Up to 50% off"
    ],
    "isDeliveryAvailable": false,
    "isPickupAvailable": true,
    "timezone": "Asia/Kuala_Lumpur",
    "heroImage": "https://foodpanda.dhmedia.io/image/fd-my/LH/cb0hc-listing.jpg",
    "openingHours": [
        {
            "day": "Monday",
            "type": "delivery",
            "opens": "10:30",
            "closes": "23:30"
        }
    ],
    "specialDays": [],
    "menuItemCount": 106,
    "menu": [
        {
            "name": "New Cheese & Steak Pizza (Personal Pizza)!",
            "items": [
                {
                    "id": 2046757630,
                    "name": "Cheese & Steak Chicken Classic (Personal)",
                    "description": "Grilled chicken steak chunks, chicken sausage, and onions, loaded with rich grilled cheese sauce.",
                    "image": "https://foodpanda.dhmedia.io/image/global-menu-service/FP_MY/vendor/o6to/product/1981973007/35591e20-db31-4705-baa1-a6e97eea293a.jpg",
                    "price": 15.89,
                    "priceBeforeDiscount": 18.9,
                    "isSoldOut": false,
                    "isAlcoholic": false,
                    "dietaryTags": [],
                    "variations": [
                        {
                            "name": null,
                            "price": 15.89,
                            "priceBeforeDiscount": 18.9,
                            "optionGroupIds": [
                                139585544,
                                59807937
                            ]
                        }
                    ]
                }
            ]
        }
    ],
    "reviews": null,
    "scrapedAt": "2026-11-01T21:01:19.200Z"
}
```

This example is a real item (a restaurant pasted by its code, with the menu option), shortened: one opening hour and one dish are kept, and an item has all 77 fields below, `null` when the restaurant has no such data or the option is off. You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

#### All 77 fields

| Fields | What you get |
| --- | --- |
| `id`, `vendorId`, `url`, `name`, `brand`, `country` | **Restaurant**: code in its URL (unique within a country), numeric id, page link, name, `foodpanda` / `foodora`, country code — `q99e`, `SG` |
| `city`, `address`, `addressLine2`, `postalCode`, `latitude`, `longitude`, `timezone` | **Address and map**, as written by the restaurant — `44 Haji Lane`, `189237`, `Asia/Singapore` |
| `phone`, `legalName`, `tradeRegisterNumber` | **Contact and company** — `+6580206914`, `An Acai Affair (Haji Lane) Pte Ltd`, `202236694N` |
| `description`, `chainName`, `chainCode`, `heroImage`, `logo` | description, chain (null for an independent restaurant), cover photo (the one shown in the app's lists) and logo URLs |
| `rating`, `reviewCount` | **Rating** 0-5 (null without ratings) and exact number of ratings, also above a thousand (where the app shows `1000+`) — `5`, `688` |
| `cuisines`, `primaryCuisine`, `foodCharacteristics`, `budget`, `priceRange` | **Cuisines and price level**: the main cuisine first, then the others in alphabetical order — `["Dessert", "Healthy"]`, `Dessert`, `["Halal"]`, `2`, `$$` |
| `currency`, `minimumOrderAmount`, `deliveryFee`, `deliveryFeeType`, `deliveryTimeMinutes`, `pickupTimeMinutes`, `deliveryProvider` | **Delivery** — `SGD`, lowest delivery fee shown, shortest delivery time in minutes, `platform_delivery` (the platform's riders) or `vendor_delivery` (the restaurant's own); fee, minimum order and time are the site's live figures at the time of the run |
| `freeDelivery`, `hasDiscount`, `discounts`, `tags`, `isNew`, `newUntil`, `isSuperVendor`, `isPromoted`, `isPremium`, `isBestInCity`, `loyaltyPrograms`, `cashbackPercent` | **Offers and badges** — `Up to 50% off`, `Featured`; `isPromoted` = the restaurant pays to be shown first (`isPromoted` and `isPremium` are the paid placement of the moment and change from one call to the next); free delivery is often an offer for the first order only, and `hasDiscount` counts it as an offer |
| `isActive`, `isDeliveryEnabled`, `isPickupEnabled`, `isPreorderEnabled`, `hasOnlinePayment`, `isPreferredPartner`, `isMealForOne`, `pricesIncludeVat` | **Services**: what the restaurant offers on the app (`hasOnlinePayment` false = cash on delivery only) |
| `isDeliveryAvailable`, `isPickupAvailable`, `isTemporarilyClosed`, `closeReasons`, `isBusy` | **Status at the time of the run**, and why the restaurant does not take orders (`isBusy`: with the menu option); `isPickupAvailable` = the restaurant offers pick-up (same value as `isPickupEnabled`, not tied to the opening hours) |
| `vertical`, `verticalSegment` | type of shop — `restaurants`, `shop`, `darkstores`, `groceries` |
| `searchLocation`, `distanceKm` | **Search**: the city, map point or URL that found it, distance from the city center or map point in km (null for a whole country, restaurant codes and restaurant URLs) |
| `openingHours`, `specialDays` | **Hours** (option): one entry per day and service (delivery / pick-up) with opening and closing times; special days and closures from the day of the run on (past ones left out) |
| `offers`, `smallOrderFee`, `deliveryFeeBeforeDiscount`, `serviceFee` | **Offers and fees** (option): offers and vouchers with code, value, minimum order, dates and conditions; small-order fee; regular delivery fee before the discount; service fee with its minimum and maximum |
| `foodLicenseNumber`, `legalAddress`, `menuItemCount`, `menu`, `menuOptionGroups` | **Menu** (option): food license, registered address, number of dishes, categories → dishes (description, photo, price, price before discount, sizes, sold out, alcohol), add-on groups with their prices; prices rounded to the cent as the app shows them (in Taiwan the app shows whole dollars) |
| `reviews` | **Reviews** (option), newest first: date, text, author name as shown, scores, dishes ordered, likes, the restaurant's answer |
| `scrapedAt` | ISO timestamp of the extraction |

### 💡 Tips

#### How to get more results

Set **Max restaurants** to `0`, keep **Radius** at 0 (automatic) and list every city you need, or tick **Whole country**. A smaller **Grid step** (`1` or `2` km) also finds the small restaurants that deliver only around their street, with more requests. Restaurants found by several cities are saved once.

#### How to reduce costs

The price is per restaurant, so the levers are **Max restaurants**, **Max restaurants per city**, the filters of the app (free), the Actor's filters (a restaurant dropped costs only the filter fee, less than a restaurant) and **Only new restaurants** for recurring runs (you never pay twice for the same restaurant). The menu and the reviews are charged only when you tick them; **Max reviews per restaurant** caps the reviews.

#### Cities, map points and whole countries

A city is found in a table of 4,921 cities of the 15 countries: every town of 15,000 inhabitants or more, and every city foodpanda or foodora lists, by its English or local name or its slug in a city URL (`kuala-lumpur`). A city name that exists in several countries takes the selected **Country**; an unknown name stops the run with the closest names. For any other place, type its map point `latitude,longitude`. **Whole country** starts from every city of the table in that country (from 22 in Laos to 1,110 in Hungary) and grows around each one that has restaurants; a country holds tens of thousands of restaurants, so set **Max restaurants**. City data © [GeoNames](https://www.geonames.org/), licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

#### Monitoring: only the new restaurants

Tick **Only new restaurants** (`onlyNew`), set **Max restaurants** to 0 and schedule the Actor. The first run returns everything (with a cap, it returns only the first ones, and the later runs then bring restaurants not delivered yet rather than new ones); each later run skips the restaurants already delivered: they are not saved and not charged. The memory lives in a named key-value store of your account (`foodpanda-restaurants-scraper-seen`, up to 150,000 restaurants per key) and is only updated with restaurants that really reached the dataset, so a failed run never hides anything. Give each schedule its own `stateKey` (two schedules sharing a key would hide each other's restaurants), and tick `resetState` once to start over. Not the same as **Restaurants marked new only**, which keeps the restaurants the app marks as new.

#### Reviews by date

`postedAfter` and `postedBefore` select the reviews, never the restaurants: a restaurant without any review in the period is still saved, with an empty list of reviews. The reviews are read newest first and the reading stops at the first page entirely older than `postedAfter`, so a short period is fast. The apps show about the last 12 months of written reviews: older reviews cannot be read, even when the rating counts many more. Restaurants rarely answer their reviews: **Reviews with the restaurant's answer only** often leaves few of them.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per foodpanda or foodora restaurant. Actor id: `nice_dev/foodpanda-restaurants-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/foodpanda-restaurants-scraper`.

Smallest input, for a cheap first call:

```json
{
    "country": "sg",
    "location": "Singapore",
    "maxItems": 10
}
```

Key output fields: `name`, `phone`, `legalName`, `address`, `latitude`, `longitude`, `rating`, `cuisines`, `deliveryFee`, `url`.

Cost: $0.89 per 1,000 restaurants plus $0.01 per run start ($0.86 per 1,000 on the Gold plan); the menu, opening hours and offers (`restaurant-details`, $2.69 per 1,000) and the reviews (`review`, $1.39 per 1,000) only when ticked, see the pricing section above. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape foodpanda and foodora?

The Actor only reads what foodpanda and foodora show publicly to any anonymous visitor of their apps and websites. It logs in to nothing. Results contain business data published by the restaurants (phone number, company name and number) and, with the reviews, the names reviewers chose to show; personal data is protected by GDPR and similar laws: do not store it without a legitimate reason. You are responsible for using the data in compliance with the Terms of Use of foodpanda and foodora and with applicable law. This Actor is not affiliated with foodpanda, foodora or Delivery Hero.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Is the data safe to open in Excel or to show on a web page?

Names, descriptions, menus and reviews are the restaurants' and reviewers' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@`, and phone numbers nearly always do: they come in international form (`+601300888333`; 298 of 298 phones of a test run in Kuala Lumpur, 5 of 5 in Stockholm). Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. On a web page, escape every field like any text written by a stranger.

#### Known limitations

- The apps list a restaurant at the points it delivers to (with **Order type** pick-up: near it): a restaurant that delivers to no point of the searched area is not found by a city search; paste its code or URL instead.
- `distanceKm` is measured from the city center or the map point of the search; for a whole country, restaurant codes and restaurant URLs it is `null`.
- Restaurants pasted by code or URL have no `hasOnlinePayment`, `isPreferredPartner`, `isMealForOne`, `isPromoted`, `loyaltyPrograms` nor `deliveryProvider` (the app shows them only in its lists), and their minimum order, delivery fee, fee before discount and delivery time are the site's figures without a delivery address (they can differ from a search near an address); the restaurant page may also lack the trade register number and the promotion labels of the lists (`tags`).
- `onlyNew` remembers restaurant codes, not their content: a restaurant whose rating or menu changed is not returned again.
- Two runs sharing the same `stateKey` at the same time may both return the same new restaurant.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options). At about 45 to 50 restaurants a minute with **Include menu, opening hours and offers**, the default timeout (1 hour) holds about 2,600 to 3,000 restaurants; without the menu, 1,000 restaurants take about 5 seconds.

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the restaurants already saved are skipped: none is delivered or charged twice, and **Max restaurants** still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the restaurants it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the restaurants of its last 2 seconds once more.

#### Something doesn't work?

The last line of the log counts the restaurants saved, filtered out and no longer on the app, and the requests that failed after every retry. Those requests and the restaurants gone are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause. A city where no restaurant delivers says so in the log (`no restaurant delivers around here`), instead of ending with an empty dataset and no word.

If foodpanda or foodora change their data, you are told instead of paying for blank rows. If the first 20 restaurants read all lack their name, numeric id, GPS point or page link, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first restaurants are charged. A run of fewer restaurants (a scheduled `onlyNew` run that finds a few new ones, a small **Max restaurants**) is checked at its end, from 5 restaurants: its restaurants are already saved, and the run fails with the missing field instead of ending green.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which URLs failed and why.

# Actor input Schema

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

foodpanda or foodora URLs of the 15 countries: a city page (`https://www.foodpanda.my/city/kuala-lumpur`), a restaurant page (`https://www.foodpanda.sg/restaurant/q99e/an-acai-affair-haji-lane`) or a results page with a location in it (`https://www.foodpanda.sg/restaurants/new?lat=1.2897&lng=103.8501`). The country is read from the domain. When this list or **Restaurant codes** is not empty, the location fields below are ignored; filters, caps, menus, reviews and monitoring still apply. Max 1 000 URLs.

## `vendorCodes` (type: `array`):

Restaurant codes of the selected **Country**: the short code after `/restaurant/` in a restaurant URL (e.g. `q99e`). Each restaurant is read directly, without any search. Added to **Start URLs**: the location fields below are then ignored. Max 1 000.

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

Country of the cities, points and restaurant codes below. A city name that only exists in another of the 15 countries switches to that country.

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

City to cover entirely: name in English or in the local language (`Kuala Lumpur`, `Makati`, `Praha`), city slug of a foodpanda / foodora URL (`kuala-lumpur`), or a point `latitude,longitude`. The Actor searches a grid of points from the city center outwards, so the whole city is covered, not only one address. Empty = the fields below.

## `locations` (type: `array`):

Several cities (or `latitude,longitude` points) in one run, added to **City**. Restaurants found by several cities are saved once. Max 100.

## `wholeCountry` (type: `boolean`):

Search the whole selected **Country** in one go: the grid starts in every city of the country (how the cities of each country are chosen is in the README) and grows around each one that has restaurants. **City** is then ignored (the form pre-fills it with an example): to search another city as well, put it in **More cities**; the cities and points of that country are left out (already covered). Large: tens of thousands of restaurants in the big countries; use **Max restaurants** to cap the run.

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

foodpanda and foodora have no keyword search: the Actor reads the whole area and keeps the restaurants whose name, chain or cuisine contains this word (e.g. `pizza`, `McDonald's`, `sushi`; case and accents ignored). Each restaurant it drops is charged as a *Filter check* event, see Pricing. Empty = all restaurants.

## `searchQueries` (type: `array`):

Several keywords, added to **Keyword**: a restaurant is kept when it matches any of them. The area is read once whatever the number of keywords.

## `coordinates` (type: `string`):

Search around this point instead of a city: `latitude,longitude` in decimal degrees, latitude FIRST (e.g. `1.2897,103.8501` = Singapore center). With **Radius** 0: the restaurants that deliver to this point, as in the app; with a radius: the restaurants located within it. Uses the selected **Country**.

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

0 = automatic. For a city: the grid of search points grows from the city center, point by point, and stops in a direction after two points in a row bring no new restaurant of that city (at most 40 km). For a map point: that point only. Above 0: the restaurants located within this distance of the city center or of the map point (up to 50 km).

## `gridStepKm` (type: `number`):

Distance between two search points. foodpanda and foodora only list the restaurants that deliver to a given point, so an area is covered by a grid of points; a smaller step also finds the restaurants with a very small delivery zone, with more requests.

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

Maximum number of restaurants to save for the whole run (after deduplication and filters). 0 = no limit.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH city, map point or start URL, so that the first one cannot use up the whole **Max restaurants** budget. 0 = no per-city cap.

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

Add the full menu of each restaurant (categories, dishes with description, photo, price and price before discount, sizes, add-ons with their prices, sold-out and alcohol flags), its opening hours and special days, current offers, small-order fee, food license and legal address (1 extra request per restaurant). Charged as a separate event, see Pricing. Off = those fields are null.

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

Language of cuisine names and menus: English or the main local language of the country (Chinese in Taiwan and Hong Kong, Malay in Malaysia, Swedish in Sweden…). Restaurant names stay as the restaurant wrote them.

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

Only restaurants of these cuisines, by name as shown on foodpanda / foodora (e.g. `Pizza`, `Japanese`, `Burgers`); several = any of them. Applied by the site, no extra cost. A name the site does not know stops the run with the list of valid names.

## `foodCharacteristics` (type: `array`):

Only restaurants with these tags, by name as shown on the site (e.g. `Halal`, `Vegetarian`). Applied by the site, no extra cost. A name the site does not know stops the run with the list of valid names.

## `budgets` (type: `array`):

Only restaurants of these price levels. Applied by the site. Empty = all.

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

Restaurants, or the other shops of the app: shops (flowers, pharmacies, electronics…), the app's own dark stores (pandamart, foodora market) or grocery stores.

## `expeditionType` (type: `string`):

Restaurants that deliver to the search points (default), that offer pick-up near them, or that take dine-in orders (very few).

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

Order in which the restaurants of each search point are read (and cut by the caps). Distance is not strict on the site.

## `minRating` (type: `number`):

Only restaurants rated at least this (0-5, e.g. `4.5`). Restaurants without a rating are dropped. 0 = no minimum.

## `minReviewCount` (type: `integer`):

Drop the restaurants with fewer ratings than this. 0 = no minimum.

## `requirePhone` (type: `boolean`):

Drop the restaurants without a phone number (the site shows none in the Philippines, Hong Kong and Pakistan).

## `freeDeliveryOnly` (type: `boolean`):

Only restaurants showing free delivery at the time of the run.

## `withDiscountOnly` (type: `boolean`):

Only restaurants running an offer at the time of the run: a discount (e.g. `Up to 50% off`) or free delivery.

## `newRestaurantsOnly` (type: `boolean`):

Only restaurants the site marks as new on the platform. Not the same as **Only new restaurants** (monitoring) below.

## `openNowOnly` (type: `boolean`):

Only restaurants taking orders at the time of the run (delivery or pick-up available, not temporarily closed).

## `excludeChains` (type: `boolean`):

Drop the restaurants that belong to a chain (a chain name on the site).

## `cityOnly` (type: `boolean`):

For a city search: drop the restaurants of neighbouring towns that the grid meets near the city limits (city as written by the site in the `city` field). With several cities, a restaurant of any of them is kept.

## `excludeKeywords` (type: `array`):

Drop the restaurants whose name, chain, cuisine or address contains one of these WHOLE words (case and accents ignored): `art` drops "Art Cafe" but keeps "Smart Kitchen". Several words in one entry (`hot pot`) must appear together, in that order. Chinese, Japanese, Korean, Thai, Lao, Khmer and Burmese words are found anywhere in the text (no spaces there).

## `includeReviews` (type: `boolean`):

Add the reviews of each restaurant (30 per request): date, text, author name as shown, overall / food / rider scores, dishes ordered, likes and the restaurant's answer. Charged per review as a separate event, see Pricing.

## `maxReviewsPerRestaurant` (type: `integer`):

Maximum number of reviews per restaurant, newest first. 0 = all the reviews the site shows (it keeps about the last 12 months of written reviews), up to 6,000.

## `postedAfter` (type: `string`):

Only reviews written on or after this date: `2026-09-01` (a UTC day), or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too). Restaurants are never dropped by this filter.

## `postedBefore` (type: `string`):

Only reviews written on or before this date (the whole UTC day is included), or older than a period such as `30 days`.

## `minReviewRating` (type: `integer`):

Only reviews whose overall score is at least this (1-5). 0 = all.

## `maxReviewRating` (type: `integer`):

Only reviews whose overall score is at most this (e.g. `2` = complaints only). 0 = all.

## `onlyWithText` (type: `boolean`):

Drop the ratings without any text.

## `onlyWithBusinessReply` (type: `boolean`):

Keep only the reviews the restaurant answered.

## `reviewKeywords` (type: `array`):

Keep only the reviews whose text contains one of these words (case and accents ignored).

## `onlyNew` (type: `boolean`):

Skip the restaurants that a previous run (same **Memory key**) already delivered: they are not saved and not charged. First run = everything is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new restaurants**. Give each schedule / task its own key (e.g. `kl-pizza`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every restaurant again. Untick it afterwards.

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

Apify Proxy or your own proxies. Keep the default: the Apify Proxy is included in the price and works for this site. The residential Apify proxy is not available in this Actor.

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

Maximum number of requests processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to the site in any 60 seconds, all of them counted: result pages, menu pages and review pages. A budget, not an even pace: up to this many can leave at once when the minute starts (spread them with the minimum delay below). Lower it if the site answers HTTP 429 / 403 in the log.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked as failed. Behind a proxy, a request the site turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "vendorCodes": [],
  "country": "sg",
  "location": "Singapore",
  "locations": [],
  "wholeCountry": false,
  "searchQueries": [],
  "radiusKm": 0,
  "gridStepKm": 3,
  "maxItems": 20,
  "maxItemsPerQuery": 0,
  "includeMenu": false,
  "language": "en",
  "cuisines": [],
  "foodCharacteristics": [],
  "budgets": [],
  "vertical": "restaurants",
  "expeditionType": "delivery",
  "sortBy": "default",
  "minRating": 0,
  "minReviewCount": 0,
  "requirePhone": false,
  "freeDeliveryOnly": false,
  "withDiscountOnly": false,
  "newRestaurantsOnly": false,
  "openNowOnly": false,
  "excludeChains": false,
  "cityOnly": false,
  "excludeKeywords": [],
  "includeReviews": false,
  "maxReviewsPerRestaurant": 20,
  "minReviewRating": 0,
  "maxReviewRating": 0,
  "onlyWithText": false,
  "onlyWithBusinessReply": false,
  "reviewKeywords": [],
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 240,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

## `results` (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 = {
    "country": "sg",
    "location": "Singapore",
    "maxItems": 20,
    "includeMenu": false,
    "includeReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/foodpanda-restaurants-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 = {
    "country": "sg",
    "location": "Singapore",
    "maxItems": 20,
    "includeMenu": False,
    "includeReviews": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/foodpanda-restaurants-scraper").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 '{
  "country": "sg",
  "location": "Singapore",
  "maxItems": 20,
  "includeMenu": false,
  "includeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/foodpanda-restaurants-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/foodpanda-restaurants-scraper"
        }
    }
}
```

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/kLBRcJxrWfNsMdcrG/builds/cjggMIzLL9Ne3JdmY/openapi.json
