# Swiggy Restaurant & Menu Scraper (`axlymxp/swiggy-restaurant-menu-scraper`) Actor

Scrape Swiggy (India) restaurants and full menus by city, coordinates, keyword or URL — ratings, cuisines, delivery ETA, cost for two, offers, and per-item prices as structured JSON.

- **URL**: https://apify.com/axlymxp/swiggy-restaurant-menu-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 dataset items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Swiggy Restaurant & Menu Scraper

Extract **restaurants and complete menus from Swiggy** (India's largest food‑delivery
platform) as clean, structured data. Search by **city, exact coordinates, keyword, or
restaurant URL** and get ratings, cuisines, delivery times, cost for two, live offers,
and **every menu item with its price** — no login, no browser automation, no manual work.

Built directly on Swiggy's own JSON API (with automatic anti‑bot handling), so results
are fast, complete, and reliable.

### Who it's for

- **Food‑tech analysts & investors** — measure market coverage, pricing and ratings across cities.
- **Cloud kitchens & restaurant operators** — benchmark competitor menus and prices.
- **Price‑intelligence & SaaS teams** — track item prices, offers and delivery ETAs at scale.
- **Researchers & ML teams** — build structured restaurant + dish datasets.

### What you get (output fields)

| Field                     | Description                                                                                                             |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `id`, `name`, `url`       | Swiggy restaurant identifier, name and page link                                                                        |
| `cuisines`                | Cuisine tags                                                                                                            |
| `rating`, `rating_count`  | Average rating and number of ratings                                                                                    |
| `cost_for_two`            | Approximate cost for two (₹)                                                                                            |
| `area`, `locality`        | Neighbourhood / locality                                                                                                |
| `sla_minutes`, `distance` | Estimated delivery time and distance                                                                                    |
| `veg`, `promoted`         | Pure‑veg flag, promoted/ad flag                                                                                         |
| `offers`                  | Active discount headlines (e.g. "ITEMS AT ₹99")                                                                         |
| `image_url`               | Restaurant image                                                                                                        |
| `menu`                    | Full menu: categories → items with `name`, `price`, `veg`, `description`, `in_stock` (when **Include full menu** is on) |
| `menu_item_count`         | Number of menu items collected                                                                                          |

### Use cases

- **Competitive menu & price benchmarking** for a cloud kitchen in a target locality.
- **City‑level market maps** of restaurants, cuisines, ratings and delivery times.
- **Dish price tracking** across restaurants for a price‑intelligence product.
- **Lead lists** of restaurants by area for F&B suppliers and agencies.
- **Research datasets** of Indian restaurant menus for analytics or ML.

### Input parameters

| Field                | Type    | Description                                                                   |
| -------------------- | ------- | ----------------------------------------------------------------------------- |
| `location`           | string  | City or area (e.g. "Bangalore", "Koramangala"). Auto‑resolved to coordinates. |
| `lat`, `lng`         | number  | Exact coordinates (overrides `location`).                                     |
| `searchQuery`        | string  | Search a dish/restaurant instead of browsing an area.                         |
| `restaurantUrls`     | array   | Specific Swiggy restaurant URLs → fetch their menus.                          |
| `includeMenu`        | boolean | Fetch the full menu for each restaurant.                                      |
| `maxRestaurants`     | integer | Max restaurants to collect.                                                   |
| `maxMenus`           | integer | Cap on full‑menu fetches.                                                     |
| `proxyConfiguration` | object  | Optional Apify Proxy.                                                         |

> **Note:** Swiggy operates in India only. Use Indian cities/coordinates.

### Example input

```json
{
    "location": "Bangalore",
    "includeMenu": true,
    "maxRestaurants": 40,
    "maxMenus": 20
}
````

### Example output (one row)

```json
{
    "id": "739118",
    "name": "Seoul Burgers & Shakes",
    "cuisines": ["Burger", "Bubble Tea", "Fast Food"],
    "rating": 4.2,
    "cost_for_two": "₹200 for two",
    "sla_minutes": 46,
    "offers": ["ITEMS AT ₹99"],
    "url": "https://www.swiggy.com/city/bangalore/...-rest739118",
    "menu_item_count": 111,
    "menu": {
        "categories": [
            {
                "title": "Recommended",
                "items": [
                    {
                        "name": "Korean Honey Sriracha Chicken Burger",
                        "price": 299.0,
                        "veg": false,
                        "in_stock": true
                    }
                ]
            }
        ]
    }
}
```

### Scheduling & integrations

Schedule runs (e.g. daily price tracking) from the Apify Console, or trigger via the
API and receive results by webhook. Export to JSON, CSV, Excel, or push to your database.

### AI assistants (MCP)

Prefer live access from Claude, ChatGPT, Cursor or your own agents? Use the companion
**Swiggy MCP Server** actor to search restaurants, fetch menus and geocode locations as
MCP tools.

### FAQ

**Which countries are supported?** India only — that's Swiggy's coverage.

**Do I need menus for every restaurant?** No — leave `includeMenu` off for a fast
listing, or cap menu fetches with `maxMenus`.

**Is login or an API key required?** No. The actor handles everything, including
Swiggy's anti‑bot challenge, automatically.

**How fresh is the data?** It's fetched live from Swiggy on every run.

**Is scraping this legal?** The actor collects publicly available data. You are
responsible for using the output in line with Swiggy's terms and applicable laws.

# Actor input Schema

## `location` (type: `string`):

Indian city or area to scrape restaurants in, e.g. "Bangalore", "Koramangala", "Mumbai". Resolved to coordinates automatically. Ignored if you set lat/lng below.

## `lat` (type: `number`):

Exact latitude. Overrides the location field and skips geocoding. Must be inside India (Swiggy is India-only).

## `lng` (type: `number`):

Exact longitude. Use together with latitude.

## `searchQuery` (type: `string`):

Search a dish or restaurant name instead of browsing an area, e.g. "biryani", "pizza", "Starbucks".

## `restaurantUrls` (type: `array`):

Specific Swiggy restaurant URLs to fetch full menus for (e.g. https://www.swiggy.com/city/bangalore/...-rest12808). Overrides listing/search.

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

Fetch the complete menu (categories + items with prices) for each restaurant. Menu fetches use an AWS WAF token minted automatically.

## `maxRestaurants` (type: `integer`):

Maximum number of restaurants to collect (listing/search modes).

## `maxMenus` (type: `integer`):

Cap on how many full menus to fetch when "Include full menu" is on (each is a separate request).

## `proxyConfiguration` (type: `object`):

Optional proxy. Swiggy serves data by coordinates, so a proxy is usually not required; enable Apify Proxy if you hit rate limits.

## Actor input object example

```json
{
  "location": "Bangalore",
  "restaurantUrls": [],
  "includeMenu": false,
  "maxRestaurants": 40,
  "maxMenus": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "location": "Bangalore",
    "restaurantUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/swiggy-restaurant-menu-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 = {
    "location": "Bangalore",
    "restaurantUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/swiggy-restaurant-menu-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 '{
  "location": "Bangalore",
  "restaurantUrls": []
}' |
apify call axlymxp/swiggy-restaurant-menu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiggy Restaurant & Menu Scraper",
        "description": "Scrape Swiggy (India) restaurants and full menus by city, coordinates, keyword or URL — ratings, cuisines, delivery ETA, cost for two, offers, and per-item prices as structured JSON.",
        "version": "1.0",
        "x-build-id": "y0ZLIEIGGiVfeTjKN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/axlymxp~swiggy-restaurant-menu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-axlymxp-swiggy-restaurant-menu-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/axlymxp~swiggy-restaurant-menu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-axlymxp-swiggy-restaurant-menu-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/axlymxp~swiggy-restaurant-menu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-axlymxp-swiggy-restaurant-menu-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": {
                    "location": {
                        "title": "Location (city or area)",
                        "type": "string",
                        "description": "Indian city or area to scrape restaurants in, e.g. \"Bangalore\", \"Koramangala\", \"Mumbai\". Resolved to coordinates automatically. Ignored if you set lat/lng below."
                    },
                    "lat": {
                        "title": "Latitude (optional)",
                        "type": "number",
                        "description": "Exact latitude. Overrides the location field and skips geocoding. Must be inside India (Swiggy is India-only)."
                    },
                    "lng": {
                        "title": "Longitude (optional)",
                        "type": "number",
                        "description": "Exact longitude. Use together with latitude."
                    },
                    "searchQuery": {
                        "title": "Search query (optional)",
                        "type": "string",
                        "description": "Search a dish or restaurant name instead of browsing an area, e.g. \"biryani\", \"pizza\", \"Starbucks\"."
                    },
                    "restaurantUrls": {
                        "title": "Restaurant URLs (optional)",
                        "type": "array",
                        "description": "Specific Swiggy restaurant URLs to fetch full menus for (e.g. https://www.swiggy.com/city/bangalore/...-rest12808). Overrides listing/search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeMenu": {
                        "title": "Include full menu",
                        "type": "boolean",
                        "description": "Fetch the complete menu (categories + items with prices) for each restaurant. Menu fetches use an AWS WAF token minted automatically.",
                        "default": false
                    },
                    "maxRestaurants": {
                        "title": "Max restaurants",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of restaurants to collect (listing/search modes).",
                        "default": 40
                    },
                    "maxMenus": {
                        "title": "Max menus to fetch",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on how many full menus to fetch when \"Include full menu\" is on (each is a separate request).",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. Swiggy serves data by coordinates, so a proxy is usually not required; enable Apify Proxy if you hit rate limits.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
