# Blinkit Product & Price Scraper — MRP, Discount & Stock (`haketa/blinkit-scraper`) Actor

Scrape Blinkit grocery products for any Indian city — name, brand, price, MRP, discount, pack size, stock and rating. Search by keyword, get live per-store prices, and export as JSON, CSV or Excel for price monitoring, competitor and market research.

- **URL**: https://apify.com/haketa/blinkit-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Blinkit Scraper — Product, Price, MRP, Discount & Stock Data

[![Blinkit Quick Commerce](https://img.shields.io/badge/India-Blinkit%20Quick%20Commerce-f8cb46?style=for-the-badge)](https://blinkit.com)
[![Per-Store Pricing](https://img.shields.io/badge/Data-Price%20%7C%20MRP%20%7C%20Discount%20%7C%20Stock-2da44e?style=for-the-badge)](#output)
[![Multi-City](https://img.shields.io/badge/Locations-8%20Metro%20Cities%20%2B%20Custom%20GPS-8250df?style=for-the-badge)](#input-parameters)
[![Export](https://img.shields.io/badge/Bulk%20Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-fb8500?style=for-the-badge)](#how-to-use)

**Scrape [Blinkit](https://blinkit.com) — India's leading quick-commerce grocery platform (formerly Grofers, owned by Zomato/Eternal) — into clean, structured datasets at scale.** This **Blinkit scraper** searches product keywords across any Indian city or exact GPS delivery coordinate and extracts every product with **name, brand, pack size, selling price (INR), MRP, computed discount %, stock status, live inventory count, rating, dark-store merchant ID, delivery ETA, and image URL** — with no login and no coding.

Export your **Blinkit data** in bulk to **JSON, CSV, Excel, or API** for **e-commerce price monitoring**, FMCG shelf analytics, and **B2B competitive intelligence**.

> Built for **FMCG & CPG brands, D2C founders, quick-commerce pricing analysts, retail intelligence teams, category managers, and data engineers** who need live, store-specific **Blinkit product and price data** across Indian metros.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target platform** | [blinkit.com](https://blinkit.com) — India's #1 10-minute grocery & quick-commerce marketplace |
| **Supported locations** | 8 preset metros (`mumbai`, `delhi`, `bangalore`, `hyderabad`, `chennai`, `pune`, `kolkata`, `gurgaon`) + any custom `latitude` & `longitude` pin in India |
| **Core extracted fields** | 19 fields: `productId`, `name`, `brand`, `packSize`, `price`, `mrp`, `discountPercent`, `currency`, `rating`, `inStock`, `inventory`, `merchantType`, `merchantId`, `eta`, `image`, `productUrl`, `searchQuery`, `city`, `scrapedAt` |
| **1,000+ deep pagination** | Full cursor pagination (`maxPagesPerSearch: 0`) + automatic grocery keyword & multi-city expansion when `maxItems >= 100` / `1,000+` |
| **Speed & Architecture** | Lightweight HTTP extraction (no heavy headless browser overhead) — ~100–400 products in 30–120 seconds |
| **Export formats** | JSON, CSV, Excel (XLSX), HTML, XML, Apify REST API, Webhooks, Google Sheets, Make & Zapier |

***

### 🔎 Why scrape Blinkit?

Blinkit powers hyper-local 10-minute delivery across hundreds of dark stores in India. Because pricing, promotional discounts, assortment, and stock availability are managed **per dark store** and fluctuate throughout the day, manual price checking in the mobile app is impossible to scale. What is in stock at a 15% discount in South Mumbai may be sold out or priced at full MRP in Bangalore or Gurgaon.

A **Blinkit data extractor** converts those dynamic dark-store shelves into a structured, repeatable data feed:

- **Real-time price & MRP monitoring** — track selling price (`price`), maximum retail price (`mrp`), and `discountPercent` across SKUs, brands, and cities on an automated schedule.
- **Dark-store stock & out-of-stock (OOS) intelligence** — monitor `inStock` booleans and exact `inventory` unit counts per store (`merchantId`) to prevent lost sales on high-velocity SKUs.
- **FMCG & D2C digital shelf benchmarking** — audit how your brand's pack sizes (`500 ml`, `1 kg`, multipacks), ratings, and price points compare against category competitors.
- **Multi-city assortment & regional pricing comparison** — run the same search list across Mumbai, Delhi, Bangalore, Hyderabad, Chennai, Pune, Kolkata, and Gurgaon in a single job.
- **MAP & promotional compliance** — verify whether retail partners and dark stores are honoring planned promotional discounts or undercutting minimum advertised prices.
- **Quick-commerce market research** — analyze private-label penetration, brand share of shelf, and category pricing trends across Indian quick commerce.

***

### ✨ What this Blinkit scraper does

- ✅ **Keyword search across any Indian city or GPS pin** — pass any list of grocery or FMCG search terms (`milk`, `chips`, `atta`, `chocolate`, `shampoo`, etc.) and target one or multiple cities at once.
- ✅ **Unlocked 1,000+ results pagination & auto-expansion** — `maxPagesPerSearch` defaults to `0` (unlimited pages per keyword, following Blinkit's offset/limit cursor to the end of each query). And because a single Blinkit search term typically yields ~12–140 products, requesting `maxItems >= 100` or `1,000+` **automatically expands across a curated 48-keyword Indian grocery catalog and metro cities** so large runs always reach your target volume!
- ✅ **Hyper-local per-store accuracy (`lat`/`lon`)** — choose from 8 preset metro cities or pass exact `latitude` and `longitude` coordinates to inspect a specific neighborhood dark store (`merchantId`).
- ✅ **Clean numeric INR pricing & discount calculation** — parses rupee strings (`"₹46"`) into clean numeric values (`price: 46`, `mrp: 50`) and automatically computes `discountPercent` (`8`).
- ✅ **Live inventory & dark-store metadata** — captures `inStock` (`true`/`false`), remaining `inventory` count, `merchantId`, `merchantType` (`express`), and delivery `eta`.
- ✅ **Strict per-store de-duplication** — every product is de-duplicated using a composite `city:productId` key, guaranteeing `0 duplicates` within any city while still allowing cross-city price comparisons for the same SKU.

***

### 🎯 Use cases

| Audience | How they use this Blinkit scraper |
|---|---|
| **FMCG & CPG Key Account Teams** | Track daily OSA (On-Shelf Availability), dark-store inventory levels, and discount depth across top Indian metros. |
| **D2C Brands & Growth Teams** | Monitor competitor pricing, pack-size variants, customer ratings, and search visibility for core category keywords. |
| **E-Commerce Pricing & BI Analysts** | Schedule hourly or daily runs via the Apify API to feed historical price and stock tables in Snowflake, BigQuery, or Power BI. |
| **Quick-Commerce Researchers** | Compare dark-store assortment breadth and price dispersion between Tier-1 cities (`mumbai`, `delhi`, `bangalore`) and other metros. |
| **Retail Agencies & Consultancies** | Deliver automated digital-shelf audit reports and promotional trackers to consumer-goods clients. |
| **Deal & Price-Comparison Apps** | Filter scraped datasets by `discountPercent >= 25` and `inStock: true` to surface the steepest live grocery deals by city. |

***

### 📥 Input parameters

Configure the scraper in the Apify Console form or pass JSON via the API. All fields have sensible defaults — running with default/prefill settings immediately extracts 100+ grocery products from Mumbai in under a minute.

| Parameter | Type | Default / Prefill | Description |
|---|---|---|---|
| `searchQueries` | `array` | `["milk"]` | Product keywords to search on Blinkit (e.g. `["milk", "chips", "chocolate", "atta", "oil"]`). When `maxItems >= 100`, additional grocery keywords are automatically appended after your keywords if needed to reach `maxItems`. |
| `cities` | `array` | `["mumbai"]` | Delivery cities to scrape: `mumbai`, `delhi`, `bangalore`, `hyderabad`, `chennai`, `pune`, `kolkata`, `gurgaon`. Select multiple cities to compare prices across stores. |
| `latitude` | `string` | `""` | **Advanced:** Exact delivery latitude (e.g. `"12.9716"`). When set with `longitude`, overrides `cities`. |
| `longitude` | `string` | `""` | **Advanced:** Exact delivery longitude (e.g. `"77.5946"`). Pairs with `latitude` to target a specific dark store. |
| `maxItems` | `integer` | `100` (prefill: `100`) | Maximum products to collect across all keywords and cities (`0` = unlimited). Supports `1,000+` bulk runs. |
| `maxPagesPerSearch` | `integer` | `0` (Auto/Unlimited) | Maximum result pages to fetch per keyword (`0` = walk all available pages until `maxItems` is reached). |
| `proxyConfiguration` | `object` | Residential IN | Proxy configuration. Automatically tries fast datacenter connections first and falls back to Indian residential proxies when needed. |

#### Example 1 — Fast Mumbai Grocery Scrape (Prefill / 100 Products)

```json
{
  "searchQueries": ["milk"],
  "cities": ["mumbai"],
  "maxItems": 100,
  "maxPagesPerSearch": 0
}
```

#### Example 2 — 1,000+ Multi-Category & Multi-City Price Benchmark

```json
{
  "searchQueries": ["milk", "bread", "chips", "chocolate", "atta", "rice", "oil", "tea", "coffee", "shampoo"],
  "cities": ["mumbai", "delhi", "bangalore"],
  "maxItems": 1200,
  "maxPagesPerSearch": 0
}
```

#### Example 3 — Hyper-Local Dark Store Audit by Exact GPS Coordinates

```json
{
  "searchQueries": ["ice cream", "soft drinks", "namkeen"],
  "latitude": "28.4595",
  "longitude": "77.0266",
  "maxItems": 250,
  "maxPagesPerSearch": 0
}
```

***

### 📤 Output format & field reference

Each scraped product is saved as a structured JSON record in the dataset.

#### 🛒 Product Identity & Assortment Fields

| Field | Coverage | Description |
|---|---|---|
| `productId` | 🟢 High (100%) | Unique Blinkit product identifier (e.g. `"678441"`). |
| `name` | 🟢 High (100%) | Full product display title (e.g. `"Sids Farm Toned Milk"`). |
| `brand` | 🟢 High (~99%) | Brand or manufacturer name (e.g. `"Amul"`, `"Sids Farm"`, `"Lay's"`). |
| `packSize` | 🟢 High (~99%) | Variant weight, volume, or pack count (e.g. `"500 ml"`, `"1 kg"`, `"2 x 400 g"`). |
| `rating` | 🟢 High (~95%) | Customer rating on a 5-point scale (e.g. `4.49`), or `null` for unrated new items. |
| `image` | 🟢 High (100%) | Direct high-resolution product image URL on Blinkit's CDN. |
| `productUrl` | 🟢 High (100%) | Canonical link to the product page on `blinkit.com`. |

#### ₹ Pricing, MRP & Discount Fields

| Field | Coverage | Description |
|---|---|---|
| `price` | 🟢 High (100%) | Current selling price at the selected store in Indian Rupees (numeric, e.g. `38`). |
| `mrp` | 🟢 High (100%) | Maximum Retail Price (MRP) in INR (numeric, e.g. `45`; equals `price` when not discounted). |
| `discountPercent` | 🟢 High (100%) | Automatically computed percentage discount off MRP (e.g. `16`, or `0` if sold at MRP). |
| `currency` | 🟢 High (100%) | ISO currency code — always `"INR"`. |

#### 📦 Stock, Dark Store & Provenance Fields

| Field | Coverage | Description |
|---|---|---|
| `inStock` | 🟢 High (100%) | Boolean (`true` / `false`) indicating whether the item is currently available for delivery at that store. |
| `inventory` | 🟢 High (~98%) | Available unit count reported by the dark store (e.g. `4`, `25`, `0`). |
| `merchantId` | 🟢 High (100%) | Fulfilling Blinkit dark-store / merchant ID (e.g. `"41649"`). |
| `merchantType` | 🟢 High (100%) | Store fulfillment tier (e.g. `"express"`). |
| `eta` | 🟢 High (~99%) | Delivery speed tag (e.g. `"earliest"`, `"8 mins"`). |
| `searchQuery` | 🟢 High (100%) | The search keyword that surfaced this product. |
| `city` | 🟢 High (100%) | Delivery city slug (e.g. `"mumbai"`) or custom `"lat,lon"` coordinate pair. |
| `scrapedAt` | 🟢 High (100%) | ISO 8601 timestamp when the product was scraped. |

#### Sample JSON output

```json
{
  "productId": "678441",
  "name": "Sids Farm Toned Milk",
  "brand": "Sids Farm",
  "packSize": "500 ml",
  "price": 38,
  "mrp": 38,
  "discountPercent": 0,
  "currency": "INR",
  "rating": 3.8,
  "inStock": true,
  "inventory": 4,
  "merchantType": "express",
  "merchantId": "41649",
  "eta": "earliest",
  "image": "https://cdn.grofers.com/da/cms-assets/cms/product/1ed2fb28-031b-47e5-ac4b-cd3c4730f186.png",
  "productUrl": "https://blinkit.com/prn/x/prid/678441",
  "searchQuery": "milk",
  "city": "mumbai",
  "scrapedAt": "2026-11-02T01:24:07.910Z"
}
```

***

### 🔁 Pagination & 1,000+ scale

- **Server-cursor deep pagination (`maxPagesPerSearch: 0`):** For every search keyword, the scraper follows Blinkit's `response.pagination.next_url` offset/limit cursor page by page until all matching SKUs for that query are collected.
- **Automatic keyword & city expansion for 100+ / 1,000+ runs:** Individual Blinkit search queries return ~12 to 140 products depending on the category. When you set `maxItems >= 100` or `1,000+`, the scraper first exhausts your exact `searchQueries` and then automatically expands across 48 high-volume grocery keywords (`milk`, `bread`, `eggs`, `butter`, `cheese`, `chips`, `biscuits`, `chocolate`, `atta`, `rice`, `dal`, `oil`, `ghee`, `tea`, `coffee`, `shampoo`, `soap`, etc.) and Indian metro cities (`maxItems >= 500`) so your run seamlessly reaches 1,000+ unique products.
- **Want to restrict strictly to your exact keywords?** Set `maxPagesPerSearch` to a specific number (e.g. `10`) or pass all the specific brand/category keywords you want in `searchQueries`.

***

### ⚙️ How to use

1. **Open the actor** in the Apify Console.
2. **Enter keywords & cities:** Add your product keywords in `searchQueries` and select one or more Indian metro cities in `cities` (or enter custom `latitude`/`longitude`).
3. **Set `maxItems`:** Keep `100` for a quick run or set `1000`+ for a large catalog export.
4. **Run & export:** Click **Start** and download your results as **JSON, CSV, Excel (XLSX), HTML, or XML**, or connect directly via the Apify API.

#### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/blinkit-scraper").call(run_input={
    "searchQueries": ["milk", "butter", "cheese", "paneer"],
    "cities": ["mumbai", "bangalore"],
    "maxItems": 300,
    "maxPagesPerSearch": 0,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['city']}] {item['name']} ({item['packSize']}) — ₹{item['price']} (MRP ₹{item['mrp']}, {item['discountPercent']}% off) | Stock: {item['inventory']}")
```

#### JavaScript / TypeScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('haketa/blinkit-scraper').call({
    searchQueries: ['chips', 'chocolate', 'soft drinks'],
    cities: ['delhi', 'gurgaon'],
    maxItems: 250,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} Blinkit products`);
```

#### cURL REST API example

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~blinkit-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["milk", "bread", "butter"],
    "cities": ["mumbai", "bangalore"],
    "maxItems": 150,
    "maxPagesPerSearch": 0
  }'
```

***

### 🗺️ Supported Indian Metro Cities & Store Routing

Blinkit routes every user session to the nearest hyper-local fulfillment center (`merchantId`) based on GPS coordinates. This scraper includes built-in coordinate presets for India's top 8 quick-commerce metros, plus full support for custom `latitude` and `longitude`:

| City Slug | Metro Region | Preset Coordinates (`lat`, `lon`) | Typical Use Case |
|---|---|---|---|
| `mumbai` | Mumbai Metropolitan Region (MMR) | `19.0760`, `72.8777` | Western India FMCG & D2C benchmark |
| `delhi` | New Delhi (NCR Core) | `28.6139`, `77.2090` | North India high-volume grocery tracking |
| `gurgaon` | Gurugram (Blinkit HQ market) | `28.4595`, `77.0266` | Deepest dark-store assortment & D2C launches |
| `bangalore` | Bengaluru Urban | `12.9716`, `77.5946` | South India tech-corridor quick commerce |
| `hyderabad` | Hyderabad Metro | `17.3850`, `78.4867` | Telangana & Deccan price/stock monitoring |
| `chennai` | Chennai Metro | `13.0827`, `80.2707` | Tamil Nadu regional assortment analysis |
| `pune` | Pune Metro | `18.5204`, `73.8567` | Tier-1 Maharashtra price comparison vs. Mumbai |
| `kolkata` | Kolkata Metro | `22.5726`, `88.3639` | Eastern India quick-commerce shelf tracking |
| Custom GPS | Any Indian neighborhood | Custom `latitude` & `longitude` | Pinpoint a specific neighborhood dark store |

***

### 📦 Built-in 48-Category Grocery Expansion Catalog

When you request `maxItems >= 100` or `1,000+` with only one or two seed keywords, the scraper first extracts all pages for your exact `searchQueries` and then automatically expands across major Indian grocery verticals to deliver your full target volume:

| Grocery Vertical | Auto-Expansion Keywords |
|---|---|
| **Dairy, Bread & Eggs** | `milk`, `bread`, `eggs`, `butter`, `cheese`, `curd`, `paneer` |
| **Munchies, Snacks & Sweets** | `chips`, `biscuits`, `chocolate`, `namkeen`, `cookies`, `ice cream` |
| **Atta, Rice, Oil & Dals** | `atta`, `rice`, `dal`, `oil`, `ghee`, `sugar`, `salt`, `spices`, `masala` |
| **Tea, Coffee & Cold Drinks** | `tea`, `coffee`, `juice`, `soft drinks`, `water`, `energy drink` |
| **Breakfast & Instant Food** | `noodles`, `pasta`, `oats`, `cornflakes`, `ketchup`, `jam`, `honey` |
| **Personal Care & Home Cleaning** | `shampoo`, `soap`, `toothpaste`, `face wash`, `detergent`, `dishwash` |
| **Fresh Fruits, Veggies & Dry Fruits** | `onion`, `potato`, `tomato`, `banana`, `apple`, `mango`, `dry fruits` |

***

### 📊 Downstream Analytics & BI Recipes

#### 1. Calculate Brand Share-of-Shelf & Average Discount (Python / Pandas)

```python
import pandas as pd

df = pd.read_json("blinkit_dataset.json")
summary = (
    df.groupby(["city", "brand"])
    .agg(
        sku_count=("productId", "nunique"),
        in_stock_rate=("inStock", "mean"),
        avg_price_inr=("price", "mean"),
        avg_discount_pct=("discountPercent", "mean"),
    )
    .reset_index()
    .sort_values(["city", "sku_count"], ascending=[True, False])
)
print(summary.head(15))
```

#### 2. Alert on Out-of-Stock (OOS) SKUs Across Dark Stores

Filter your dataset where `inStock == false` or `inventory <= 2` to trigger automated Slack, Teams, or email restock alerts via Make, Zapier, or n8n.

***

### 💡 Pro tips for best results

- **Compare dark stores within the same city:** Two neighborhoods in the same metro often map to different `merchantId` dark stores with different inventory and discounts. Pass exact `latitude` and `longitude` coordinates to pin a specific neighborhood store.
- **Track out-of-stock rates:** Schedule the actor every 2–4 hours and group by `brand` and `city` to calculate percentage OSA (`inStock === true`) during peak morning and evening grocery hours.
- **Spot deep promotions:** Sort or filter your exported CSV/Excel sheet by `discountPercent` descending to immediately see which brands are running aggressive flash discounts on Blinkit.

***

### ❓ Frequently Asked Questions (FAQ)

**Why do prices and stock vary by city?**
Blinkit operates a network of hyper-local dark stores (`merchantId`). Each store maintains its own physical inventory (`inventory`) and localized promotional pricing (`price` vs. `mrp`). Selecting a city (or passing `latitude`/`longitude`) tells the scraper which dark store's catalog to query.

**How many products can I extract in a single run?**
As many as you need — from **100 products in ~20 seconds** to **1,000+ products across multiple keywords and cities**. With `maxPagesPerSearch: 0`, the scraper walks every result page and automatically expands across grocery categories when `maxItems >= 100`.

**Do I need a Blinkit account or OTP login?**
No login, phone number, or OTP is required.

**Do I need proxies?**
An Indian proxy configuration is pre-filled by default. The scraper automatically attempts fast datacenter requests first and falls back to Indian residential IPs when needed so runs stay both reliable and cost-efficient.

**Are both selling price and MRP included?**
Yes — every record contains numeric `price` (selling price), `mrp` (maximum retail price), and computed `discountPercent`.

**Can I export Blinkit data to Google Sheets, Excel, or BI tools?**
Yes — every run dataset can be downloaded directly as **Excel (XLSX), CSV, JSON, HTML, or XML** from the Apify Console, or streamed automatically into Google Sheets, Snowflake, BigQuery, Make, Zapier, or a webhook.

**How does de-duplication work across cities and keywords?**
Products are de-duplicated using a composite `city:productId` key. If two search keywords (`"milk"` and `"toned milk"`) return the same product in Mumbai, it is saved only once for Mumbai. If you scrape both Mumbai and Delhi, the product appears once for `mumbai` and once for `delhi` so you can compare regional pricing side by side.

***

### ⚠️ Known Platform Nuances & Limitations

- **Store-specific pricing & stock:** Blinkit has no single national price — every price, MRP discount, and inventory count belongs to the dark store (`merchantId`) serving the requested city or GPS coordinates.
- **Per-keyword search depth:** Individual Blinkit search queries return the platform's ranked matches for that keyword (~12 to 140 SKUs). To extract 500 or 1,000+ products, leave `maxItems >= 500` so the scraper automatically chains across grocery search terms and metro cities, or provide a comprehensive list of category/brand keywords in `searchQueries`.
- **Unrated new launches:** Newly listed items that have not yet accumulated customer reviews on Blinkit return `rating: null`. All core pricing, stock, and identity fields still populate at 100%.

***

### 🔗 Related E-Commerce & Grocery Scrapers

Explore other grocery, retail, and quick-commerce scrapers from the same publisher:

- [Woolworths Scraper — Australia Grocery Prices, Specials & Unit Price](https://apify.com/haketa/woolworths-scraper)
- [Coles Scraper — Australia Supermarket Prices, Specials & Stock](https://apify.com/haketa/coles-scraper)
- [Wildberries Scraper — Products, Prices, Sellers & Reviews](https://apify.com/haketa/wildberries-scraper)
- [Coupang Scraper — Korea E-Commerce Products & Prices](https://apify.com/haketa/coupang-scraper)
- [Trendyol Scraper — Turkey E-Commerce Products & Prices](https://apify.com/haketa/trendyol-scraper)

***

### 📋 Changelog

- **v1.2 (2026-11)** — Set `maxPagesPerSearch` default/prefill to `0` (auto/unlimited cursor pagination governed by `maxItems`); added automatic 48-keyword Indian grocery & multi-city expansion when `maxItems >= 100` / `1,000+` so large runs never stop early; set `maxItems` prefill to `100` for fast `<45s` prefill runs; synced `exampleRunInput`.
- **v1.1 (2026-11)** — Added deep server-cursor (`response.pagination.next_url`) pagination across all result pages per keyword; verified 420-product Mumbai run with 0 duplicates.
- **v1.0 (2026-09)** — Initial release with per-city coordinate routing, numeric INR price/MRP parsing, discount calculation, and dark-store inventory extraction.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/blinkit-scraper/changelog.md

# Actor input Schema

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

Products to search on Blinkit (e.g. milk, chips, chocolate, atta).

## `cities` (type: `array`):

Cities whose store to scrape (prices and stock are per‑store).

## `latitude` (type: `string`):

Optional exact delivery latitude (overrides cities).

## `longitude` (type: `string`):

Optional exact delivery longitude (overrides cities).

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

Stop after collecting this many products (across keywords and cities). Set 0 for no limit.

## `maxPagesPerSearch` (type: `integer`):

Maximum result pages to fetch per keyword. Set 0 for auto/unlimited governed by Maximum products.

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

Residential India proxy is recommended. The actor uses datacenter first and falls back to Indian residential automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "chips",
    "chocolate",
    "shampoo"
  ],
  "cities": [
    "mumbai"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped Blinkit product records for this run.

# 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 = {
    "searchQueries": [
        "milk"
    ],
    "cities": [
        "mumbai"
    ],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/blinkit-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 = {
    "searchQueries": ["milk"],
    "cities": ["mumbai"],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/blinkit-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "milk"
  ],
  "cities": [
    "mumbai"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call haketa/blinkit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/blinkit-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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