Scrape Talabat Restaurant Menus for Price Monitoring (2026)

Q: Can I scrape specific restaurants without searching?

Yes. Pass restaurant slugs directly via the restaurantSlugs input. The slug is the last segment of a Talabat URL — for talabat.com/uae/blue-fig the slug is blue-fig. This skips search entirely and is the cheapest way to monitor a fixed competitor list.

Published April 27, 2026 · 1542 words · For ops

Thirdwatch's Talabat Scraper extracts restaurant menus and prices across all nine Talabat markets at $0.002 per restaurant, including 130+ menu items per restaurant with no per-item surcharge. Pure HTTP, no proxy, no browser. Built for ops and pricing analysts who need daily price monitoring across the UAE, Saudi Arabia, Kuwait, Bahrain, Oman, Qatar, Jordan, Egypt, and Iraq.

Why scrape Talabat menus for price monitoring

Restaurant chains in the Middle East are losing margin to silent menu-price changes by competitors and by their own franchisees. Talabat is the dominant aggregator across MENA — Delivery Hero, Talabat's parent, processed over $14B in gross merchandise value in 2024 — which means Talabat's catalog is the single most accurate snapshot of what people are actually paying for food in the region. A McDonald's manager in Dubai can verify within seconds whether KFC raised the price of its 8-piece bucket in Riyadh. A chain operations team can detect when one of its 60 franchise locations drifts from the master price list. None of this needs to be done manually if you can pull the data on a schedule.

Manual menu checks don't scale past a handful of restaurants. By the time a price-monitoring analyst has finished tabulating five chains, four of them have changed an item. The job-to-be-done is daily, structured, machine-readable: pull every restaurant's menu, diff against yesterday's, alert on changes. That is what Thirdwatch's Talabat Scraper exists for. The same pipeline doubles as a market-entry research tool — a chain considering an Egypt launch can pull the entire Cairo restaurant catalog in under an hour, segment by cuisine, and benchmark proposed prices against the existing competitive distribution before signing a single lease.

How does this compare to the alternatives?

Three honest options for getting Talabat menu data:

Approach	Cost per 1,000 restaurants	Reliability	Setup time	Maintenance
DIY Python (httpx + Next.js data API)	Free compute, ~6 hrs of dev	Breaks on Talabat frontend updates	1–2 days	You own every Next.js manifest change
Generic scraping API (Bright Data, ScraperAPI)	$5–$15 (proxy + parsing)	High, but you still parse the JSON yourself	4–6 hrs	You own the parser
Thirdwatch Talabat Scraper	$2 ($0.002 × 1,000)	Production-tested, 27K+ restaurants in UAE alone	5 minutes	Thirdwatch monitors and patches upstream changes

Picking the actor is the obvious call when prices are the deliverable, not the scraping. The Talabat Scraper actor page documents every input field and output schema, but the short version: it uses Talabat's own Next.js data API directly — no headless browser, no residential proxy, no captcha solving — which is why the unit cost is an order of magnitude cheaper than a generic scraping API.

How to scrape Talabat menus in 4 steps

Step 1: How do I get an Apify API token?

Sign in at apify.com (free tier, no credit card), open Settings → Integrations, and copy your personal API token. Every example below uses an environment variable named APIFY_TOKEN. Set it once:

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: How do I run the actor for one country with menu data?

Call Apify's run endpoint with a JSON body that mirrors the actor's input schema. The two settings that matter for menu monitoring are scrapeMenu: true (otherwise you get restaurant metadata only) and the country code.

import os, requests

ACTOR = "thirdwatch~talabat-scraper"
TOKEN = os.environ["APIFY_TOKEN"]

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={
        "queries": ["pizza"],
        "country": "uae",
        "maxResults": 50,
        "scrapeMenu": True,
    },
    timeout=600,
)
restaurants = resp.json()
print(f"{len(restaurants)} restaurants, "
      f"{sum(len(r.get('menu_items', [])) for r in restaurants)} menu items")

run-sync-get-dataset-items blocks until the run finishes and returns the dataset directly — convenient for ad-hoc scripts. For scheduled monitoring use the async runs endpoint and read the dataset when the run completes.

Step 3: How do I monitor specific restaurants without searching?

Pass slugs directly. This is the cheapest mode because the actor skips search and goes straight to the menu API for each restaurant. A slug is the last URL segment — talabat.com/uae/blue-fig → blue-fig.

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={
        "restaurantSlugs": ["blue-fig", "pizza-hut", "kfc-uae"],
        "country": "uae",
        "scrapeMenu": True,
    },
)

For a 50-restaurant competitor watchlist this run costs 50 × $0.002 = $0.10 and completes in roughly two minutes.

Step 4: How do I diff today's prices against yesterday's?

Persist each run's output keyed by (country, slug, item_name) and compare across days. A minimal pandas pipeline:

import pandas as pd

rows = []
for r in restaurants:
    for item in r.get("menu_items", []):
        rows.append({
            "country": r["country"],
            "slug": r["slug"],
            "name": item["name"],
            "price": item["price"],
            "scraped_at": r["scraped_at"],
        })
df = pd.DataFrame(rows)
df.to_parquet(f"talabat-{pd.Timestamp.utcnow().date()}.parquet")

# Diff against yesterday
yest = pd.read_parquet("talabat-2026-04-26.parquet")
merged = df.merge(yest, on=["country", "slug", "name"], suffixes=("_today", "_yest"))
changes = merged[merged.price_today != merged.price_yest]
print(changes[["country", "slug", "name", "price_yest", "price_today"]])

For a no-code version, schedule the actor in Apify Console (Actor → Schedule → daily) and pipe the dataset to a Google Sheet via Apify's Sheets integration. The diff lives in a sheet formula.

Sample output

A single restaurant record with menu data enabled looks like this. Five records of this shape weigh ~12 KB on the wire.

{
  "name": "Pizza Hut",
  "slug": "pizza-hut",
  "cuisine": "Pizza, Italian, Fast Food",
  "rating": 4.2,
  "total_ratings": 15420,
  "latitude": 25.2048,
  "longitude": 55.2708,
  "accepts_cash": true,
  "accepts_card": true,
  "most_selling_items": ["Pepperoni Pizza", "Margherita", "Chicken Supreme"],
  "country": "uae",
  "url": "https://www.talabat.com/uae/pizza-hut",
  "menu_items": [
    {
      "name": "Pepperoni Pizza (Large)",
      "description": "Classic pepperoni with mozzarella on a hand-tossed crust.",
      "price": 49.0,
      "old_price": 59.0,
      "category": "Pizzas",
      "image": "https://images.deliveryhero.io/.../pepperoni-large.jpg",
      "has_choices": true
    }
  ],
  "scraped_at": "2026-04-27T08:14:22.000000+00:00"
}

price is in the country's local currency (AED for uae, SAR for sa, KWD for kw, etc.). old_price is populated only when the restaurant is running a discount — which makes detection of promotional pricing trivial: filter for old_price > price. has_choices: true flags items with size/add-on customisations; flip on scrapeMenuChoices if you need that detail too.

Common pitfalls

Three things go wrong in any production menu-monitoring pipeline. Slug drift — restaurants occasionally change their slug after a rebrand, breaking your watchlist. Catch this by alerting on runs that return zero items for a known slug. Country-specific currency confusion — a daily diff that mixes UAE AED with Saudi SAR will produce nonsense; always group by country before comparing. Discount-driven false positives — a "price change" alert during Ramadan or seasonal promotions will be 90% noise; filter to changes where old_price is unchanged or the discount delta exceeds a threshold.

Thirdwatch's actor handles each of these at the data layer: every record carries country, slug, and old_price, so the schema lets you filter and group correctly without joining external metadata. A fourth subtle issue — duplicate listings when a chain operates multiple branches under nearly identical names — is best handled downstream by deduping on (latitude, longitude) rounded to four decimal places, which the actor surfaces directly on every record.

Related use cases

Frequently asked questions

How much does it cost to scrape Talabat menus?

Thirdwatch's Talabat Scraper charges $0.002 per restaurant on the FREE tier and drops to $0.001 at GOLD volume. Menu data is included in that price — there is no per-item upcharge unless you also fetch customizable choices, which bills separately at $0.0005 per item.

Which countries does Talabat data cover?

All nine Talabat markets: UAE, Saudi Arabia, Kuwait, Bahrain, Oman, Qatar, Jordan, Egypt, and Iraq. The actor accepts a country code per run and returns localised restaurant catalogs, GPS coordinates, and prices in the local currency.

How fresh is the menu data?

Each run pulls live data from Talabat's public Next.js data API at request time. There is no cache and no stale snapshot — prices reflect the moment your query executes. For continuous monitoring, schedule the actor to run daily or hourly via Apify's built-in scheduler.

Can I scrape specific restaurants without searching?

Yes. Pass restaurant slugs directly via the restaurantSlugs input. The slug is the last segment of a Talabat URL — for talabat.com/uae/blue-fig the slug is blue-fig. This skips search entirely and is the cheapest way to monitor a fixed competitor list.

Does the actor handle Talabat's anti-bot defenses?

Talabat exposes restaurant and menu data through its public Next.js data API without aggressive bot defense, so the actor uses pure HTTP without browser automation or proxies. That keeps costs low and uptime high. Thirdwatch monitors for upstream changes and patches within hours when Talabat ships a frontend update.

What's the difference between scrapeMenu and scrapeMenuChoices?

scrapeMenu returns the full menu — items with names, prices, descriptions, images, and categories. scrapeMenuChoices additionally pulls the choice tree for customisable items (sizes, add-ons, extras with their own prices). Most price-monitoring use cases need only scrapeMenu; turn on scrapeMenuChoices only when tracking customisation pricing matters.

Run the Talabat Scraper on Apify Store — pay-per-restaurant, free to try, no credit card to test.