# Zepto Product Scraper - Prices, MRP, Stock by Location (`memo23/zepto-product-scraper`) Actor

Scrape Zepto product listings for any delivery location in India — name, brand, price, MRP, discount, pack size, stock, rating and image. Search by keyword or paste category/product URLs. Compare prices across cities. JSON, CSV or Excel out, billed per product.

- **URL**: https://apify.com/memo23/zepto-product-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 39 total users, 10 monthly users, 74.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 products

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Zepto Product Scraper

Turn [Zepto](https://www.zepto.com) — India's 10-minute grocery app — into structured product data for **any delivery location**. Search by keyword, or paste category / product URLs, and get one clean row per product with **price, MRP, discount, pack size, stock, rating and image** — tagged with the location it was priced for.

Built for price monitoring, competitor tracking and quick-commerce market research across India.

#### How it works

![How the Zepto Product Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-zepto.png)

#### ✨ Why use this scraper?

- **Real, location-specific prices** — Zepto stock and prices vary by store, so every row is tagged with the delivery location it was scraped for. Run multiple cities to compare.
- **Three ways in** — keyword search, category URLs, or direct product URLs. Mix them in one run.
- **Rich product rows** — name, brand, MRP, selling price, discount %, Zepto Pass price, pack size, unit, stock, rating, category and images.
- **Prices in ₹, not paise** — converted and clean, ready for a sheet.
- **No login, no browser, no captcha** — talks to Zepto's own app API directly; fast and cheap to run.
- **JSON, CSV, Excel or API** — pipe straight into your BI tool, sheet or pipeline. Billed per product.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Brand / FMCG team | Track your SKUs' prices, discounts and availability across cities on Zepto |
| Competitor analyst | Compare a category's pricing between Zepto stores / cities |
| Quick-commerce researcher | Measure assortment, discount depth and stock-outs over time |
| Pricing / revenue team | Feed live competitor prices into dynamic-pricing models |
| Data / app builder | Seed a grocery price-comparison product with structured rows |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Location (required) | `Koramangala, Bengaluru` or `12.9352,77.6245` | Resolves the delivery store; everything is priced for it |
| Search keyword | `milk`, `chocolate`, `atta` | Searches the keyword in each location, paginated |
| Category URL | `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` | Sweeps a category for each location (use this deeplink form — it carries both ids the API needs) |
| Product URL | `https://www.zepto.com/pn/{slug}/pvid/{id}` | Looks up that product (resolved via search) for each location |

**Not supported:** placing orders, cart / checkout, account-only data, or any non-public content. The actor reads only the public catalogue.

#### ⚙️ How it works

1. **Resolve** each location — free text is geocoded through Zepto's own maps, then matched to a serviceable store.
2. **Fetch** the catalogue from Zepto's app API: keyword search, category page, or product page — paginated.
3. **Parse** the product grid into flat rows; prices are converted from paise to ₹.
4. **Tag** every row with its store / location, dedupe, and emit one row per product.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `locations` | array | — | Area names or `lat,lng` pairs. **Required** (Zepto prices are per-store). |
| `searchQueries` | array | — | Products to search, **one product per entry** (e.g. `milk`, `bread`, `atta`). Zepto searches one product at a time, so a comma/newline-separated list in a single field (`bread, milk`) is auto-split and each product searched individually. |
| `startUrls` | array | — | Zepto category (`/cn/…/cid/…`) and/or product (`/pn/…/pvid/…`) URLs. |
| `maxItems` | integer | `1000` | Hard cap on product rows for the whole run. |
| `maxItemsPerQuery` | integer | `1000` | Cap per keyword × location (and per URL × location). |
| `maxConcurrency` | integer | `4` | Parallel requests. Keep low — Zepto rate-limits per IP. |
| `maxRequestRetries` | integer | `12` | Retry budget on Zepto's rate-limit codes (the 477–486 band) and network errors. Each retry rotates to a fresh India IP across two residential pools. |
| `proxy` | object | Apify Residential IN | India residential is used automatically. |

#### 📊 Output overview

Each dataset record is **one product, priced for one location**. Run the same keyword across several `locations` to get one row per (product × location) — ideal for cross-city price comparison. All money fields are in INR (₹), converted from Zepto's internal paise.

#### 📦 Output sample

```json
{
  "rowType": "product",
  "productId": "5dac97a5-0241-4b24-9a5d-8243838257f5",
  "variantId": "ba77f9b3-0525-4ce8-bc4b-a2480419b780",
  "productUrl": "https://www.zepto.com/pn/godrej-jersey-toned-fresh-milk-pouch/pvid/ba77f9b3-0525-4ce8-bc4b-a2480419b780",
  "name": "Godrej Jersey Toned Fresh Milk | Pouch",
  "brand": "Godrej Jersey",
  "mrp": 27,
  "sellingPrice": 26,
  "discountedPrice": 26,
  "discountPercent": 3,
  "zeptoPassPrice": null,
  "packSize": "1 pack (490 ml or 500 ml)",
  "unit": "ml",
  "weightInGms": 500,
  "images": ["https://cdn.zeptonow.com/production/cms/product_variant/8fd1fa19-56f7-4f23-8a0d-625fc669cec2.jpeg"],
  "inStock": true,
  "availableQuantity": 10,
  "category": "Dairy, Bread & Eggs",
  "categoryId": "5d92e29c-1f5a-43a2-9d8e-8b6f5f0f0a11",
  "rating": 4.6,
  "ratingCount": 66206,
  "storeId": "5ec071fd-78df-41f6-b3ae-7298d9f96a3d",
  "location": "Koramangala, Bengaluru",
  "latitude": 12.9352,
  "longitude": 77.6245,
  "sourceQuery": "milk",
  "sourceUrl": null,
  "scrapedAt": "2026-06-23T20:30:00.000Z"
}
```

#### 🗂 Key output fields

| Field | Type | Notes |
|---|---|---|
| `name` / `brand` | string | Product name + brand |
| `sellingPrice` / `mrp` / `discountedPrice` | number | In ₹ (converted from paise) |
| `discountPercent` | number | Discount off MRP |
| `zeptoPassPrice` | number | null | Zepto Pass member price, when offered |
| `packSize` / `unit` / `weightInGms` | string / number | Pack details |
| `inStock` / `availableQuantity` | boolean / number | Live stock for the store |
| `rating` / `ratingCount` | number | Product rating + number of ratings |
| `category` / `categoryId` | string | Primary category |
| `images` | string\[] | Product image URLs |
| `productUrl` / `productId` / `variantId` | string | Canonical URL + ids |
| `storeId` / `location` / `latitude` / `longitude` | string / number | The store & location this row was priced for |
| `sourceQuery` / `sourceUrl` | string | null | What produced the row |

#### ❓ FAQ

**Why do I need a location?** Zepto is a delivery app — every product's price, discount and stock depend on the store serving your address. No location, no catalogue.

**Can I compare prices across cities?** Yes — that's the point. Put several entries in `locations` and the same product comes back once per location, each with its local price and stock.

**How many products per keyword?** A Zepto keyword search returns roughly a few hundred products. Categories can be larger. Use `maxItemsPerQuery` to cap.

**Are the prices accurate / live?** Yes — they're read live from Zepto's catalogue at scrape time, in ₹.

**Do I need to set up proxies?** No. India residential routing is built in (Zepto is India-only). Just give it a location and what to scrape.

#### 💬 Support

Found a bug or need an extra field? Open an issue on the [actor's Issues tab](https://apify.com/memo23/zepto-product-scraper/issues) and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom field, another quick-commerce app (Blinkit, Instamart), or a scheduled price-tracking feed into your warehouse? Custom scraping and pipeline work is available on request.

#### 🔎 Explore more scrapers

Looking for more India / commerce data sources? Check out the other directory, e-commerce and company scrapers in the same publisher's collection on the Apify Store.

***

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/zepto-product-scraper`).

**Purpose:** Zepto (India's 10-minute grocery app) product rows for any delivery location, priced per-store so the same product can be compared across cities.

**Minimal input:**

```json
{
  "locations": ["Koramangala, Bengaluru"],
  "searchQueries": ["milk"],
  "maxItems": 50
}
```

URL mode instead of keywords: drop `searchQueries` and pass `"startUrls": ["https://www.zepto.com/pn/{slug}/pvid/{id}"]` (product) or a `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` deeplink (category).

**Output:** one row per product × location — rowType, productId, variantId, productUrl, name, brand, mrp, sellingPrice, discountedPrice, discountPercent, zeptoPassPrice, packSize, unit, weightInGms, images, inStock, availableQuantity, category, categoryId, rating, ratingCount, storeId, location, latitude, longitude, sourceQuery, sourceUrl, scrapedAt. Money fields are in ₹ (converted from paise).

**Behaviors an agent should know:**

- `locations` is required (prices/stock are per-store); every query and URL is scraped once per location, so the same product returns one row per location.
- Set `maxItems` (whole-run cap, default 1000) and `maxItemsPerQuery` (per keyword × location, default 1000); one keyword search returns roughly a few hundred products.
- `searchQueries` is one product per entry; a comma/newline list in a single entry (`bread, milk`) is auto-split and searched individually.
- Category URLs must use the `Categories?categoryId=…&subCategoryId=…` deeplink form — a plain `/cn/…/cid/…` URL carries only one id and won't list products.
- India residential proxy is built in; keep `maxConcurrency` low (3–5) — Zepto rate-limits per IP.
- Billing: one paid `product` event per row — see the Pricing tab on the actor page.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Zepto (Kiranakart Technologies Pvt. Ltd.) or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Zepto product catalogue data — no authenticated endpoints, no account-only features, no order placement. Users are responsible for ensuring their use complies with Zepto's Terms of Service, applicable data-protection law (including India's DPDP Act, GDPR and CCPA where relevant) and any contractual obligations of their own organisation.

***

### SEO Keywords

zepto scraper, scrape zepto, zepto product scraper, zepto price scraper, zepto api, zepto data extraction, quick commerce scraper india, zepto price tracker, grocery price scraper india, zepto product data, q-commerce price monitoring, zepto competitor analysis, indian grocery delivery scraper, zepto category scraper, zepto mrp discount scraper, blinkit instamart zepto data, dynamic pricing grocery india, zepto stock availability, scrape indian quick commerce, zepto bengaluru mumbai delhi prices

# Actor input Schema

## `locations` (type: `array`):

An area / landmark name (e.g. `Koramangala, Bengaluru`, `Bandra West, Mumbai`) or a `latitude,longitude` pair (e.g. `12.9352,77.6245`). Text is geocoded via Zepto's own maps. Must be inside a Zepto-serviceable city.

## `searchQueries` (type: `array`):

Products to search — one product per line. e.g. `milk`, `chocolate`, `atta`. Each is searched separately in every location and paginated. Tip: you can also put several products in one line separated by commas (`bread, milk`) — they're split and searched individually (Zepto searches one product at a time).

## `startUrls` (type: `array`):

Product URLs `https://www.zepto.com/pn/{slug}/pvid/{id}` and/or category URLs in the app deeplink form `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` (this form carries both ids the category API needs — a plain `/cn/.../cid/{id}` URL has only one and won't list products). Each is scraped for each location.

## `maxItems` (type: `integer`):

Hard cap on product rows across the entire run. Each row is one paid `product` event. Default 1000.

## `maxItemsPerQuery` (type: `integer`):

Cap per (keyword × location) and per (URL × location). Note Zepto search returns roughly a few hundred products per keyword. Default 1000.

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. Zepto rate-limits per IP — keep this low (3–5) so the limiter isn't tripped. Default 4.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on Zepto's rate-limit codes (the 477–486 band), 429 and network errors. Each retry rotates to a fresh India residential IP across two pools (Evomi + Webshare) with backoff, so throttled requests break through. Backoff is time-bounded (≈2s of cumulative wait per retry) so one throttled request can never stall the run for minutes. Default 12.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "locations": [
    "Koramangala, Bengaluru"
  ],
  "searchQueries": [
    "milk"
  ],
  "startUrls": [],
  "maxItems": 1000,
  "maxItemsPerQuery": 1000,
  "maxConcurrency": 4,
  "maxRequestRetries": 12
}
```

# 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 = {
    "locations": [
        "Koramangala, Bengaluru"
    ],
    "searchQueries": [
        "milk"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/zepto-product-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 = {
    "locations": ["Koramangala, Bengaluru"],
    "searchQueries": ["milk"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/zepto-product-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 '{
  "locations": [
    "Koramangala, Bengaluru"
  ],
  "searchQueries": [
    "milk"
  ],
  "startUrls": []
}' |
apify call memo23/zepto-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IpMuaACewIJkDhBMh/builds/wj6qMkIDzC0hNDvzs/openapi.json