September 25, 2026 · 13 min read

Foodpanda Restaurant & Menu Scraper: Up to 2,500 Free Results a Month

Each vendor record carries 24 fields, covering ratings, delivery fees, minimum orders, and full nested menus across Singapore, Bangladesh, Pakistan, Hong Kong, and Malaysia. Results cost $2.00 per 1,000 results on the free plan, which equals $0.002 per result written to your dataset. Direct API access avoids browser overhead while using automated country-targeted residential proxies. This tool serves teams analyzing delivery market density, catalog availability, and regional restaurant pricing. It is not for teams seeking consumer contact details or private user order histories, as the platform does not expose these endpoints.

Try it: open Foodpanda Restaurant & Menu Scraper on Apify, sign in on the free plan and run the prefilled example.

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.002 per result, that covers up to 2,500 results of Foodpanda Restaurant & Menu Scraper a month, before run-start charges and platform usage.

The example request further down caps maxRestaurants at 5, so a first run returns at most 5 results and costs at most $0.01 in result charges. That is enough to see the real shape of the data before deciding anything.

Foodpanda Restaurant & Menu Scraper was last updated on 2026-04-14. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 674,790 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.002	$2.00
BRONZE	$0.00167	$1.67
SILVER	$0.00133	$1.33
GOLD	$0.001	$1.00
PLATINUM	$0.001	$1.00
DIAMOND	$0.001	$1.00

The primary control driving costs is maxRestaurants in Discovery mode or the length of restaurantUrls in URL mode, because charges apply only to results written to the dataset. Setting includeMenu to true attaches nested categories and items to existing restaurant objects without generating additional dataset result fees. The cheapest way to test your setup is running the example input, which caps maxRestaurants at 5 and costs at most $0.01 in result charges.

None of its 11 controls is strictly required, so the defaults below produce a valid run on their own. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Foodpanda Restaurant & Menu Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~foodpanda-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"restaurantUrls":["https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio"],"radiusKm":3,"maxRestaurants":5,"maxItemsPerRestaurant":10,"vendorTypes":["restaurant"]}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

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

run = client.actor("crawlerbros~foodpanda-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

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

const run = await client.actor('crawlerbros~foodpanda-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

The input schema provides 11 controls, of which 0 are required. The primary parameters that define your dataset are restaurantUrls for direct URL mode, or country combined with latitude, longitude, city, or cityPageUrl for Discovery mode. For initial runs, keep radiusKm at its default 3 km and avoid tweaking maxItemsPerRestaurant until you confirm the vendor output structure.

restaurantUrls (array): URL mode: one or more Foodpanda restaurant page URLs. The actor auto-detects the country from the domain. Example: https://www.foodpanda.sg/restaurant/en/m3jj-mcdonalds-ang-mo-kio
latitude (number): Discovery mode: decimal latitude of the search centre. Requires 'longitude' and 'country' to also be set.
longitude (number): Discovery mode: decimal longitude of the search centre. Requires 'latitude' and 'country' to also be set.
cityPageUrl (string): Discovery mode: a Foodpanda city or listing URL (e.g. https://www.foodpanda.sg/restaurants/new/). Country and coordinates are extracted automatically.
city (string): Discovery mode: city name resolved via built-in lookup table. Examples: Singapore, Karachi, Dhaka, Lahore, Kuala Lumpur, Hong Kong, Penang. Requires 'country' to also be set.
country (string): Required for Discovery mode with lat/lon or city name.
radiusKm (number): Discovery mode: radius around the resolved location in kilometres. Default: 3.
maxRestaurants (integer): Discovery mode: maximum number of vendors to scrape. Default: 50.
includeMenu (boolean): Whether to fetch full menu data for each restaurant. Defaults to true for URL mode and false for Discovery mode when not explicitly set.
maxItemsPerRestaurant (integer): Maximum number of menu items to extract per restaurant. Only applies when Include Menu is enabled. Default: 200.
vendorTypes (array): Discovery mode: filter by vendor type. Leave empty to include all types.

Fixed-choice controls: country accepts sg (Singapore), bd (Bangladesh), pk (Pakistan), hk (Hong Kong), my (Malaysia).

The output supplies structured vendor profiles including vendorCode, cuisines, deliveryFee, minimumOrder, and nested menu arrays with item prices and dietary tags. It conspicuously omits buyer accounts, internal sales metrics, and private operator contact info.

What data does it extract?

vendorCode: Foodpanda's internal restaurant ID
vendorUrl: Direct link to the restaurant page
name: Restaurant name
rating: Aggregate star rating (e.g. 4.9)
reviewCount: Number of customer reviews
cuisines: Cuisine tags (e.g. Fast Food, Halal, Chicken)
vendorType: Vendor category (restaurant, grocery, etc.)
isOpen: Whether currently open for delivery
address: Full street address
city: City (when available)
country: Country code (sg, bd, pk, hk, my)
latitude / longitude: Venue coordinates
deliveryFee: Delivery fee in local currency
minimumOrder: Minimum order value
estimatedDeliveryTime: Delivery ETA (e.g. "30-45 min")
currency: Currency code (SGD, BDT, PKR, HKD, MYR)
heroImageUrl: Restaurant banner/logo image URL
menu: Full nested menu (when enabled)
menuCategoryCount: Number of menu categories
menuItemCount: Total menu items
itemsWithImageCount: Items that have images
itemsWithDescCount: Items that have descriptions
scrapedAt: Scrape timestamp (UTC ISO-8601)

Menu item fields

itemId: Product ID
name: Item name
description: Item description
price: Price in local currency (e.g. 9.70)
currency: Currency code
imageUrl: Item image URL
isAvailable: Whether currently available
dietaryAttributes: Dietary tags (e.g. halal, vegetarian)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Foodpanda Restaurant & Menu Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Verify that your target area falls within one of the five supported country codes: sg, bd, pk, hk, or my.
Choose URL mode by populating restaurantUrls with target links, or choose Discovery mode by supplying country with latitude and longitude, city, or cityPageUrl.
Set includeMenu to true if you need item-level catalog data, or leave it false to return only high-level vendor records.
Cap your initial execution by setting maxRestaurants to 5 and maxItemsPerRestaurant to 10.
Run the Actor once and verify that the returned dataset items contain valid vendorCode, currency, and address values.
Inspect the nested menu array on returned records to confirm itemId and price are populated before increasing maxRestaurants.

How do you apply it? Three worked playbooks

These are Foodpanda Restaurant & Menu Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Menu database

Outcome: Build a database of restaurant menus for comparison or analysis

Configure: Set restaurantUrls to a list of target Foodpanda links, includeMenu to true, and maxItemsPerRestaurant to 200.

Working method: Execute a single test URL to confirm the menu array outputs valid item names and prices. Once verified, feed the broader list of URLs into restaurantUrls and parse the nested category structures into your downstream table.

Deliverable: A structured dataset export containing vendor details and nested item-level records with prices, descriptions, and dietary tags.

Stop condition: Abort if menu arrays arrive empty across consecutive restaurants while includeMenu is enabled.

Use case 2: Competitor research

Outcome: Track competitor pricing, menu changes, and delivery fees over time

Configure: Populate restaurantUrls with specific competitor profile links, set includeMenu to true, and schedule recurrent runs.

Working method: Run the Actor on a fixed schedule against the chosen restaurantUrls. Compare each run's deliveryFee, minimumOrder, and individual item price values against the previous snapshot to detect localized price shifts.

Deliverable: A time-series dataset of competitor pricing, delivery fee adjustments, and menu item availability.

Stop condition: Stop the workflow if deliveryFee or currency returns unexpected null values across target profiles.

Use case 3: Restaurant discovery

Outcome: Find all restaurants in a neighbourhood with their ratings and cuisines

Configure: Set city to 'Singapore', country to 'sg', radiusKm to 3, maxRestaurants to 50, and vendorTypes to ['restaurant']. Leave includeMenu set to false.

Working method: Start with a tight radiusKm around your target city or coordinates. Inspect the returned vendor list to ensure vendorCode, rating, cuisines, and address populate accurately before expanding radiusKm.

Deliverable: A directory export containing local restaurant profiles, aggregate ratings, review counts, and physical addresses.

Stop condition: Halt execution if zero restaurants are returned for a known active city and country combination.

What breaks, and how do you design around it?

When querying broad geographic areas in Discovery mode, single-point searches may hit location boundaries; split wide coverage zones into coordinate points or distinct cityPageUrl inputs. If certain menu items omit descriptions or images, handle those fields as optional in your ingestion pipeline rather than failing the run. To manage high-volume discovery tasks, space scheduled runs across intervals to account for session-based rate limiting.

Do not use this Actor if you need restaurant coverage outside Singapore, Bangladesh, Pakistan, Hong Kong, or Malaysia. For North American delivery platforms, use DoorDash Restaurant Scraper or Grubhub Restaurant Scraper. If your target region covers Latin America or Europe, choose Rappi Restaurant Scraper or Glovo Restaurant Scraper. For municipal sanitation grades rather than online delivery menus, collect official data directly using NYC Restaurant Inspection Scraper.

What should you check before trusting the output?

Halt execution if vendorCode is missing or null on returned vendor records.
Verify that the currency field matches the regional code, such as SGD for Singapore or PKR for Pakistan.
Flag any record where includeMenu is true but menuCategoryCount is 0 or menu is missing.
Alert if price is negative or non-numeric on available menu items.
Stop scheduled runs if scrapedAt fails to parse as a UTC ISO-8601 timestamp.

None of this proves a record is correct. It gives a scheduled Foodpanda Restaurant & Menu Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What does running this Actor cost on the free plan?

Results cost $2.00 per 1,000 results on the free-plan price, which equals $0.002 per result. In addition, Apify charges a run-start fee of $0.005 per GB of Actor memory on every run, plus platform compute usage. Up to 2,500 results are covered monthly under Apify's free plan.

Which countries does the scraper support?

The Actor supports five countries: Singapore (sg), Bangladesh (bd), Pakistan (pk), Hong Kong (hk), and Malaysia (my). You select the target region via the country parameter or by supplying restaurant URLs from those local Foodpanda domains.

Do I need to configure proxies or login details?

No login credentials or manual proxy setup are required. A country-targeted Apify residential proxy is hardcoded and applied automatically to bypass Foodpanda's PerimeterX bot protection.

Can I scrape grocery and convenience store listings?

Yes. In Discovery mode, you can adjust the vendorTypes control to include 'grocery' or 'convenience', or leave it empty to collect all available vendor categories in the area.

Why do some returned menu items lack descriptions?

Foodpanda relies on vendor-supplied item details. When a restaurant does not upload descriptions or images for specific items, those fields are simply omitted from the returned menu items.

Where to go next

When you are ready to run it, open Foodpanda Restaurant & Menu Scraper on Apify; the free plan covers up to 2,500 results a month.

Start with the Foodpanda Restaurant & Menu Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

Grubhub Restaurant Scraper: Scrape Grubhub restaurant listings and menus.
Watsons Health & Beauty Scraper: Scrape Watsons Asia health and beauty products across Singapore, Malaysia, and Hong Kong.
DoorDash Restaurant Scraper: Extract restaurant info + complete menus from DoorDash store pages like name, address, cuisine, breadcrumbs, FAQ, and full menu sections with item names, descriptions, and prices.
Glovo Restaurant Scraper: Scrape Glovo restaurant listings across Europe & Africa.
NYC Restaurant Inspection Scraper: Scrape the official NYC DOHMH Restaurant Inspection Results open dataset.
Rappi Restaurant Scraper: Scrape Rappi restaurant listings across Latin America.
Google Maps Menu Scraper: Extract restaurant menu items, popular dishes, photos, categories, and external menu links from any Google Maps place page.
UberEats Menu Scraper: Scrape full restaurant menus from UberEats.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-25.
Actor last updated by its maintainers on 2026-04-14.
Run outcome figures cover the 30 day public window ending 2026-09-25.
Foodpanda Restaurant & Menu Scraper on Apify

Featured actors

Foodpanda Restaurant & Menu Scraper

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

Run on Apify ↗