Track Zomato Food Delivery Coverage by City in India (2026)

Thirdwatch's Zomato Scraper maps food delivery coverage across 20 Indian cities on Zomato. Each result includes delivery time, serviceability status, cost for two, cuisine availability, and full address with locality and coordinates. Compare city-level restaurant supply density, delivery speed distributions, and pricing bands to identify underserved localities and cuisine gaps. Built for cloud kitchen operators, food-tech founders, and market researchers sizing India's delivery infrastructure.

Why track Zomato delivery coverage by city

India's online food delivery market reached $8.7 billion in 2025 and is projected to grow at 18% CAGR through 2030, according to Redseer's India food delivery report. NRAI's India Food Services Report puts the total food services industry at $78 billion, with online delivery now accounting for over 10% of that spend. But this growth is not uniform — metro cities like Bangalore and Mumbai have saturated delivery ecosystems, while tier-2 cities like Lucknow, Indore, and Coimbatore are expanding rapidly with fewer incumbents per locality.

For anyone making location decisions in India's F&B economy, delivery coverage data is the leading indicator. A cloud kitchen operator choosing between Jaipur and Kochi needs to know: how many delivery-active restaurants exist in each city, what are the average delivery times (a proxy for logistics maturity), what cuisines are underrepresented, and what cost-for-two bands dominate. A food-tech startup sizing its addressable market needs these numbers at city scale, not from anecdotal visits. An investor evaluating a QSR franchise pitch needs to see the competitive density in each proposed market. All of these require structured delivery data from the dominant platform, and in India that platform is Zomato.

How does this compare to the alternatives?

Three ways to map India food delivery coverage:

Consulting reports provide top-down estimates that are 6-12 months stale by publication. Zomato's own disclosures are national aggregates without city-level or locality-level breakdowns. The Thirdwatch Zomato Scraper provides bottom-up, live, restaurant-level data that you can aggregate to any geographic level — city, locality, or cuisine category.

How to track delivery coverage in 4 steps

Step 1: How do I authenticate with Apify?

Sign up at apify.com (free tier, no credit card), go to Settings, then Integrations, and copy your API token:

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: How do I pull delivery restaurant counts across all 20 cities?

Run a blank-query search in each city with deliveryOnly set to true. This returns all delivery-active restaurants up to your maxResults limit.

import os, requests, pandas as pd, time

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

CITIES = [
    "bangalore", "mumbai", "delhi", "hyderabad", "chennai",
    "kolkata", "pune", "ahmedabad", "jaipur", "lucknow",
    "chandigarh", "kochi", "goa", "indore", "coimbatore",
    "nagpur", "vizag", "bhopal", "gurgaon", "noida",
]

city_data = []

for city in CITIES:
    resp = requests.post(
        f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
        params={"token": TOKEN},
        json={
            "city": city,
            "maxResults": 500,
            "deliveryOnly": True,
        },
        timeout=3600,
    )
    restaurants = resp.json()
    city_data.extend(restaurants)
    print(f"{city}: {len(restaurants)} delivery restaurants")
    time.sleep(2)

df = pd.DataFrame(city_data)
print(f"\nTotal: {len(df)} restaurants across {df.city.nunique()} cities")

Leaving queries empty returns the broadest cross-section of delivery restaurants in each city, which is what you need for coverage analysis rather than cuisine-specific searches.

Step 3: How do I compare delivery speed and pricing across cities?

Parse delivery times into minutes and cost strings into numeric values for cross-city comparison.

import re

def parse_minutes(time_str):
    if not time_str:
        return None
    match = re.search(r"(\d+)", str(time_str))
    return int(match.group()) if match else None

def parse_cost(cost_str):
    if not cost_str:
        return None
    digits = re.sub(r"[^\d]", "", str(cost_str))
    return int(digits) if digits else None

df["delivery_min"] = df["delivery_time"].apply(parse_minutes)
df["cost_numeric"] = df["cost_for_two"].apply(parse_cost)

# City-level coverage metrics
coverage = df.groupby("city").agg(
    restaurant_count=("name", "count"),
    avg_delivery_min=("delivery_min", "mean"),
    median_delivery_min=("delivery_min", "median"),
    avg_cost_for_two=("cost_numeric", "mean"),
    pct_serviceable=("is_serviceable", "mean"),
    unique_localities=("location", "nunique"),
).round(1)

coverage = coverage.sort_values("restaurant_count", ascending=False)
print(coverage.to_string())

The unique_localities column is a rough proxy for geographic spread — a city with 300 restaurants across 50 localities has broader delivery coverage than one with 300 restaurants concentrated in 15 localities.

Step 4: How do I identify underserved cuisines and localities?

Find gaps in cuisine availability and thin-coverage areas within each city.

# Cuisine availability by city
cuisine_exploded = df.explode("cuisine")
cuisine_city = cuisine_exploded.groupby(["city", "cuisine"]).size().reset_index(name="count")
cuisine_pivot = cuisine_city.pivot_table(index="cuisine", columns="city",
                                          values="count", fill_value=0)

# Cuisines available in metros but missing in tier-2
metros = ["bangalore", "mumbai", "delhi"]
tier2 = ["lucknow", "indore", "coimbatore", "vizag", "bhopal"]

metro_cuisines = set(cuisine_pivot[cuisine_pivot[metros].sum(axis=1) > 10].index)
for city in tier2:
    city_cuisines = set(cuisine_pivot[cuisine_pivot[city] > 2].index)
    gaps = metro_cuisines - city_cuisines
    print(f"\n{city}: {len(gaps)} cuisines present in metros but underrepresented")
    print(f"  Top gaps: {list(gaps)[:10]}")

# Localities with long delivery times (underserved logistics)
locality_speed = df.groupby(["city", "location"]).agg(
    avg_delivery=("delivery_min", "mean"),
    restaurant_count=("name", "count"),
).reset_index()
slow_areas = locality_speed[
    (locality_speed["avg_delivery"] > 40) & (locality_speed["restaurant_count"] >= 3)
].sort_values("avg_delivery", ascending=False)
print(f"\n{len(slow_areas)} localities with avg delivery > 40 min:")
print(slow_areas.head(15).to_string())

Localities with average delivery times above 40 minutes despite having 3+ restaurants are logistics bottlenecks — either far from restaurant clusters or underserved by delivery fleets. For cloud kitchen site selection, these are high-opportunity zones.

Sample output

Two records illustrating cross-city delivery coverage differences:

[
  {
    "name": "Behrouz Biryani",
    "cuisine": ["Biryani", "North Indian", "Mughlai"],
    "delivery_rating": 4.3,
    "delivery_rating_count": "8,100",
    "cost_for_two": "₹600 for two",
    "delivery_time": "22 min",
    "is_serviceable": true,
    "has_online_ordering": true,
    "location": "Koramangala, Bangalore",
    "city": "bangalore",
    "restaurant_id": "18934021"
  },
  {
    "name": "Paradise Biryani",
    "cuisine": ["Biryani", "North Indian"],
    "delivery_rating": 3.9,
    "delivery_rating_count": "2,400",
    "cost_for_two": "₹500 for two",
    "delivery_time": "42 min",
    "is_serviceable": true,
    "has_online_ordering": true,
    "location": "Aminabad, Lucknow",
    "city": "lucknow",
    "restaurant_id": "62019847"
  }
]

The Bangalore outlet shows 22-minute delivery and 8,100 ratings; the Lucknow outlet shows 42-minute delivery and 2,400 ratings. Both serve biryani at similar price points, but the 20-minute delivery gap reflects Bangalore's denser delivery infrastructure. The is_serviceable flag confirms both are currently accepting orders; when this flag is false, it signals temporary outages or zone restrictions.

Common pitfalls

Three issues affect delivery coverage analysis. Confusing maxResults with total coverage — setting maxResults to 200 returns 200 restaurants per city, not all restaurants. Zomato may have 5,000+ delivery restaurants in Mumbai; your 200 are the top-ranked by Zomato's default sort. For true coverage mapping, run multiple queries (by cuisine, by dish) and deduplicate on restaurant_id. Delivery time as a snapshot — delivery_time reflects the estimate at scrape time, which varies by hour (lunch rush vs 3 PM). Schedule runs at consistent times for comparable data. City slug formatting — the city parameter must be a lowercase slug from the supported list (e.g., gurgaon, not Gurugram or Gurgaon). Unsupported cities return empty results with no error.

A fourth consideration: rating vs delivery rating divergence. Zomato surfaces separate dining and delivery ratings for the same restaurant. A highly-rated dine-in restaurant may have poor delivery ratings due to packaging quality or cold food. For delivery coverage analysis, always use delivery_rating rather than the generic rating field, since delivery-specific satisfaction is what matters for cloud kitchen benchmarking and food-tech market sizing.

Thirdwatch's actor handles anti-bot work and geo-routing internally, so your coverage analysis pipeline receives clean, structured data on every run without managing proxies or request pacing.

Related use cases

• Scrape Zomato restaurants for India food research
• Build an India restaurant database with Zomato
• Monitor Zomato ratings for restaurant chains
• Build India food delivery coverage with Swiggy
• Monitor Swiggy vs Zomato India pricing
• The complete guide to scraping food delivery platforms
• All Thirdwatch use-case guides