Zomato Restaurant Search Scraper

Extract restaurant leads from public Zomato city, restaurant, and cuisine pages. The actor returns Zomato profile URLs, names, cuisines, ratings, review counts, locality, address, cost-for-two, images, and source-page metadata in a clean dataset.

Use it when you need repeatable Zomato restaurant discovery for food-tech research, local business lead generation, restaurant sales outreach, local SEO work, or market mapping in Indian cities where Zomato has strong coverage.

What does Zomato Restaurant Search Scraper do?

Zomato Restaurant Search Scraper reads public Zomato pages and extracts restaurant cards from the embedded page state.

It can start from a city page such as https://www.zomato.com/bangalore/restaurants or a cuisine page such as https://www.zomato.com/bangalore/restaurants/biryani.

When enabled, it also follows public cuisine and locality links that Zomato exposes on the page so you can collect more restaurants from one city URL without using private APIs.

Who is it for?

• 🍽️ Restaurant sales teams building Zomato-based prospect lists.
• 📍 Local SEO agencies checking restaurant categories, ratings, and profiles.
• 🧾 Food-tech analysts mapping cuisines, costs, and locations by city.
• 🏪 Franchise and cloud-kitchen operators researching market density.
• 🧑‍💻 Developers who need a structured Zomato extractor instead of brittle page parsing.

Why use this scraper?

Zomato pages are useful, but manually copying restaurant cards is slow and inconsistent.

This actor gives you a repeatable Apify workflow with typed fields, a dataset export, API access, scheduled runs, webhooks, and MCP compatibility.

It focuses on public restaurant search data rather than private user accounts, checkout flows, or protected APIs.

Key features

• ✅ Public Zomato city and cuisine URL input.
• ✅ Restaurant profile URL and Zomato restaurant ID.
• ✅ Rating, rating text, review count, and review label.
• ✅ Cuisines, locality, address, and city.
• ✅ Cost-for-two and distance when present.
• ✅ Promoted/new flags for filtering.
• ✅ Image and featured image URLs.
• ✅ Optional public cuisine/locality page discovery.
• ✅ Pay-per-event pricing with one charge per saved restaurant.

Data fields

Field	Description
restaurantId	Zomato restaurant identifier.
name	Restaurant name.
url	Public Zomato restaurant profile URL.
city	City slug inferred from the source URL.
locality	Locality or area shown by Zomato.
address	Public address text when available.
cuisines	Array of cuisine names.
cuisineText	Cuisines joined as text for spreadsheets.
rating	Numeric rating when available.
ratingText	Rating text exactly as shown by Zomato.
reviewCount	Parsed review count.
costForTwo	Cost-for-two text, for example ₹1,500 for two.
distance	Distance label when present.
isPromoted	Whether the card is promoted/sponsored.
isNew	Whether Zomato marks the restaurant as new.
imageUrl	Main image URL.
featuredImageUrl	Featured image URL when available.
offerText	Public offer text when present.
sourceUrl	Zomato page where the record was found.
sourceQuery	Cuisine/query inferred from the source URL.
scrapedAt	ISO timestamp of extraction.

How much does it cost to scrape Zomato restaurants?

The actor uses pay-per-event pricing.

There is a small run-start event and a per-restaurant item event.

The exact live tiered prices are shown on the Apify Store pricing tab. The default implementation charges only when a restaurant record is saved, so empty or blocked pages do not create item charges.

Input

{
  "startUrls": [
    { "url": "https://www.zomato.com/bangalore/restaurants" }
  ],
  "maxItems": 50,
  "maxPages": 20,
  "crawlCuisinePages": true,
  "includePromoted": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["SHADER"] }
}

Input options explained

startUrls

Add one or more public Zomato URLs.

Good examples:

• https://www.zomato.com/bangalore/restaurants
• https://www.zomato.com/bangalore/restaurants/biryani
• https://www.zomato.com/mumbai/restaurants/pizza

maxItems

Maximum number of unique restaurants to save.

Use a small value for smoke tests and a larger value for city/cuisine lead generation.

maxPages

Maximum number of Zomato pages to fetch.

This protects your run from unexpectedly discovering too many cuisine or locality links.

crawlCuisinePages

When true, the actor follows public cuisine/locality links found in the embedded Zomato page state.

This is useful for collecting 100+ restaurants from a city page.

includePromoted

When false, promoted restaurant cards are filtered out.

Keep it true if you want the same visible restaurant universe a Zomato user sees.

Output example

{
  "restaurantId": "22243456",
  "name": "Ishaara",
  "url": "https://www.zomato.com/bangalore/ishaara-church-street-bangalore/info",
  "city": "bangalore",
  "locality": "Church Street, Bangalore",
  "address": "1st Floor, Church Street, Bangalore",
  "cuisines": ["Modern Indian", "Beverages"],
  "cuisineText": "Modern Indian, Beverages",
  "rating": 4.3,
  "reviewCount": 1276,
  "costForTwo": "₹1,500 for two",
  "isPromoted": false,
  "sourceUrl": "https://www.zomato.com/bangalore/restaurants",
  "scrapedAt": "2026-06-26T04:58:56.648Z"
}

How to scrape Zomato restaurant leads

1. Open the actor on Apify.
2. Paste one or more public Zomato restaurant, city, or cuisine URLs.
3. Set maxItems to your target number of restaurants.
4. Keep crawlCuisinePages enabled for broader city coverage.
5. Run the actor.
6. Export the dataset to CSV, JSON, Excel, Google Sheets, or via API.

Tips for better results

• Start with a city restaurant page for broad discovery.
• Start with a cuisine URL for targeted prospecting.
• Increase maxPages when you need more city coverage.
• Disable promoted cards if you want organic-only restaurant lists.
• Schedule recurring runs to monitor rating and review-count changes.

Integrations

You can connect the output to:

• Google Sheets for sales prospecting.
• CRMs for restaurant outreach workflows.
• BI dashboards for cuisine and locality analysis.
• Data warehouses for historical monitoring.
• Apify webhooks for automatic downstream processing.

API usage with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zomato-restaurant-search-scraper').call({
  startUrls: [{ url: 'https://www.zomato.com/bangalore/restaurants' }],
  maxItems: 100,
  maxPages: 20,
  crawlCuisinePages: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/zomato-restaurant-search-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.zomato.com/bangalore/restaurants'}],
    'maxItems': 100,
    'maxPages': 20,
    'crawlCuisinePages': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])

API usage with cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~zomato-restaurant-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.zomato.com/bangalore/restaurants"}],"maxItems":100,"maxPages":20,"crawlCuisinePages":true}'

MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP URL:

https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper

Claude Code setup:

$claude mcp add apify-zomato-restaurant-search "https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper"

Claude Desktop JSON setup:

{
  "mcpServers": {
    "apify-zomato-restaurant-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper"
    }
  }
}

Example prompts:

• "Scrape 100 Zomato restaurants from Bengaluru and summarize cuisines by locality."
• "Find Zomato biryani restaurants in Bengaluru with ratings and profile URLs."
• "Export Zomato restaurant leads into a spreadsheet-friendly table."

Common workflows

Restaurant lead generation

Run a city page with cuisine discovery enabled, export CSV, then filter by locality, cuisine, rating, and review count.

Cuisine market mapping

Run multiple cuisine URLs such as biryani, pizza, Chinese, and desserts, then compare restaurant counts and ratings.

Local SEO monitoring

Schedule weekly runs for a fixed set of city/cuisine pages and track rating or review-count changes over time.

Limitations

• The actor extracts public listing data visible in Zomato page state.
• It does not log in, bypass paywalls, place orders, or collect private account data.
• Zomato can change page structure; if embedded state changes, extraction may need maintenance.
• Detail-page-only data and full review text are outside the MVP output.

FAQ and troubleshooting

Why did I get fewer restaurants than maxItems?

The source pages may contain fewer unique restaurant cards, or several cuisine pages may repeat the same restaurants. Increase maxPages, add more start URLs, or enable cuisine discovery.

Why did a URL fail?

Check that the page is a public Zomato restaurant/search/cuisine page and returns normal HTML in a browser. Some old city slugs or malformed cuisine URLs can return 404.

Should I enable proxies?

The actor defaults to the cost-effective Apify SHADER proxy group because Zomato may block direct cloud datacenter traffic. Keep that default unless you have a trusted custom proxy.

Legality and responsible use

This actor extracts publicly available Zomato page data. You are responsible for using the data legally, respecting applicable terms, privacy rules, and local regulations, and avoiding spam or abusive outreach.

Related scrapers

• Google Maps Lead Finder — broader local-business lead discovery.
• Google Maps Reviews Scraper — review monitoring and reputation analysis.
• Website Contact Finder — enrich restaurant or business websites with contact details.

Changelog

0.1

Initial private build for public Zomato restaurant search and cuisine page extraction.

Support

If a public Zomato restaurant page stops working, open an Apify issue with the run ID, input, and expected city/cuisine. Include whether proxies were enabled.