# Talabat Restaurants Scraper (`automation-lab/talabat-restaurant-listings-scraper`) Actor

Extract Talabat restaurant listings for assortment and competitor monitoring.

- **URL**: https://apify.com/automation-lab/talabat-restaurant-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Talabat Restaurants Scraper

Collect structured **Talabat restaurants** records from public country directories for assortment research, cuisine coverage analysis, and repeatable competitor monitoring.

The Actor extracts restaurant IDs, names, slugs, cuisine labels, logos, public restaurant URLs, market codes, and listing-page provenance. It follows Talabat's public country pagination without requiring a Talabat account, browser, location selection, or proxy.

### What can you do with Talabat Restaurants Scraper?

- Build a current restaurant directory for a supported Talabat market.
- Compare cuisine assortment across countries.
- Take scheduled snapshots and detect additions or removals downstream.
- Seed spreadsheets, BI dashboards, databases, and enrichment pipelines.
- Preserve source-page URLs and timestamps for review and audit.

This Actor focuses on country restaurant listings. Location-gated menus, prices, ratings, delivery fees, availability, and item options are outside its scope.

### Who is this Actor for?

**Food-delivery analysts** can compare market assortment and cuisine coverage.

**Restaurant groups** can monitor whether brands appear in public Talabat directories.

**Market researchers** can create country-level restaurant samples with stable Talabat IDs.

**Data teams** can schedule repeatable snapshots and compare them in a warehouse.

**Developers** can consume clean JSON instead of maintaining Talabat page parsing.

### Why use this Talabat restaurant extractor?

The Actor uses lightweight HTTP requests and parses Talabat's structured page data. That keeps runs smaller and faster than browser automation for this public-directory workflow.

It supports nine Talabat markets:

- United Arab Emirates (`uae`)
- Kuwait (`kuwait`)
- Qatar (`qatar`)
- Bahrain (`bahrain`)
- Oman (`oman`)
- Egypt (`egypt`)
- Jordan (`jordan`)
- Iraq (`iraq`)
- Saudi Arabia (`ksa`)

Results are deduplicated by country and Talabat restaurant ID. Limits are applied across all selected countries.

### What data does it extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `restaurantId` | integer | Talabat restaurant identifier |
| `name` | string | Public restaurant name |
| `slug` | string | Talabat URL slug |
| `cuisines` | string\[] | Cuisine labels from the listing |
| `logoUrl` | string or null | Public logo image URL when available |
| `restaurantUrl` | string | Public Talabat restaurant page |
| `country` | string | Talabat market slug |
| `sourcePageUrl` | string | Listing page that supplied the record |
| `sourcePage` | integer | Pagination page number |
| `scrapedAt` | string | ISO 8601 collection timestamp |

### How to scrape Talabat restaurants

1. Open the Actor input page.
2. Select one or more countries, or paste country listing URLs.
3. Optionally enter a cuisine filter such as `Indian` or `Pizza`.
4. Choose the maximum number of records and pages per country.
5. Click **Start**.
6. Open the default dataset and export JSON, CSV, Excel, XML, or another supported format.

A safe first run is:

```json
{
  "countries": ["uae"],
  "maxItems": 30,
  "maxPagesPerCountry": 2
}
```

### Input parameters

#### `countries`

An optional list of supported Talabat market slugs. If neither countries nor start URLs are provided, the Actor uses `uae`.

#### `startUrls`

Optional Talabat country restaurant-listing URLs. For example:

```json
{
  "startUrls": [
    { "url": "https://www.talabat.com/kuwait/restaurants" }
  ]
}
```

A `?page=3` query can choose the first page. Other domains, restaurant detail URLs, and unsupported countries fail validation.

#### `cuisine`

Optional case-insensitive text matched against the listing's cuisine labels. Filtering may require scanning several pages to find enough matching records.

#### `maxItems`

Maximum matching records saved across the whole run. Range: 1 to 50,000. Default: 100.

#### `maxPagesPerCountry`

Safety limit for pagination in each market. Range: 1 to 1,000. Default: 20.

### Output example

A current public UAE listing produces records shaped like this:

```json
{
  "restaurantId": 328,
  "name": "Johnny Rockets",
  "slug": "johnny-rockets",
  "cuisines": ["Kerala", "Indian", "Pakistani", "South indian", "Curry", "Biryani"],
  "logoUrl": "https://images.deliveryhero.io/image/talabat/restaurants/Johnny-Rockets-Logo_636004641354274810.jpg",
  "restaurantUrl": "https://www.talabat.com/uae/johnny-rockets",
  "country": "uae",
  "sourcePageUrl": "https://www.talabat.com/uae/restaurants?page=1",
  "sourcePage": 1,
  "scrapedAt": "2026-08-02T05:10:00.000Z"
}
```

Names, cuisines, images, and directory membership can change because Talabat controls the source.

### How much does it cost to extract Talabat restaurants?

The Actor uses pay-per-event pricing: one `start` event per run plus one `item` event per saved restaurant. You are not charged an item event for duplicates, malformed source rows, filtered-out restaurants, or failed requests.

The six item-price tiers decrease with account tier. At the BRONZE tier, the rate is **$0.0008 per restaurant**, plus a **$0.00005** run start event. The live Apify pricing panel is authoritative if the displayed price differs.

Example BRONZE item charges:

| Saved restaurants | Approximate item charge |
| ---: | ---: |
| 30 | $0.024 |
| 100 | $0.080 |
| 1,000 | $0.800 |

Compute usage is included under Apify's pay-per-event model. Set `maxItems` and `maxPagesPerCountry` to control run scope.

### Assortment monitoring workflow

For recurring monitoring, select the same countries and limits on every run. Schedule the Actor daily or weekly, then compare datasets by the stable key `country + restaurantId`.

Typical change rules include:

- key exists today but not in the previous snapshot: possible addition;
- key existed previously but not today: possible removal or temporary omission;
- cuisine array changed: category or positioning update;
- name, slug, or logo changed: public listing metadata update.

The Actor produces snapshots; it does not store historical diffs or send alerts itself.

### Cuisine coverage workflow

Use `cuisine` for a focused sample:

```json
{
  "countries": ["kuwait"],
  "cuisine": "Indian",
  "maxItems": 100,
  "maxPagesPerCountry": 20
}
```

The match is case-insensitive and checks each cuisine label. It is a text filter, not a semantic cuisine classifier.

### Export and integrations

The default dataset works with Apify integrations and standard dataset export endpoints.

Useful destinations include:

- Google Sheets for quick review;
- Airtable for operational tracking;
- BigQuery or Snowflake for historical comparison;
- webhooks for triggering a downstream diff job;
- Python or JavaScript pipelines for enrichment;
- CSV and Excel for analysts.

### Run through the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~talabat-restaurant-listings-scraper/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"countries":["uae"],"maxItems":30,"maxPagesPerCountry":2}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/talabat-restaurant-listings-scraper').call({
  countries: ['uae', 'qatar'],
  maxItems: 100,
  maxPagesPerCountry: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/talabat-restaurant-listings-scraper").call(run_input={
    "countries": ["bahrain"],
    "maxItems": 50,
    "maxPagesPerCountry": 3,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

#### Claude Code

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/talabat-restaurant-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code clients can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/talabat-restaurant-listings-scraper"
    }
  }
}
```

Example prompts:

- “Extract 30 Talabat UAE restaurant records and summarize cuisine coverage.”
- “Collect Indian restaurant listings from Talabat Kuwait.”
- “Create a snapshot of UAE, Qatar, and Bahrain restaurant assortment.”

### Reliability and limits

Talabat controls its pages and may change markup, structured data, pagination, or country availability. The Actor retries transient connection errors, HTTP 429, and server errors up to three times with bounded backoff.

A missing or malformed structured listing fails the run instead of silently emitting guessed data. Deterministic HTTP 4xx responses are not retried blindly.

Country directory records do not prove that a restaurant currently delivers to a specific address. Results can include brands or branches whose availability varies by location.

### Responsible use and legality

This Actor collects public country-directory metadata. You are responsible for ensuring your use complies with Talabat's terms, applicable law, database rights, privacy rules, and your contractual obligations.

Avoid collecting or combining data to identify individuals. Use reasonable schedules and limits. Do not use the output for spam, deception, or unauthorized access.

Talabat is a trademark of its owner. This Actor is an independent data-extraction tool and is not affiliated with or endorsed by Talabat.

### Troubleshooting

#### Why did I receive fewer results than `maxItems`?

The selected page limit may have ended first, the cuisine filter may match only a few records, the source may have ended, or duplicates may have been removed. Increase `maxPagesPerCountry` carefully when using a narrow filter.

#### Why was my start URL rejected?

Only public country listing URLs in the form `https://www.talabat.com/{country}/restaurants` are accepted. Use `countries` for the simplest setup.

#### Why did the run fail with a structured-data error?

Talabat may have changed or temporarily withheld the public listing. Retry later and inspect the log. The Actor fails closed rather than returning incomplete placeholder rows.

#### Do I need a proxy or Talabat account?

No. The supported country-directory workflow currently works with anonymous direct HTTP requests. The Actor does not expose an automatic paid-proxy fallback.

### FAQ

#### Does it scrape menus and prices?

No. The minimum product is restaurant listing metadata. Menus and location-specific availability are intentionally excluded.

#### Can I monitor new restaurants?

Yes. Schedule identical snapshot inputs and compare `country + restaurantId` with a previous dataset in your own workflow.

#### Can I search a city or delivery address?

No. This Actor scans public country directories. It does not claim city-complete or address-specific delivery coverage.

#### Are the restaurant URLs guaranteed to remain stable?

No. Talabat can change slugs or remove pages. Use the source ID and country as the more stable comparison key.

#### Can I export to a spreadsheet?

Yes. Download the default dataset as CSV or Excel, or connect an Apify integration.

### Related Automation Labs Actors

For cross-platform restaurant research, consider:

- [Grubhub Restaurant Menus Scraper](https://apify.com/automation-lab/grubhub-restaurant-menus-scraper)
- [MenuPages Restaurant Menu Scraper](https://apify.com/automation-lab/menupages-restaurant-menu-scraper)
- [Zomato Restaurant Search Scraper](https://apify.com/automation-lab/zomato-restaurant-search-scraper)

Choose this Actor when your required source is Talabat's public country restaurant directory and the listing-level fields above satisfy the job.

# Actor input Schema

## `countries` (type: `array`):

Talabat markets to scan. UAE is used when neither countries nor start URLs are supplied.

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

Optional talabat.com country restaurant-listing URLs, such as https://www.talabat.com/uae/restaurants. A ?page= number may select the first page.

## `cuisine` (type: `string`):

Optional case-insensitive cuisine text, for example Indian or Pizza. Pages are scanned until the result limit, page limit, or source end is reached.

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

Stop after saving this many matching restaurant records across all selected countries.

## `maxPagesPerCountry` (type: `integer`):

Safety limit for country pagination. Each Talabat listing page currently contains up to 30 restaurants.

## Actor input object example

```json
{
  "countries": [
    "uae"
  ],
  "startUrls": [
    {
      "url": "https://www.talabat.com/uae/restaurants"
    }
  ],
  "maxItems": 20,
  "maxPagesPerCountry": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the Talabat restaurants table view.

# 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 = {
    "countries": [
        "uae"
    ],
    "startUrls": [
        {
            "url": "https://www.talabat.com/uae/restaurants"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/talabat-restaurant-listings-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 = {
    "countries": ["uae"],
    "startUrls": [{ "url": "https://www.talabat.com/uae/restaurants" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/talabat-restaurant-listings-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 '{
  "countries": [
    "uae"
  ],
  "startUrls": [
    {
      "url": "https://www.talabat.com/uae/restaurants"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/talabat-restaurant-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/talabat-restaurant-listings-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/FyE83CJS6js012xp9/builds/RNE1sbkTlo0zY7BqY/openapi.json