# Zomato Scraper - India Restaurants, Ratings & Delivery Data (`thirdwatch/zomato-scraper`) Actor

Scrape Zomato restaurants across 20 Indian cities. Get ratings (delivery + dining), cuisines, cost for two, delivery times, addresses, and images. Search by dish, cuisine, or browse all restaurants in a city.

- **URL**: https://apify.com/thirdwatch/zomato-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Zomato Scraper

> Scrape restaurant data from Zomato — ratings, cuisines, cost for two, delivery times, and locations across 20 Indian cities.

### What you get

Restaurant discovery data from Zomato.com, India's largest restaurant listing and food-delivery platform. Each result includes name, cuisines, separate delivery and dining ratings, cost for two, delivery time, full address, image, and listing URL. Browse by dish, by cuisine, or list all delivery restaurants in a city.

### Output fields

| Field | Description |
|-------|-------------|
| `name` | Restaurant name |
| `cuisine` | Array of cuisines served |
| `rating` | Overall Zomato rating |
| `rating_count` | Number of ratings (e.g., "11.7K") |
| `delivery_rating` | Delivery-specific rating |
| `delivery_rating_count` | Delivery rating count |
| `dining_rating` | Dine-out rating |
| `dining_rating_count` | Dine-out rating count |
| `cost_for_two` | Average cost for two (formatted) |
| `cost_for_one` | Average cost for one (formatted) |
| `delivery_time` | Estimated delivery time |
| `is_serviceable` | Whether delivery is available |
| `has_online_ordering` | Online ordering available |
| `location` | Locality |
| `address` | Full address |
| `city` | City |
| `image_url` | Main restaurant image |
| `url` | Zomato listing URL |
| `restaurant_id` | Unique restaurant ID |
| `is_promoted` | Paid promoted listing flag |
| `query` | Original search query |

### Example output

```json
{
    "name": "Meghana Foods",
    "cuisine": ["Biryani", "Andhra", "North Indian", "Chinese"],
    "rating": 4.2,
    "rating_count": "11.7K",
    "delivery_rating": 4.2,
    "delivery_rating_count": "10.5K",
    "dining_rating": 4.2,
    "dining_rating_count": "1,197",
    "cost_for_two": "₹1,000 for two",
    "cost_for_one": "₹400 for one",
    "delivery_time": "29 min",
    "is_serviceable": true,
    "has_online_ordering": true,
    "location": "St. Marks Road, Bangalore",
    "address": "18-22, Vasavi Complex, St. Marks Road, Bangalore",
    "city": "bangalore",
    "image_url": "https://b.zmtcdn.com/data/pictures/...",
    "url": "https://www.zomato.com/bangalore/meghana-foods-residency-road/order",
    "restaurant_id": "19282473",
    "is_promoted": false,
    "query": "biryani"
}
````

### Input parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `queries` | No | Dish or cuisine names to search (e.g., `["biryani", "pizza"]`). Leave empty to browse all restaurants in the city. |
| `city` | No | City to search. One of 20 supported Indian cities. Default `bangalore`. |
| `maxResults` | No | Maximum restaurants to return. Default `10`. |
| `deliveryOnly` | No | Only delivery-available restaurants. Default `true`. |
| `includeMenu` | No | Fetch menu items per restaurant (slower). Default `false`. |
| `proxy` | No | Proxy configuration. Defaults to India residential proxy. |

**Supported cities:** Bangalore, Mumbai, Delhi, Hyderabad, Chennai, Kolkata, Pune, Ahmedabad, Jaipur, Lucknow, Chandigarh, Kochi, Goa, Indore, Coimbatore, Nagpur, Vizag, Bhopal, Gurgaon, Noida.

### Use cases

- **Food-tech startups**: Benchmark competitor ratings and pricing against yours in every market.
- **Cloud kitchen operators**: Identify top-rated cuisines and cost-for-two bands per locality.
- **Market researchers**: Build India restaurant supply-side datasets for investor reports.
- **Food bloggers & aggregators**: Enrich your own recommendation lists with live ratings and delivery info.

### Limitations

- **India only** — currently covers 20 major Indian cities; smaller towns and Zomato's international markets are not supported.
- Returns **public restaurant listings** — name, ratings, cuisines, cost, address, image, listing URL.
- **Menu data may not be present for all restaurants** — only fetched when `includeMenu: true`, and not every restaurant publishes a full menu on its public page.
- Phone numbers and direct contact details are not returned (Zomato gates them behind login).
- Requires an India-based residential proxy (the default Apify residential proxy in India is pre-configured).

### Compared to alternatives

- **vs. tugkan/zomato-scraper** (flat ~$10/run): This actor charges only per restaurant, so small runs are near-free.
- **vs. Zomato Partner API**: The official API is only available to enterprise restaurant partners; this actor gives any buyer structured discovery data.

Pairs well with [Swiggy Scraper](https://apify.com/thirdwatch/swiggy-scraper) and [Google Maps Scraper](https://apify.com/thirdwatch) for full India F\&B coverage.

### FAQ

**Does this include Zomato outside India?**
This scraper covers 20 major Indian cities only.

**Can I get full menus?**
Set `includeMenu: true`. Note that Zomato rate-limits menu requests, so large runs will be slower.

**Does it return delivery and dine-out ratings separately?**
Yes. Zomato gives each restaurant two ratings — both are returned as `delivery_rating` and `dining_rating`.

**How fresh is the data?**
Data is pulled live at run time — as fresh as Zomato itself.

Last verified: 2026-05

More scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

## `queries` (type: `array`):

Dish or cuisine names to search for (e.g., 'biryani', 'pizza', 'north-indian'). Leave empty to browse all delivery restaurants in the selected city.

## `city` (type: `string`):

Indian city to search in.

## `maxResults` (type: `integer`):

Maximum number of restaurants to return.

## `deliveryOnly` (type: `boolean`):

If true, only show restaurants available for delivery. If false, also include dine-out restaurants.

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

If true, fetch menu items for each restaurant (slower, one extra request per restaurant).

## `proxy` (type: `object`):

Proxy configuration. Defaults to Apify residential proxy in India.

## Actor input object example

```json
{
  "queries": [
    "biryani"
  ],
  "city": "bangalore",
  "maxResults": 10,
  "deliveryOnly": true,
  "includeMenu": 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 = {
    "queries": [
        "biryani"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/zomato-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 = {
    "queries": ["biryani"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/zomato-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "biryani"
  ],
  "maxResults": 10
}' |
apify call thirdwatch/zomato-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thirdwatch/zomato-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Scraper - India Restaurants, Ratings & Delivery Data",
        "description": "Scrape Zomato restaurants across 20 Indian cities. Get ratings (delivery + dining), cuisines, cost for two, delivery times, addresses, and images. Search by dish, cuisine, or browse all restaurants in a city.",
        "version": "0.1",
        "x-build-id": "4eRmkFEvaRwcU41Ua"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~zomato-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-zomato-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/thirdwatch~zomato-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-zomato-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/thirdwatch~zomato-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-zomato-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Dish or cuisine names to search for (e.g., 'biryani', 'pizza', 'north-indian'). Leave empty to browse all delivery restaurants in the selected city.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "bangalore",
                            "mumbai",
                            "delhi",
                            "hyderabad",
                            "chennai",
                            "kolkata",
                            "pune",
                            "ahmedabad",
                            "jaipur",
                            "lucknow",
                            "chandigarh",
                            "kochi",
                            "goa",
                            "indore",
                            "coimbatore",
                            "nagpur",
                            "vizag",
                            "bhopal",
                            "gurgaon",
                            "noida"
                        ],
                        "type": "string",
                        "description": "Indian city to search in.",
                        "default": "bangalore"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of restaurants to return.",
                        "default": 10
                    },
                    "deliveryOnly": {
                        "title": "Delivery Only",
                        "type": "boolean",
                        "description": "If true, only show restaurants available for delivery. If false, also include dine-out restaurants.",
                        "default": true
                    },
                    "includeMenu": {
                        "title": "Include Menu",
                        "type": "boolean",
                        "description": "If true, fetch menu items for each restaurant (slower, one extra request per restaurant).",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration. Defaults to Apify residential proxy in India."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
