How to Scrape Swiggy Restaurants and Menus in 2026

Swiggy is one of India’s two dominant food-delivery platforms, and its catalog is hyper-local: what a Swiggy user sees depends entirely on the latitude/longitude they’re standing at. That makes Swiggy data unusually rich for location intelligence — the same chain shows different prices, delivery fees, and availability across neighborhoods. Swiggy serves all of this through an internal Desktop API that returns clean JSON, so you can pull it with direct HTTP requests and skip browser automation entirely. This guide covers what’s exposed, how hyper-local targeting works, the two-endpoint restaurant-plus-menu pattern, and how to do it cheaply at scale.

What’s worth extracting

Swiggy’s data comes in two layers — the restaurant listing, and the full menu behind it.

Per restaurant:

• Identity — unique restaurant ID, name, city, neighborhood/area.
• Reputation — average rating and rating volume (the count matters as much as the score).
• Economics — cost-for-two estimate, delivery fee (normalized to INR), estimated delivery time.
• Classification — cuisine tags (North Indian, Biryani, Chinese, Desserts, …).
• Status — availability (open/closed for the queried location), promoted/ad placement flag.
• Timestamps — when the record was scraped.

Per dish (the menu):

• Identity — per-dish ID, dish name, menu category (Starters, Mains, Beverages…).
• Description — dish description / ingredients when present.
• Price — exact price in INR (converted from Swiggy’s backend integer units).
• Dietary — vegetarian flag (a first-class field in the Indian market).
• Availability — in-stock / out-of-stock at scrape time.

The menu is the part most generic scrapers miss. Dish-level pricing across a city is the dataset that powers cloud-kitchen and pricing-intelligence work.

Hyper-local targeting is the whole game

On Swiggy, location is a query parameter, not a filter. The platform’s listing endpoint takes a latitude and longitude and returns the restaurants serviceable from that point, with that point’s prices and delivery economics. There’s no national “all restaurants” view — you scrape Swiggy by sweeping coordinates.

In practice you target either specific coordinates (a neighborhood centroid, a competitor’s exact address) or city-center points, and the scraper traverses Swiggy’s pagination tokens to walk the full serviceable list at each point. To cover a city you tile it: a grid of coordinate points, each yielding the local restaurant set, deduplicated by restaurant ID across overlapping tiles. This is why coordinate coverage — not keyword search — is the right mental model for Swiggy.

Zero-browser API architecture

Swiggy’s Desktop API returns JSON directly, so the scraper makes direct HTTP requests with no headless browser — which is what makes it fast and cheap. The flow is:

1. Hit the listing endpoint for a coordinate, page through the pagination tokens to collect all restaurant cards.
2. For each restaurant, hit the secondary menu endpoint to pull the full dish catalog.
3. Normalize prices from Swiggy’s backend units (it stores prices as integers in the smallest unit) into clean INR values.

The anti-blocking layer is lightweight by design — proxy rotation, randomized request delays, and header spoofing — because there’s no JavaScript challenge wall to defeat, only rate-limiting to stay under. No browser means no Chromium memory overhead, which is the difference between an expensive scrape and a near-free one.

▶ Run the Swiggy Restaurant Scraper — coordinate or city-center targeting, full restaurant profiles plus complete dish-level menus in INR. Zero-browser direct API, proxy rotation and pacing included. Fast and cheap.

Schema design for downstream use

Restaurant and menu are two related tables. A per-restaurant row with the menu kept as a nested array (or as a separate dish table joined on restaurant ID):

{
  "restaurant_id": "334288",
  "name": "Meghana Foods",
  "city": "Bengaluru",
  "area": "Koramangala",
  "rating": 4.5,
  "rating_count": 18400,
  "cost_for_two_inr": 600,
  "delivery_fee_inr": 35,
  "delivery_time_min": 32,
  "cuisines": ["Andhra", "Biryani", "South Indian"],
  "is_open": true,
  "is_promoted": false,
  "lat": 12.9352,
  "lon": 77.6245,
  "menu": [
    {
      "dish_id": "9920114",
      "name": "Boneless Chicken Biryani",
      "category": "Biryani",
      "price_inr": 320,
      "is_veg": false,
      "in_stock": true
    }
  ],
  "scraped_at": "2026-05-25T13:00:00Z"
}

Choices worth making early:

• Store the query coordinate alongside the restaurant. Prices and delivery fees are location-dependent; you need to know where a quote was valid.
• Keep rating_count next to rating. A 4.8 from 12 ratings and a 4.3 from 40,000 are not comparable.
• Don’t flatten the menu away. Dish-level pricing is the high-value layer; keep the array (or a related dish table) intact.
• Stamp scraped_at. Menus, prices, and availability change through the day; a stale snapshot misleads.

Typical use cases

• Cloud-kitchen site selection — sweep candidate neighborhoods, measure cuisine saturation and price bands, and find menu gaps a new kitchen could fill.
• Competitive pricing intelligence — monitor a competitor set’s dish prices, delivery fees, and promotions on a daily cadence across the city.
• Food-discovery / aggregation apps — power an alternative discovery or nutrition-tracking product with structured restaurant-and-menu data.
• Quality and sentiment monitoring — track average ratings and rating volumes across large restaurant sets to spot decline or breakout performers.
• Market research — size the addressable market by cuisine and price tier in a given city or zone.

The value is location density plus menu depth: a single restaurant’s menu is trivia, but every restaurant’s menu across every neighborhood of a metro, refreshed daily, is genuine market infrastructure.

Cost math

This actor is pay-per-event with per-result pricing set to zero — you pay the small per-run start fee (about $0.00005) plus Apify compute, and nothing per restaurant or dish. Because it’s zero-browser, the compute is light, so even a full-city sweep with menus is dominated by the (modest) compute time rather than data volume. Compared to running your own coordinate-grid crawler on a VPS with a proxy pool, you skip the proxy bill, the browser memory you don’t need, and the work of normalizing Swiggy’s backend price units.

Common pitfalls

• No location, no data. Swiggy returns nothing without a valid lat/lon. Build your coordinate grid first.
• Backend price units aren’t INR. Swiggy stores prices as integers in a smaller unit; if you skip the conversion you’ll report prices that are off by an order of magnitude. The actor normalizes this for you.
• Dedup across tiles. Overlapping coordinate tiles return the same restaurant multiple times — dedup by restaurant ID.
• Availability is per-location and per-time. A restaurant “closed” for one coordinate at one moment may be open elsewhere or later; don’t treat a single snapshot as ground truth.
• The menu lives behind a second request. The listing endpoint gives you the card; you must hit the menu endpoint per restaurant to get dishes and prices.
• Promoted listings skew the top of the list. Use the is_promoted flag to separate paid placement from organic ranking when you analyze visibility.

Wrapping up

Swiggy is a fast, JSON-clean target with no browser required — but it’s only useful if you think in coordinates rather than keywords, handle the restaurant-plus-menu two-endpoint pattern, and normalize the backend price units. A managed actor handles the tiling, pagination tokens, menu fetches, INR conversion, and pacing, so you can go straight to the pricing or site-selection analysis.

▶ Open the Swiggy Restaurant Scraper on Apify — hyper-local coordinate targeting, restaurants plus full dish-level menus in INR, zero-browser speed. Per-result pricing is zero. Start with Apify’s free monthly credit.