# Zepto Product Screener (`scrapix/zepto-product-screener`) Actor

Extract product listings from Zepto (https://www.zepto.com)  India's 10-minute grocery delivery app by search keyword or category for any delivery location you choose.
Get one clean row per product, complete with brand, MRP, selling price, discount, pack size, stock status, image, and product URL.

- **URL**: https://apify.com/scrapix/zepto-product-screener.md
- **Developed by:** [Saleem Javed](https://apify.com/scrapix) (community)
- **Categories:** E-commerce, Lead generation, Integrations
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

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

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

## Zepto Quick-Commerce Product Scraper

**Built for reliability** In quick-commerce, the scraper you can schedule and trust is the one worth running.

Extract **product listings from [Zepto](https://www.zepto.com)** — India's
10-minute grocery delivery app — by **search keyword** or **category**, for any
**delivery location** you choose. Get one clean row per product, complete with
brand, MRP, selling price, discount, pack size, stock status, image, and product
URL.

Because Zepto is **hyperlocal**, prices and availability differ by area — so you
tell the Actor *where* to deliver (a pincode or city/area), and it scrapes the
catalog of the store that actually serves that location.

Perfect for **price monitoring, assortment & competitor analysis, availability
tracking, and grocery market research**.

### Who it's for:
FMCG brands tracking competitor pricing · quick-commerce and
retail analysts · researchers monitoring grocery prices and availability · teams
building pricing dashboards and assortment reports.

### What it does

Give it a delivery location plus either search keywords (e.g. `milk`,
`mustard oil`) or Zepto category page URLs, and it returns the products Zepto shows
for that location — structured as JSON/CSV/Excel, ready for your spreadsheet or
database.

### Features

- 📍 **Location-aware** — pass a pincode (e.g. `560001`) or area (e.g.
  `Koramangala, Bangalore`); the Actor geocodes it and scrapes the store serving
  that point, so prices and stock match what a real customer there sees.
- 🔎 **Search or category** — scrape by keyword, or paste category page URLs.
- 💰 **Full pricing** — MRP, selling price, final discounted price, and discount
  percentage (all in rupees).
- 📦 **Rich product data** — brand, pack size/unit, stock status, available
  quantity, category, product image, and product URL.
- 🛡️ **Resilient runs** — a keyword or URL that fails is skipped with a warning;
  the run finishes and still returns everything else.
- 🌐 **Proxy support** — Apify Proxy (residential, country `IN` recommended).

### Input

| Field | Type | Description |
|---|---|---|
| `location` | string | Delivery pincode or city/area. Required for keyword search. |
| `searchTerms` | array of strings | Keywords to search, one result set each. |
| `categoryUrls` | array of strings | Zepto `/cn/.../cid/.../scid/...` category page URLs. |
| `maxResultsPerTerm` | integer | Max products per keyword/URL (default `60`). |
| `proxyConfiguration` | object | Proxy settings. Residential + country `IN` recommended. |

Provide at least one of `searchTerms` or `categoryUrls`.

#### Example input

```json
{
    "location": "Koramangala, Bangalore",
    "searchTerms": ["milk", "coca cola"],
    "maxResultsPerTerm": 60,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN"
    }
}
````

### Example output

```json
{
    "searchTerm": "milk",
    "source": "search",
    "name": "Amul Gold Full Cream Fresh Milk",
    "brand": "Amul",
    "mrp": 33.0,
    "sellingPrice": 33.0,
    "discountedSellingPrice": 31.0,
    "discountPercent": 6,
    "unit": "1 pack (500 ml)",
    "packSize": "500",
    "inStock": true,
    "availableQuantity": 12,
    "categoryId": "1a7e46a8-e627-450f-8960-490b550eeee6",
    "productId": "205a24dc-7dd9-5ceb-9fa5-0a0c469d9013",
    "baseProductId": "dac5a323-bd7e-4034-b198-1e2f2ae776d3",
    "imageUrl": "https://cdn.zeptonow.com/production/cms/product_variant/....jpeg",
    "productUrl": "https://www.zepto.com/pn/amul-gold-full-cream-fresh-milk/pvid/6f3c2f7a-1d4b-4e9a-9c2e-7b6a0d51e3c8",
    "storeId": "b4dc8d65-ed2e-4142-81b6-373982b13500",
    "location": "Koramangala, Bangalore",
    "latitude": 12.9357,
    "longitude": 77.6241
}
```

Every field is available as a column when you export to CSV, Excel, JSON, or XML.

### Good to know / limitations

- **Location drives everything.** Different pincodes map to different stores with
  different prices, offers, and stock. The `storeId`/`latitude`/`longitude` on
  each row tell you exactly which store the data came from.
- **Keyword search works best for product types.** Search keywords are matched to
  Zepto's categories (e.g. `mustard oil`, `milk`, `chips`, `paneer`, `chocolate`
  all work). Brand-specific queries that aren't category names (e.g. `coca cola`)
  may return nothing — for those, use a category URL instead.
- **Use residential proxies.** Zepto runs behind bot protection and rate-limits
  datacenter IPs; Apify residential proxies (country `IN`) are recommended.
- **Snapshots, not feeds.** Quick-commerce prices and availability change
  through the day — treat results as a point-in-time snapshot.

### Disclaimer

This tool fetches publicly visible catalog data from Zepto on demand using your
own runs and proxies. You are responsible for using the output in compliance with
Zepto's Terms of Use and applicable laws.

# Actor input Schema

## `searchTerms` (type: `array`):

Product keywords to search on Zepto (e.g. "milk", "coca cola", "chips"). One result set is collected per keyword. Requires a delivery location below.

## `categoryUrls` (type: `array`):

Zepto category/subcategory page URLs to scrape, e.g. https://www.zepto.com/cn/ice-creams-more/ice-creams/cid/<id>/scid/<id>. Copy them from the Zepto website.

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

Where to deliver — a 6-digit Indian pincode (e.g. "560001") or an area/city name (e.g. "Koramangala, Bangalore"). Zepto's prices, availability, and the serving store all depend on this. Required for keyword search.

## `maxResultsPerTerm` (type: `integer`):

Stop after collecting this many products per search keyword or category URL.

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

Proxy settings. Zepto runs behind AWS WAF and rate-limits datacenter IPs; RESIDENTIAL proxies with country IN are strongly recommended for reliable runs.

## Actor input object example

```json
{
  "searchTerms": [
    "milk",
    "coca cola"
  ],
  "categoryUrls": [
    "https://www.zepto.com/cn/ice-creams-more/ice-creams/cid/c5550221-3ad4-40e4-a14f-5275cef37781/scid/03ec68f8-13cf-4eed-b72c-9de5fb0d0b62"
  ],
  "location": "Koramangala, Bangalore",
  "maxResultsPerTerm": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all scraped products.

# 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 = {
    "searchTerms": [
        "milk"
    ],
    "location": "560001",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapix/zepto-product-screener").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 = {
    "searchTerms": ["milk"],
    "location": "560001",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapix/zepto-product-screener").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 '{
  "searchTerms": [
    "milk"
  ],
  "location": "560001",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call scrapix/zepto-product-screener --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zepto Product Screener",
        "description": "Extract product listings from Zepto (https://www.zepto.com)  India's 10-minute grocery delivery app by search keyword or category for any delivery location you choose.\nGet one clean row per product, complete with brand, MRP, selling price, discount, pack size, stock status, image, and product URL.",
        "version": "0.0",
        "x-build-id": "4DVHpMsLa1dNEup7e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapix~zepto-product-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapix-zepto-product-screener",
                "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/scrapix~zepto-product-screener/runs": {
            "post": {
                "operationId": "runs-sync-scrapix-zepto-product-screener",
                "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/scrapix~zepto-product-screener/run-sync": {
            "post": {
                "operationId": "run-sync-scrapix-zepto-product-screener",
                "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": {
                    "searchTerms": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Product keywords to search on Zepto (e.g. \"milk\", \"coca cola\", \"chips\"). One result set is collected per keyword. Requires a delivery location below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category page URLs",
                        "type": "array",
                        "description": "Zepto category/subcategory page URLs to scrape, e.g. https://www.zepto.com/cn/ice-creams-more/ice-creams/cid/<id>/scid/<id>. Copy them from the Zepto website.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Delivery location (pincode or city/area)",
                        "type": "string",
                        "description": "Where to deliver — a 6-digit Indian pincode (e.g. \"560001\") or an area/city name (e.g. \"Koramangala, Bangalore\"). Zepto's prices, availability, and the serving store all depend on this. Required for keyword search."
                    },
                    "maxResultsPerTerm": {
                        "title": "Max results per term",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after collecting this many products per search keyword or category URL.",
                        "default": 60
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Zepto runs behind AWS WAF and rate-limits datacenter IPs; RESIDENTIAL proxies with country IN are strongly recommended for reliable runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
