# 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
- **Features:** Limited permissions
- **Stats:** 92 total users, 7 monthly users, 100.0% runs succeeded, 0 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/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

## Zomato Scraper

> **Thirdwatch portfolio:** 8,800+ users across 140+ public Actors, 2M+ records delivered, >95% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

> 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. Preconfigured for reliable access to Zomato's India listings. |

**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).
- Optimized for Indian cities only; coverage outside the supported-cities list is not guaranteed.

### 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?fpr=9m2cd6) and [Google Maps Scraper](https://apify.com/thirdwatch/google-maps-scraper?fpr=9m2cd6) 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`):

Preconfigured for reliable access to Zomato's India listings — leave this at its default unless you have a specific reason to change it.

## 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(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 '{
  "queries": [
    "biryani"
  ],
  "maxResults": 10
}' |
apify call thirdwatch/zomato-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thirdwatch/zomato-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/Uxl8pbbsIIra2qtdS/builds/KMj9rMw72SxgXbhdZ/openapi.json