# Blinkit Scraper — Prices, MRP, Stock & Delivery ETA (`logiover/blinkit-scraper`) Actor

Blinkit scraper: export quick-commerce products by keyword, category, city or product id with price, MRP, discount, stock, brand, pack size, category path, images, store id and delivery ETA. About 90 Indian cities, up to 30,000 products per city. No login.

- **URL**: https://apify.com/logiover/blinkit-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, AI, Agents
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 97.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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 — Prices, MRP, Stock & Delivery ETA

> This Actor is not affiliated with, endorsed by or sponsored by Blinkit, Eternal Limited (formerly Zomato Limited) or any of their group companies. "Blinkit" is a trademark of its owner, used here only to name the website the data comes from. The Actor reads product and price data that blinkit.com shows to every visitor without a login. You are responsible for using the data lawfully — see [Legal and compliance](#legal-and-compliance).

**Blinkit Scraper** turns blinkit.com, India's 10-minute grocery and quick-commerce store, into a spreadsheet. Choose a city (about 90 Indian cities, from Mumbai, Delhi and Bengaluru to Jaipur, Kochi and Guwahati), then search by keyword, walk the category tree or look up product ids, and get one clean row per product: **selling price, MRP, discount percent and rupees saved, stock state and units, brand, pack size, category path, rating, images, the dark store that serves the price and the delivery ETA** — plus, on request, the product page itself: description, ingredients, nutrition facts, shelf life, manufacturer, FSSAI licence and country of origin. It is a Blinkit scraper, a Blinkit API alternative and a quick-commerce price tracker in one: scrape blinkit.com with no login, no account, no cookies to paste and no browser, then export the Blinkit product list to CSV, Excel, JSON or XML, or pull it through the Apify API. One run measured on 29 Oct 2026 returned 12,000 unique products from 3 cities with zero duplicates.

Searching for a **Blinkit price tracker**, a **Blinkit product list in Excel**, **grocery delivery price comparison for India**, a **Blinkit data extractor** or **MRP and discount data by city**? Hindi and Hinglish searches land here too: **ब्लिंकिट डेटा स्क्रैपर**, **ब्लिंकिट से प्रोडक्ट की कीमत और एमआरपी कैसे निकालें**, **क्विक कॉमर्स प्राइस डेटा**, "Blinkit se data kaise nikale", "Blinkit ke rate Excel mein", "dark store assortment data", "kirana price vs quick commerce price". Blinkit prices, stock and delivery times belong to the dark store that serves a location, so the Actor takes a **city name or a latitude/longitude pair** and writes the store id and the delivery promise into every row. That is what lets you compare Mumbai with Delhi, one pack size with another, or this morning with last week.

### Table of contents

- [At a glance](#at-a-glance)
- [What you get](#what-you-get)
- [Who uses Blinkit data and how](#who-uses-blinkit-data-and-how)
- [Cookbook: ready-to-run inputs](#cookbook-ready-to-run-inputs)
- [How to run it in Apify Console](#how-to-run-it-in-apify-console)
- [How to run it through the API](#how-to-run-it-through-the-api)
- [Input reference](#input-reference)
- [Data dictionary](#data-dictionary)
- [Example output](#example-output)
- [Cities](#cities)
- [Scale and speed](#scale-and-speed)
- [What you pay](#what-you-pay)
- [Integrations](#integrations)
- [Performance tips](#performance-tips)
- [Troubleshooting and status messages](#troubleshooting-and-status-messages)
- [Honest limits](#honest-limits)
- [Blinkit Scraper compared with the alternatives](#blinkit-scraper-compared-with-the-alternatives)
- [FAQ](#faq)
- [Glossary](#glossary)
- [Legal and compliance](#legal-and-compliance)
- [Changelog](#changelog)
- [Support](#support)

### At a glance

| | |
|---|---|
| **Source** | blinkit.com search, category and product pages, read as the same public JSON the site's own pages use |
| **Modes** | keyword search · category browse · product ids or URLs — combinable, sharing one `maxResults` |
| **Where** | a city (about 90 Indian cities) or any `latitude,longitude` pair; every location has its own store, prices and ETA |
| **One row per** | product pack at one store, de-duplicated by `uniqueKey` (`merchantId_productId`) |
| **Columns** | 58: price, MRP, discount, stock, brand, pack size, category, rating, images, store, ETA, optional product-page details |
| **Filters** | in stock only · minimum discount · price band · brands |
| **Speed (measured 29 Oct 2026)** | prefill 5 s, first row after 3.6 s · 1,000 products in 11 s · 12,000 products from 3 cities in 140 s |
| **Depth (measured)** | one city store, all categories: 30,724 unique products in 240 s |
| **Export** | JSON, CSV, Excel, XML, HTML, JSONL — or API, webhooks, Google Sheets, Make, Zapier, n8n; no login, cookies or browser |
| **Price** | pay per result: $2.00 per 1,000 products on the Free plan, down to $1.30 per 1,000 on the top plans |

### What you get

Every row is one product pack at one store. Numbers stay numbers, anything Blinkit does not show is `null` (never a placeholder, never a zero standing in for "unknown"), and the [Data dictionary](#data-dictionary) lists every column with type, meaning and measured fill rate.

**Identity.** `productId` (the number after `/prid/` in the product URL), `merchantId` (the dark store whose price and stock you see), `groupId` (shared by the pack sizes of one product) and `uniqueKey` = `merchantId_productId`, the key to de-duplicate on.

**Product.** `name`, `brand`, `variant` (pack text such as "500 ml", "2 x 200 ml", "1 kg"), `productType`, `url`, `imageUrl` and up to ten `images`.

**Price.** `price` (selling price in rupees, taxes included), `mrp`, `discountPercent` (calculated from price and MRP, 0 without markdown), `discountAmount` and `offerTag`, Blinkit's "20% OFF" badge (rounded down, absent on small markdowns).

**Stock.** `inStock`, `availability` (`available`, `out_of_stock`, `coming_soon`), `inventory` (units a customer can add; the store shows at most 50) and `isSoldOut`.

**Category.** `categoryPath` ("Grocery & Kitchen > Dairy, Bread & Eggs > Milk") split into `categoryGroup`, `categoryCollection` and `category`, plus `l1CategoryId`; product-page details add the catalogue levels `l0Category`, `l1Category`, `l2Category` and their ids.

**Reputation and ads.** `rating` (1–5), `ratingCount`, `isSponsored` (a paid "Ad" placement) and `position`, the 1-based rank in the keyword or category list, sponsored cards included; the pack sizes of one card share its rank.

**Store and delivery.** `location` (what you asked for), `city`, `state`, `latitude`, `longitude`, `deliveryEtaMinutes`, `deliveryEtaText` ("Delivery in 8 minutes") and `merchantType`.

**Source.** `sourceMode` (`search`, `category` or `product`), `searchQuery` and `scrapedAt` (ISO 8601, UTC).

**Product-page details (optional).** `description`, `keyFeatures`, `ingredients`, `nutrition` (per-100-g facts as an object), `shelfLife`, `manufacturer`, `marketedBy`, `fssaiLicense`, `countryOfOrigin`, `foodType` (`veg`, `non_veg`, `egg`, `non_food`), `attributes` (every customer-facing attribute: box contents, colour, skin type, warranty...) and `detailsFetched`. Switch on `includeDetails`, or give product ids, which always read the page.

One pack, three stores. Selling price / MRP in rupees, read in one run on 29 Oct 2026:

| Product (id) | Mumbai | Delhi | Bengaluru |
|---|---|---|---|
| Onion, 1 kg (530158) | 63 / 80 | 66 / 75 | 66 / 75 |
| Coriander Bunch, 100 g (3889) | 24 / 29 | 13 / 16 | 20 / 24 |
| Pears Pure & Gentle Glow Soap, 3 x 125 g (19481) | 180 / 211 | 187 / 211 | 180 / 211 |
| Ghar Soaps De-Tanning Magic Face Wash, 100 ml (563200) | 230 / 333 | 239 / 333 | 249 / 333 |

Fresh produce carries the local word in brackets: "Onion (Kanda)" in Mumbai, "Onion (Pyaz)" in Delhi, "Onion (Eerulli)" in Bengaluru. Compare cities by `productId`, not by name.

### Who uses Blinkit data and how

**1. Price-comparison and deal apps.** Refresh your city list nightly, key rows on `uniqueKey`, and show `price`, `mrp`, `discountPercent` and `deliveryEtaMinutes` beside other retailers in your own product index.

**2. Hyperlocal inflation trackers.** Fix a basket of product ids (onion, tomato, milk, atta, ghee), run it in ten cities each morning and chart the basket per city. The table above shows why: the same onion pack cost 63 rupees in Mumbai and 66 in Delhi.

**3. FMCG brand managers.** Share of shelf and discounting: `brands: ["Amul"]` over `categories: ["all"]`, then count rows per category and city, average `discountPercent` and the share of `out_of_stock`.

**4. D2C brands.** Watch rival MRP, selling price, `rating` and `ratingCount` for a keyword set; add `includeDetails` to compare ingredients, key features and pack sizes.

**5. Market-research agencies.** Dated, reproducible studies: assortment depth per city, price bands, brands per category, stock rate by category, every row stamped with `scrapedAt` and the store id.

**6. Category managers.** Pack-size ladders from `variant` and `groupId`, price per 100 g worked out yourself, MRP gaps between rival brands inside one `productType`.

**7. Wholesalers and kirana procurement.** Use Blinkit's shelf price for staples (atta, dal, oil, ghee, sugar) as a benchmark against supplier quotes, and watch `inventory` and `availability` for local shortages.

**8. Data journalists.** Which city pays more for the same pack? Read one `productId` in several cities in a single run, so every row comes from the same minute, and publish the spread with store ids as evidence.

**9. Academic economists.** Price dispersion across cities, MRP versus selling price, markdown depth; scheduled runs make a panel in which `scrapedAt`, `merchantId` and `deliveryEtaMinutes` pin down each observation.

**10. Dark-store and assortment consultants.** SKUs per store (`merchantId`) and per category (`category`, `menuCategoryId`), the `merchantType` mix, stock depth from `inventory`.

**11. Ad agencies and retail-media analysts.** `isSponsored` plus `position` for a keyword shows who holds the top slots of a Blinkit search. De-duplication is run-wide, so use one keyword per run for a clean rank snapshot.

**12. Nutrition and health apps.** With `includeDetails`, `ingredients`, `nutrition`, `foodType`, `shelfLife` and `fssaiLicense` fill a packaged-food database or flag allergens in ingredient text.

**13. Deal-alert bots.** Schedule `minDiscountPercent` plus `onlyInStock`, diff against the previous dataset on `uniqueKey`, push new deals to Telegram or WhatsApp.

**14. AI agents and MCP clients.** "Cheapest 1 litre toned milk in Pune right now?" An agent calls the Actor with a small JSON input and reasons over flat rows: price, pack size, store, ETA.

**15. Catalogue onboarding, ONDC sellers and compliance teams.** See how a category is named, packed and priced on Blinkit before you list your own range (`variant` ladders, `mrp` levels, `productType` wording), or audit labels through `manufacturer`, `marketedBy`, `fssaiLicense` and `countryOfOrigin`.

### Cookbook: ready-to-run inputs

Paste any of these into the Input tab (JSON view) or send them through the API. Common city spellings work (Delhi, Bangalore, Gurgaon, Bombay). Each keyword, category browse and product id, in each location, is a target, and targets share `maxResults` equally.

**1. The 30-product test (the prefill, a few seconds)**

```json
{ "locations": ["Mumbai"], "categories": ["Dairy, Bread & Eggs"], "maxResults": 30 }
```

**2. Milk in five cities, 200 products each**

```json
{ "locations": ["Mumbai", "Delhi", "Bengaluru", "Hyderabad", "Chennai"], "searchQueries": ["milk"], "maxResults": 1000 }
```

**3. Discounted snacks: at least 30 % off, in stock only**

```json
{ "locations": ["Mumbai"], "categories": ["Snacks & Drinks"], "minDiscountPercent": 30, "onlyInStock": true, "maxResults": 5000 }
```

**4. One brand through the search box** (for a whole-store sweep use `"categories": ["all"]` instead of `searchQueries`; it reads every category list to its end)

```json
{ "locations": ["Mumbai"], "searchQueries": ["amul"], "brands": ["Amul"], "maxResults": 700 }
```

**5. The full store of one city**

```json
{ "locations": ["Mumbai"], "categories": ["all"], "maxResults": 40000 }
```

**6. Three metros, all categories (the input of the proof run)**

```json
{ "locations": ["Mumbai", "Delhi", "Bengaluru"], "categories": ["all"], "maxResults": 12000 }
```

**7. Ingredients, nutrition and shelf life for dairy**

```json
{ "locations": ["Mumbai"], "categories": ["Milk", "Curd & Yogurt", "Cheese & Butter"], "includeDetails": true, "maxResults": 300 }
```

**8. The same product ids in four cities** (3 products x 4 cities = up to 12 rows; ids and URLs can be mixed)

```json
{ "locations": ["Mumbai", "Delhi", "Bengaluru", "Kolkata"], "productIds": ["530158", "367909", "https://blinkit.com/prn/amul-cow-milk/prid/160704"], "maxResults": 20 }
```

**9. What can be ordered right now: protein products in Pune** (drop `onlyInStock` to see sold-out and coming-soon items too, which a stock-out monitor needs)

```json
{ "locations": ["Pune"], "categories": ["Protein Supplements"], "onlyInStock": true, "maxResults": 300 }
```

**10. Coordinates instead of city names**

```json
{ "locations": ["19.0760,72.8777", "12.9716,77.5946"], "searchQueries": ["eggs"], "maxResults": 100 }
```

**11. Staples packs up to 100 rupees in four cities** (16 targets, 200 products each)

```json
{ "locations": ["Delhi", "Mumbai", "Kolkata", "Chennai"], "searchQueries": ["atta", "toor dal", "paneer", "desi ghee"], "maxPrice": 100, "maxResults": 3200 }
```

**12. Competitor watch with product-page details**

```json
{ "locations": ["Delhi"], "searchQueries": ["protein bar", "whey protein", "muesli"], "includeDetails": true, "maxResults": 600 }
```

**13. Sponsored-rank snapshot for one keyword** (the first pages, with `position` and `isSponsored`)

```json
{ "locations": ["Mumbai"], "searchQueries": ["shampoo"], "maxResults": 60 }
```

**14. A deal feed for a bot**

```json
{ "locations": ["Mumbai"], "categories": ["Chips & Namkeen", "Sweets & Chocolates", "Drinks & Juices"], "minDiscountPercent": 25, "onlyInStock": true, "maxResults": 300 }
```

To cap the spend, set `maxResults` and also **Max cost per run** in the run options; see [What you pay](#what-you-pay).

### How to run it in Apify Console

1. Open the Actor and its **Input** tab. The prefilled input (Mumbai, category "Dairy, Bread & Eggs", 30 products) is a complete working example.
2. Under **Cities or coordinates** type city names (Enter after each) or `lat,lon` pairs.
3. Choose what to collect: **Search keywords**, **Categories to browse** and **Product ids or URLs** can be combined and share **Maximum products**. The prefilled category stays active when you add keywords, so clear it for keywords only. With all three empty the Actor browses every category.
4. Add filters for a slice (**Only products in stock**, **Minimum discount (%)**, **Minimum price**, **Maximum price (INR)**, **Brands**) and switch on **Add product page details to keyword and category results** for ingredients, nutrition and the like.
5. Set **Maximum products**. You pay per product saved, so it is also your spending limit; **Max cost per run** in the run options is a second, hard limit.
6. Press **Start**. The status message refreshes every few seconds ("Collected 1397 products (101 requests, route DC)") and the first rows reach the **Output** tab after about five seconds.
7. The Output tab has five views (Overview, Prices and stock, Store and delivery, Catalogue and ranking, Product page details). Export as JSON, CSV, Excel, XML, HTML or JSONL, with or without chosen columns.

### How to run it through the API

Start a run and wait for the rows (replace `YOUR_USERNAME` and `YOUR_TOKEN`; the Actor id also works in place of `YOUR_USERNAME~blinkit-scraper`):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~blinkit-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "locations": ["Mumbai"], "searchQueries": ["amul butter"], "maxResults": 50 }'
```

That call returns the rows as JSON and is limited to about five minutes. For bigger jobs start asynchronously, then read the dataset:

```bash
curl -s -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~blinkit-scraper/runs?token=YOUR_TOKEN&maxTotalChargeUsd=5" \
  -H "Content-Type: application/json" \
  -d '{ "locations": ["Mumbai", "Delhi"], "categories": ["all"], "maxResults": 10000 }'
## the answer holds data.id, data.defaultDatasetId and data.defaultKeyValueStoreId
curl -s "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN&format=csv&clean=1&fields=name,variant,price,mrp,discountPercent,inStock,location" -o blinkit.csv
curl -s "https://api.apify.com/v2/key-value-stores/STORE_ID/records/SUMMARY?token=YOUR_TOKEN"
```

`maxTotalChargeUsd=5` caps that run at five dollars. The dataset can be read while the run is going. Every run also writes a `SUMMARY` record to its key-value store: the outcome, counts, each location with its store id and ETA, skipped locations and the numbers behind the status message.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `locations` | list of text | `["Mumbai"]` | City names or `latitude,longitude` pairs; see [Cities](#cities). Locations are collected one after another and share the result limit. |
| `searchQueries` | list of text | empty | Keywords as typed in Blinkit's search box: `milk`, `amul butter`, `maggi`, `iphone charger`, `atta`. Each returns up to roughly 650 distinct products per city. |
| `categories` | list of text | empty (the Console prefills `Dairy, Bread & Eggs`) | `all`, a top group, a section, a category name, an L1 category id or a category URL (`https://blinkit.com/cn/.../cid/<l0>/<l1>`). Read page by page, breadth first, so a small limit still samples many categories. |
| `productIds` | list of text | empty | Product ids (`160704`) or product URLs (`https://blinkit.com/prn/amul-cow-milk/prid/160704`). Always reads the full product page, in every selected location. |
| `includeDetails` | true / false | `false` | Adds the product-page columns to keyword and category rows. About twice the requests. |
| `onlyInStock` | true / false | `false` | Skips products that are out of stock or coming soon at that store. |
| `minDiscountPercent` | number 0–100 | none | Keeps products whose selling price is at least this far below MRP. Works on `discountPercent`, not on the badge. |
| `minPrice`, `maxPrice` | number ≥ 0 | none | Selling-price band in rupees; either side may stay empty. |
| `brands` | list of text | empty | Keeps products whose brand or name contains one of these words (`Amul`, `Haldiram's`); not case sensitive. |
| `maxResults` | whole number 1–10,000,000 | `1000` (the Console prefills 30) | Stop after this many saved products across all locations, keywords, categories and ids. |
| `maxConcurrency` | whole number 1–30 | `16` | Parallel sessions. Small runs open fewer on purpose (at least 4, about one per 10 requested products). Lower it for a gentler run. |
| `proxyConfiguration` | proxy | Apify datacenter proxy | Leave as is. Cloudflare in front of Blinkit refuses most datacenter addresses at random, so the Actor tries fresh ones until one is accepted and keeps it; if datacenter addresses stop working it moves to Indian residential addresses by itself and tests the datacenter route again later. |

**How the limit is shared.** Targets get equal shares; a target that runs dry hands its unused share to the others. The proof run gave each of its three cities 4,000.

**Matching categories.** Names are compared case-insensitively with the group, section and category names of that city's menu; a name used in several sections (`Organic`, `Premium`) selects all of them, an id or URL selects one category. Menus differ a little by city: the proof run found 289, 289 and 290 categories in Mumbai, Delhi and Bengaluru. Mumbai's menu on 25 Oct 2026 had 4 groups, 28 sections and 289 categories:

The four top groups are Beauty & Personal Care, Grocery & Kitchen, Snacks & Drinks and Household Essentials; each holds 4 to 8 sections (for example Dairy, Bread & Eggs, Chips & Namkeen, Skin & Face, Cleaners & Repellents).

**Filters and counting.** Filters act before a product is counted: what they remove is not saved, not charged and does not use up `maxResults`. A narrow filter makes the run read more pages and it may end with "everything Blinkit exposes for these settings".

**Locations.** A coordinate pair must lie in India (latitude 5–38, longitude 67–98). Two locations served by the same store produce the same rows once, labelled with the first location. A name that is not on the list is skipped with a note in the status message; if no location can be used the run fails with `INVALID_INPUT`.

### Data dictionary

All 58 columns, grouped by theme, in the order of the CSV header below. **Filled** is the share of rows with a value in the measured platform runs (list columns: the 12,000-row proof run; product-page columns: the 1,000-row details run). In product-id mode `ratingCount`, `isSponsored`, `position` and `searchQuery` are `null`, because those values exist only on list cards. The category columns are filled in category mode and, in other modes, when product-page details are on. `isSoldOut` was `false` on every proof-run row, out-of-stock ones included; use `inStock` or `availability`.

#### Identity fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `uniqueKey` | text | Stable row key: merchantId_productId. The same product in two cities (two stores) is two rows; use this to de-duplicate. | 100 % |
| `productId` | number | Blinkit product id (the number after /prid/ in the product URL). | 100 % |
| `merchantId` | number | Id of the Blinkit dark store (merchant) whose price and stock the row shows. Each city centre is served by its own store; one location can also have a second store for instant-delivery items. | 100 % |
| `groupId` | number | Variant group id: pack sizes and flavours of one product share it. | 100 % |

#### Product fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `name` | text | Product name as shown on Blinkit. | 100 % |
| `brand` | text | Brand as shown in the cart item; empty for loose produce. | 99.6 % |
| `variant` | text | Pack size or unit text, e.g. "500 ml", "2 x 200 ml", "1 kg". | 100 % |
| `productType` | text | Blinkit product type, e.g. "Toned Milk", "Wheat Bread". | 100 % |

#### Price fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `price` | number | Selling price in Indian rupees at this store, inclusive of taxes. | 100 % |
| `mrp` | number | Maximum retail price in rupees; equals the price when there is no markdown. | 100 % |
| `discountPercent` | number | Percentage below the MRP, computed as (mrp - price) / mrp, one decimal. 0 when there is no markdown. | 100 % |
| `discountAmount` | number | Rupees saved against the MRP. | 100 % |
| `offerTag` | text | The discount badge as shown, e.g. "20% OFF" (Blinkit rounds down); empty when the card has no badge. | 66.5 % |

#### Stock fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `inStock` | true / false | True when the product can be ordered now; false for out-of-stock and coming-soon items. | 100 % |
| `inventory` | number | Units Blinkit lets a customer add; the store shows at most 50, so 50 means "50 or more". | 100 % |
| `availability` | text | Blinkit product state: available, out_of_stock or coming_soon. | 100 % |
| `isSoldOut` | true / false | Blinkit's own sold-out flag. Out-of-stock items are normally reported through availability, not this flag. | 100 % |

#### Category fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `categoryPath` | text | Category path. Category mode: the store menu path "group > section > category" the product was listed under, e.g. "Grocery & Kitchen > Dairy, Bread & Eggs > Bread & Pav". Keyword and product modes with page details: Blinkit's catalogue path "L0 > L1 > L2". | 100 % |
| `categoryGroup` | text | Top group of the store menu, e.g. "Snacks & Drinks". Category mode only. | 100 % in category mode |
| `categoryCollection` | text | Section of the store menu, e.g. "Chips & Namkeen". Category mode only. | 100 % in category mode |
| `category` | text | Lowest menu level (the category page the product was listed on), e.g. "Chips & Wafers". Category mode only. | 100 % in category mode |
| `menuCategoryId` | number | Id of the Blinkit category page (the l1_cat of the listing) the product was found on. Category mode only; not the product's catalogue category (see l1CategoryId). | 100 % in category mode |
| `l1CategoryId` | number | Blinkit catalogue level 1 category id of the product. Product page details only. | 100 % with details / 0 % without |
| `l0Category` | text | Catalogue level 0 name from the product page, e.g. "Dairy & Breakfast". Product page details only. | 99.8 % with details / 0 % without |
| `l1Category` | text | Catalogue level 1 name from the product page. Product page details only. | 99.8 % with details / 0 % without |
| `l2Category` | text | Catalogue level 2 name from the product page, e.g. "Sunflower Oil". Product page details only; not every product has an L2. | 89.3 % with details / 0 % without |
| `l0CategoryId` | number | Catalogue level 0 id. Product page details only. | 100 % with details / 0 % without |
| `l2CategoryId` | number | Catalogue level 2 id. Product page details only. | 100 % with details / 0 % without |

#### Reputation fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `rating` | number | Average customer rating (1-5, one decimal); empty for products without ratings. | 94 % |
| `ratingCount` | number | Number of ratings. Blinkit prints large counts rounded ("10.6 lac"), so big values are approximations. | 94 % in keyword and category modes |
| `isSponsored` | true / false | True when the card is a paid ad placement ("Ad" badge) in the list. | 100 % in keyword and category modes |

#### Media fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `imageUrl` | text | Main product image on Blinkit's CDN. | 100 % |
| `images` | list | Product images on Blinkit's CDN: all images of the product page when page details are on (up to 12), otherwise the images of the list card (up to 10). | 100 % |
| `url` | text | Product page on blinkit.com. | 100 % |

#### Location fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `location` | text | The location you asked for: the city name, or the "lat,lon" pair. | 100 % |
| `city` | text | City name when a city was given (empty for raw coordinates). | 100 % |
| `state` | text | Indian state of the city (empty for raw coordinates). | 100 % |
| `latitude` | number | Latitude sent to Blinkit; it selects the store. | 100 % |
| `longitude` | number | Longitude sent to Blinkit. | 100 % |
| `deliveryEtaMinutes` | number | Blinkit's promised delivery time for this location at scrape time, in minutes. | 100 % |
| `deliveryEtaText` | text | The same as Blinkit prints it, e.g. "Delivery in 8 minutes". | 100 % |
| `merchantType` | text | Delivery type of the item: express, instant, longtail, super_longtail, unicorn. | 100 % |

#### Source fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `searchQuery` | text | The keyword that found the product (keyword mode only). | 100 % in keyword mode / 0 % otherwise |
| `position` | number | 1-based rank in the keyword results or category list, counting sponsored items. Variants share the rank of the card they belong to. | 100 % in keyword and category modes / 0 % in product mode |
| `sourceMode` | text | search, category or product. | 100 % |
| `scrapedAt` | text | ISO 8601 UTC time the row was written. | 100 % |

#### Product page details fields

| Field | Type | Meaning | Measured fill rate |
|---|---|---|---|
| `description` | text | Product description text. | 76.8 % with details / 0 % without |
| `keyFeatures` | text | Key features, one per line. | 74.8 % with details / 0 % without |
| `ingredients` | text | Ingredient list (food and personal care). | 57.1 % with details / 0 % without |
| `nutrition` | object | Nutrition facts as the page prints them, e.g. {"Energy Per 100 g": "900 kcal"}. | 2 % with details / 0 % without |
| `shelfLife` | text | Shelf life as printed, e.g. "9 months". | 76.3 % with details / 0 % without |
| `manufacturer` | text | Manufacturer name and address. | 85.5 % with details / 0 % without |
| `marketedBy` | text | Marketer name and address. | 83.6 % with details / 0 % without |
| `fssaiLicense` | text | FSSAI food licence number (food items). | 1.9 % with details / 0 % without |
| `countryOfOrigin` | text | Country of origin as printed. | 92.6 % with details / 0 % without |
| `foodType` | text | veg, non_veg, egg or non_food as Blinkit tags it. | 99.9 % with details / 0 % without |
| `attributes` | object | Every customer-facing attribute of the product page (box contents, colour, gender, skin type, warranty...), name to value. | 100 % with details / 0 % without |
| `detailsFetched` | true / false | True when the product page was read for this row. | 100 % (true when the page was read) |

### Example output

Below is a real row from the 29 Oct 2026 proof run, unmasked (category mode, no product-page details). Keyword runs also fill `searchQuery`; rows read with `includeDetails`, or from product ids, fill the product-page columns too.

```json
{
  "uniqueKey": "41649_752015",
  "productId": 752015,
  "merchantId": 41649,
  "groupId": 2708051,
  "name": "BLA BLI BLU Perfume Gift Set For Women",
  "brand": "Bla Bli Blu",
  "variant": "3 x 30 ml",
  "price": 699,
  "mrp": 900,
  "discountPercent": 22.3,
  "discountAmount": 201,
  "offerTag": "22% OFF",
  "inStock": true,
  "inventory": 7,
  "availability": "available",
  "isSoldOut": false,
  "productType": "Perfume Gift Set",
  "categoryPath": "Beauty & Personal Care > Bath & Body > Bath & Beauty Gifts",
  "categoryGroup": "Beauty & Personal Care",
  "categoryCollection": "Bath & Body",
  "category": "Bath & Beauty Gifts",
  "menuCategoryId": 710,
  "l1CategoryId": null,
  "l0Category": null,
  "l1Category": null,
  "l2Category": null,
  "l0CategoryId": null,
  "l2CategoryId": null,
  "rating": 4.5,
  "ratingCount": 2879,
  "isSponsored": false,
  "imageUrl": "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1775457726381-640.png",
  "images": [
    "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1775457726381-640.png",
    "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1775457726381-641.png"
  ],
  "url": "https://blinkit.com/prn/bla-bli-blu-perfume-gift-set-for-women/prid/752015",
  "location": "Mumbai",
  "city": "Mumbai",
  "state": "Maharashtra",
  "latitude": 19.076,
  "longitude": 72.8777,
  "deliveryEtaMinutes": 13,
  "deliveryEtaText": "Delivery in 13 minutes",
  "merchantType": "express",
  "searchQuery": null,
  "position": 3,
  "sourceMode": "category",
  "description": null,
  "keyFeatures": null,
  "ingredients": null,
  "nutrition": null,
  "shelfLife": null,
  "manufacturer": null,
  "marketedBy": null,
  "fssaiLicense": null,
  "countryOfOrigin": null,
  "foodType": null,
  "attributes": null,
  "detailsFetched": false,
  "scrapedAt": "2026-10-29T10:28:50.377Z"
}
```

The product-page columns of a row read with `includeDetails` (product "Similac Classic Follow up Formula (Stage-2)", Mumbai, texts shortened here for the page; the dataset keeps them whole), from the 1,000-row details run of 29 Oct 2026:

```json
{
  "description": "IMPORTANT NOTICE: MOTHER’s MILK IS BEST FOR THE BABY\nSimilac Classic contains 33 Nutrients including\nTotal Potentiall...",
  "keyFeatures": "Similac Classic contains 33 Nutrients including Total Potentially Available Nucleotides and Omega 3 & Omega 6 fatty a...",
  "ingredients": "Lactose, skimmed milk powder, edible vegetable oil (high oleic sunflower oil, coconut oil, soy oil), maltodextrin, wh...",
  "shelfLife": "18 months",
  "manufacturer": "Abbott Healthcare Pvt. Ltd., Plot No. 901-B, GIDC, Jhagadia, Bharuch, Gujarat - 393110, India",
  "marketedBy": "Abbott Healthcare Pvt. Ltd., Regd. Office, 3, Corporate Park, Sion - Trombay Road, Mumbai, Maharashtra - 400071, India",
  "fssaiLicense": "10012022000149",
  "countryOfOrigin": "India",
  "foodType": "veg",
  "l0Category": "Baby Care",
  "l1Category": "Baby Food",
  "l2Category": "Baby Food (6-12 M)",
  "l0CategoryId": 7,
  "l1CategoryId": 1590,
  "l2CategoryId": 1591,
  "nutrition": {
    "Protein Per 100 g": "14.5 g",
    "Total Carbohydrates Per 100 g": "61.2 g",
    "Added Sugar Per 100 g": "31 g",
    "Total Fat Per 100 g": "19.5 g"
  },
  "attributes": {
    "Age Group": "6 - 12 months",
    "Description": "IMPORTANT NOTICE: MOTHER’s MILK IS BEST FOR THE BABY\nSimi...",
    "Key Features": "Similac Classic contains 33 Nutrients including Total Pot...",
    "Ingredients": "Lactose, skimmed milk powder, edible vegetable oil (high...",
    "Unit": "400 g"
  },
  "detailsFetched": true
}
```

**CSV columns** (the header row of a CSV export, 58 columns, in this order):

```
uniqueKey,productId,merchantId,groupId,name,brand,variant,productType,price,mrp,discountPercent,discountAmount,offerTag,inStock,inventory,availability,isSoldOut,categoryPath,categoryGroup,categoryCollection,category,menuCategoryId,l1CategoryId,l0Category,l1Category,l2Category,l0CategoryId,l2CategoryId,rating,ratingCount,isSponsored,imageUrl,images,url,location,city,state,latitude,longitude,deliveryEtaMinutes,deliveryEtaText,merchantType,searchQuery,position,sourceMode,description,keyFeatures,ingredients,nutrition,shelfLife,manufacturer,marketedBy,fssaiLicense,countryOfOrigin,foodType,attributes,detailsFetched,scrapedAt
```

`images` (a list) and `nutrition` and `attributes` (objects) are written as JSON text inside one CSV cell. In Excel parse them with Power Query (Transform, Parse, JSON); through the API ask for `format=json` or `format=jsonl`, where lists and objects stay real.

### Cities

Blinkit picks the dark store from the latitude and longitude of the request, so for a city name the Actor sends that city's centre. When probed on 25 Oct 2026, **89 of 91 Indian city centres were served**, each by its own store; Vasai-Virar and Nagpur answered "location not serviceable". The 89 cities below lie in 24 states and union territories. Blinkit changes where it delivers, so the Actor checks every location at the start of a run and reports the ones it refuses.

Common spellings work (Bangalore, Gurgaon, Bombay, Calcutta, Madras, Poona, Mysore, Vizag, Trivandrum, Cochin, Trichy, Pondicherry, Allahabad, Mangalore, PCMC and more). Delhi, NCR and Delhi NCR all mean New Delhi. For a town or neighbourhood that is not listed, give a `latitude,longitude` pair; Blinkit answers for that point or refuses it.

| State | Cities that answered with a store on 25 Oct 2026 |
|---|---|
| Andhra Pradesh | Guntur, Tirupati, Vijayawada, Visakhapatnam |
| Assam | Guwahati |
| Bihar | Patna |
| Chandigarh | Chandigarh |
| Chhattisgarh | Raipur |
| Delhi | New Delhi |
| Goa | Panaji |
| Gujarat | Ahmedabad, Gandhinagar, Rajkot, Surat, Vadodara |
| Haryana | Ambala, Bahadurgarh, Faridabad, Gurugram, Hisar, Karnal, Panchkula, Panipat, Rohtak, Sonipat |
| Jammu and Kashmir | Jammu, Srinagar |
| Jharkhand | Jamshedpur, Ranchi |
| Karnataka | Belagavi, Bengaluru, Hubballi, Mangaluru, Mysuru |
| Kerala | Kochi, Kozhikode, Thiruvananthapuram, Thrissur |
| Madhya Pradesh | Bhopal, Gwalior, Indore, Jabalpur |
| Maharashtra | Aurangabad, Kalyan, Kolhapur, Mira-Bhayandar, Mumbai, Nashik, Navi Mumbai, Pimpri-Chinchwad, Pune, Thane |
| Odisha | Bhubaneswar, Cuttack |
| Puducherry | Puducherry |
| Punjab | Amritsar, Jalandhar, Ludhiana, Mohali, Zirakpur |
| Rajasthan | Ajmer, Bikaner, Jaipur, Jodhpur, Kota, Udaipur |
| Tamil Nadu | Chennai, Coimbatore, Madurai, Salem, Tiruchirappalli |
| Telangana | Hyderabad, Warangal |
| Uttar Pradesh | Agra, Aligarh, Bareilly, Ghaziabad, Gorakhpur, Greater Noida, Kanpur, Lucknow, Meerut, Moradabad, Noida, Prayagraj, Varanasi |
| Uttarakhand | Dehradun |
| West Bengal | Kolkata, Siliguri |

### Scale and speed

All figures were measured on the Apify platform with the shipped defaults (16 parallel sessions, datacenter proxy, 2 GB memory) on 29 Oct 2026.

| Run | Result |
|---|---|
| Prefill: Mumbai, category "Dairy, Bread & Eggs", 30 products | 5 s end to end, first row after 3.6 s |
| 1,000 products, Mumbai, all categories | 11 s |
| 12,000 products, 3 cities (Mumbai, Delhi, Bengaluru), all categories | 140 s, about 86 products per second, 0 duplicates, first row after 5.8 s; the same input took 85 s in an earlier run with Blinkit's rate limits less busy |
| One city store, all categories | 30,724 unique products in 240 s |
| `includeDetails` on | 1,000 products at 8 products per second |

**What limits the speed.** A category page is one request for 15 products, a search page one request for 12 cards, and a product page one more request per product, which is why `includeDetails` runs are slower. Blinkit answered a category page in a median 0.8 s in the proof run. Of its 981 request attempts, 754 were answered, 46 were refused (HTTP 403) and 181 were rate-limit answers (HTTP 429): refused addresses were swapped at once, rate limits waited out, and no page failed (738 category pages read, 0 failed). Peak memory was 551 MB of the 2,048 MB allotted.

**What the proof dataset looks like.** Each city supplied 4,000 of the 12,000 products, taken from page one of its categories in menu order, so the sample favours what Blinkit lists first. Its shares: 92.5 % available, 6.5 % out of stock, 1.1 % coming soon; 82.8 % priced below MRP, 34.8 % at least 20 % below and 7.5 % at least 50 % below (median markdown of the discounted ones 16.7 %); 14.1 % sponsored; 84.5 % from the `express` store type; 94.0 % rated; median selling price ₹175; 1,622 brands and 7,777 distinct product ids, because a product id returns once per city. All `scrapedAt` stamps lie within 99 seconds, so the three cities form one time-aligned snapshot. These shares describe this sample, not whole stores.

**How big is a store?** Catalogue sizes differ by city. A full crawl of the Mumbai store on 25 Oct 2026 found 30,852 distinct products in its 289 categories.

### What you pay

Pay per result: **$2.00 per 1,000 products on the Free plan**, falling with your Apify plan to **$1.30 per 1,000** at the top tiers. A product counts once, whether or not its product page was read. Only rows saved to the dataset are charged: duplicates and products removed by your filters never reach it.

| Products | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| 1,000 | $2.00 | $1.77 | $1.53 | $1.30 |
| 10,000 | $20 | $17.70 | $15.30 | $13 |
| 100,000 | $200 | $177 | $153 | $130 |

**Maximum cost per run.** Every run has a spending cap: the one you set in the run options (or `maxTotalChargeUsd` in the API), or the platform's default when you leave it empty. The Actor reads the cap before it writes rows, trims its last batch to what the cap pays for and ends the run as SUCCEEDED with `outcome` = `MAX_COST` in the `SUMMARY` record and the message `Saved N products - this run's maximum cost per run covers N results; raise "Max cost per run" to collect more.` A test with a $0.05 cap saved exactly 28 products and was charged for exactly 28 (29 Oct 2026); how many rows a cap covers depends on your plan's price per result.

**Spending less.** Name the groups, sections or categories you need instead of exporting a store and filtering afterwards, leave `includeDetails` off unless you need ingredients or nutrition, set `maxResults` to what you will use, and schedule only the cities and categories you watch.

### Integrations

**Node.js (apify-client)**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/blinkit-scraper').call({
    locations: ['Mumbai', 'Delhi'], searchQueries: ['amul butter'], maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].name, items[0].price, items[0].mrp);
```

**Python (apify-client), with a price-change diff against an earlier dataset**

```python
from apify_client import ApifyClient
import pandas as pd
client = ApifyClient("YOUR_TOKEN")
run = client.actor("YOUR_USERNAME/blinkit-scraper").call(run_input={
    "locations": ["Mumbai"], "categories": ["Milk"], "maxResults": 300})
now = pd.DataFrame(list(client.dataset(run["defaultDatasetId"]).iterate_items())).set_index("uniqueKey")
old = pd.DataFrame(list(client.dataset("EARLIER_DATASET_ID").iterate_items())).set_index("uniqueKey")
both = old[["name", "price"]].join(now[["price"]], how="inner", rsuffix="_now")
print(both[both["price"] != both["price_now"]])
```

**Make, Zapier, n8n.** Use the Apify app or node: "Run Actor" with the JSON input, then "Get dataset items"; trigger on "Actor run finished" to push rows to Slack, e-mail, a CRM or a database.

**Google Sheets and Airtable.** In Sheets: `=IMPORTDATA("https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&clean=1&fields=name,variant,price,mrp,discountPercent,inStock&token=YOUR_TOKEN")`. Anyone who can open the sheet can read the token in that formula, so share carefully. In Airtable map `uniqueKey` to a unique-key column so repeated imports update rows instead of duplicating them.

**Webhooks and schedules.** Create a Schedule in the Console (daily for a price tracker) and a webhook on "run succeeded" that calls your endpoint with the dataset id.

**MCP and AI agents.** Any MCP-capable assistant can call the Actor through Apify's MCP server; the input is plain JSON and the rows are flat enough to summarise: "which three brands have the deepest markdowns in Chips and Namkeen in Pune?"

**Data warehouses.** Load the JSONL export into BigQuery, Snowflake or Postgres (`jsonb`); `uniqueKey` plus `scrapedAt` is a natural key for a price-history table.

### Performance tips

- **Start small.** The prefill (30 products) shows the shape of the data in seconds; then raise `maxResults`.
- **Name what you need instead of `all`.** `all` reads categories in menu order, so a limit smaller than a store is spent before the last groups are reached (in the proof run the Household Essentials group barely appears).
- **Categories for coverage, keywords for relevance.** A category list ends after about 200 products and a keyword after about 650 ([Honest limits](#honest-limits)); combine sections or keywords to go deeper.
- **Several cities in one run** share the limit equally and form one time-aligned snapshot. Set `maxResults` to cities times products per city.
- **`includeDetails` only when needed.** It roughly doubles the requests: 8 against 86 products per second in the measured runs.
- **One keyword per run for rank work**, because a product reached by two keywords is saved once, under the first.
- **Migrations are safe.** If Apify moves a run to another server the Actor restarts and skips what is already in the dataset ("Run restarted with N rows already in its dataset: continuing without duplicates.").

### Troubleshooting and status messages

Every run ends with one outcome, written to the `SUMMARY` record (field `outcome`). COMPLETED, PARTIAL and EMPTY_RESULT also prefix the status message; MAX_COST and the three failing outcomes show their message text alone.

| Outcome and message | Meaning and what to do |
|---|---|
| `COMPLETED: Saved N products.` | Normal end. |
| `COMPLETED: Saved N products. K categories returned no products (age-restricted such as tobacco, or empty): Cigarettes, Rolling Tobacco, Cigar, ...` | A real proof-run message (first six names shown). Not an error; see [Honest limits](#honest-limits). |
| `COMPLETED: Saved N products - this is everything Blinkit exposes for these settings (the requested M could not be reached).` | Filters, keywords or categories hold fewer than `maxResults`. Relax them or add targets. |
| `... Skipped: <input> (<reason>)` on COMPLETED, PARTIAL or EMPTY_RESULT | A location was left out: unknown city, coordinates outside India, or Blinkit answered "location not serviceable". |
| `MAX_COST`: `Saved N products - this run's maximum cost per run covers N results; raise "Max cost per run" to collect more.` | The cap was reached; rows are saved and charged exactly; run SUCCEEDED. Raise the cap for more. |
| `PARTIAL: ... the run reached its time limit before M were collected.` | Timeout (default one hour). Rows are saved. Split the job or raise the timeout. |
| `PARTIAL: ... the residential traffic safety cap was reached.` | Datacenter addresses stopped working and the fallback route's allowance ran out. Rows are saved; run again later. |
| `PARTIAL: ... X page(s) and Y detail page(s) could not be read ...` | Some pages did not answer. Rows without their product page have `detailsFetched` = `false`; re-read them through `productIds`. |
| `PARTIAL: Saved N products before an error stopped the run: ...` | An unexpected error after some rows were saved. Re-run; the message names the cause. |
| `EMPTY_RESULT: Blinkit answered but nothing matched these settings ...` | Filters too narrow, a keyword without hits, or a category name missing in that city (`SUMMARY.targets[].note` says so). |
| `EMPTY_RESULT: None of the N requested product ids exists in these stores ...` | Wrong ids, or not sold in the chosen cities. |
| `BLOCKED`: `No products collected: no Blinkit page could be fetched (...); the site is refusing these addresses right now.` | Run FAILED. Every address was refused, fallback route included. Retry later. |
| `FETCH_FAILED`: `No products collected and N request(s) failed (...)` or `The run could not collect any product: ...` | Run FAILED. Network trouble; an empty result cannot be confirmed. Retry. |
| `INVALID_INPUT`: `None of the locations could be used (...)` or `Blinkit does not deliver to ... (it answers "location not serviceable")` | Run FAILED. Check city spelling or coordinates; try a city centre such as Mumbai or Bengaluru. |

Log lines worth knowing: `Route DC -> RES-IN (N fresh exit addresses in a row were refused)` means the Actor moved to Indian residential addresses (normal); `Route back to DC (probe answered)` means datacenter addresses work again; `None of the product ids / URLs could be read` means `productIds` held neither numbers nor `blinkit.com/prn/<slug>/prid/<id>` links. The `SUMMARY` record also lists `skippedLocations`, `emptyCategories`, `targets` and request counts.

### Honest limits

#### Prices belong to one dark store, not to India

There is no national Blinkit price: price, stock and ETA belong to the dark store that serves your coordinates (see the three-city table under [What you get](#what-you-get)). Compare cities on `productId`, never on names or category paths, which differ by city.

#### Not every city is served

Of 91 city centres probed on 25 Oct 2026, 89 were served; Vasai-Virar and Nagpur answered "location not serviceable". Coverage changes: a refused location is skipped and named in the status message and in `SUMMARY`.

#### Rows are snapshots, not history

Prices, stock and ETAs change by the minute; a row shows the moment of `scrapedAt`. Mumbai's ETA read 8, 15 and 13 minutes in three runs within a quarter of an hour on 29 Oct 2026, and onion pack 530158 went from 62 to 63 rupees there between 25 and 29 Oct. For history, schedule runs and keep the datasets.

#### Age-restricted categories return nothing

Cigarettes, Cigar and Rolling Tobacco gave zero products in all three proof cities: Blinkit asks the visitor to confirm age and the Actor sends no consent, so they are skipped and named in the status message.

#### Some categories are empty in some cities

The city's store decides. In the proof run seven medicine categories (Fever & Pain Relief, Heart Medicines, Derma Medicines...) returned products in Mumbai and Bengaluru and nothing in New Delhi. The status message lists empty categories.

#### Category lists stop after about 14 pages

Blinkit prints a total per category but serves only about 14 pages, roughly 200 products. "Toys & Games" printed 2,092 items in the 25 Oct crawl, and 52 of Mumbai's 289 categories ran into the ceiling. Go deeper with keywords or several sections.

#### Keyword search stops near 650 products

A keyword returns up to roughly 650 distinct products per city; then Blinkit's list repeats and the Actor stops after three pages without a new product. More specific keywords cover more.

#### Stock units are capped at 50

`inventory` is what a customer can add to the cart and the store shows at most 50, so 50 means "50 or more" (208 of the 12,000 proof rows).

#### Large rating counts are rounded

Blinkit prints counts below 1 lakh in full ("4,615") and larger ones as "11.2 lac", so every `ratingCount` from 100,000 up is a multiple of 10,000 (498 of 498 such proof rows): an approximation.

#### Store ids can change and a city can have several stores

New Delhi's centre was served by store 30790 on 25 Oct 2026 and by 36778 on 29 Oct. One location also returns items from other stores: in the proof run Mumbai rows carried 2 store ids, Delhi 2, Bengaluru 5, among them an `instant` store (35940) that sells digital vouchers. Identify a row by `merchantId` plus `productId` (`uniqueKey`).

#### No review text, cart or personalised offers

You get `rating` and `ratingCount`, not review text. The Actor never logs in, fills a cart or checks out, so it sees no personalised offers, coupons or card discounts; `offerTag` and `discountPercent` show the public markdown against MRP.

#### Product-page details only on request

Description, ingredients, nutrition, shelf life, manufacturer, FSSAI licence, country of origin and attributes come from each product's own page, read only with `includeDetails` or product ids; otherwise those columns are `null`.

#### Cloudflare sits in front, so a proxy is needed

Blinkit refuses most datacenter addresses at random. The Actor finds an accepted one by itself (typically about 5 s to the first row) and falls back to Indian residential addresses if datacenter ones stop working. Leave the proxy setting at its default.

#### Sponsored placements are included and flagged

Paid "Ad" cards appear in lists like any product; `isSponsored` marks them and `position` counts them. In the proof run 1,671 of 1,694 sponsored rows sat at position 1, 5, 9 or 13 of a category's first page. Drop them if you want organic ranks.

#### De-duplication is run-wide

A product reached twice in one run (two keywords, two categories, or two locations served by one store) is saved once, with the context of its first hit. Use one keyword per run for per-keyword ranks.

### Blinkit Scraper compared with the alternatives

| | Blinkit Scraper (this Actor) | By hand from the app or website | Your own script | Generic scraping tools | Retail-data panels |
|---|---|---|---|---|---|
| Products per run | tens of thousands | dozens | what you build | what you set up | aggregated, rarely row-level |
| City and store control | city or coordinates, store id in every row | the address you set | you build it | you build it | usually national or regional |
| Price, MRP, stock and ETA in one table | yes | by copying | you build it | you build it | partly |
| Upkeep when Blinkit changes | handled in updates | none | yours | yours | the provider's |
| Cost model | per result | your time | engineering time | tool fees and your time | subscription |

To our knowledge Blinkit offers no self-serve public API for product and price data. Everything this Actor returns is information Blinkit already shows to any visitor.

### FAQ

#### Does Blinkit have an API?

Not a public one for product and price data, to our knowledge. This Actor is an independent tool that reads the public JSON blinkit.com's own pages use; it is not an official API.

#### How do I scrape Blinkit prices?

Name a city, add a keyword or category (or product ids), press Start, export CSV, Excel or JSON. Recipe 1 in the [Cookbook](#cookbook-ready-to-run-inputs) is a complete 30-product run.

#### Can I scrape Blinkit without logging in?

Yes. The Actor uses no Blinkit account, password or cookies of yours.

#### Blinkit se data kaise nikale?

Actor kholiye, apna shehar (jaise Mumbai) aur keyword ya category daliye, Start dabaiye, phir Export se Excel ya CSV download kar lijiye.

#### How do I export Blinkit products to Excel or CSV?

Open the run's dataset, press Export, choose Excel or CSV and the columns you want. Through the API add `format=xlsx` or `format=csv`.

#### Can I get Blinkit data for Bangalore?

Yes. Type Bangalore or Bengaluru; both resolve to the same city centre, like Mumbai, Delhi, Hyderabad, Pune, Chennai, Kolkata and some 80 more ([Cities](#cities)).

#### Can I use a pincode, an address or a neighbourhood?

There is no pincode or address input. Blinkit picks the store from latitude and longitude, so pass the point as `"lat,lon"` in `locations`; the serving store appears in `merchantId`.

#### How often do Blinkit prices change?

Whenever a store reprices or restocks; stock states and fresh produce can move within a day. Schedule runs at the interval you care about and diff on `uniqueKey`.

#### How do I build a Blinkit price tracker?

Schedule the same input daily with Apify Schedules, keep each dataset and join them on `uniqueKey`; the Python snippet under [Integrations](#integrations) prints the price changes.

#### What is the difference between price and MRP?

MRP is the maximum retail price printed on the pack, `price` is what that store charges; `discountPercent` is (`mrp` - `price`) / `mrp`.

#### Why does a product have discountPercent but no offerTag?

Blinkit rounds the badge down and shows none on small markdowns: in the proof run no row below 5 % had one, 92 % of rows at 5 % or more did. Filter on `discountPercent`.

#### Why are cigarettes missing?

Blinkit asks for an age confirmation before it shows Cigarettes, Cigar and Rolling Tobacco, and the Actor sends none, so those categories return zero products.

#### Why are some medicine categories empty?

The store serving that city had no products in them at the time; see [Honest limits](#honest-limits).

#### How many products can one run return?

As many as `maxResults` allows and the store holds: 12,000 products from 3 cities in the proof run, 30,724 from one full city store (Mumbai held 30,852 distinct products on 25 Oct 2026).

#### Why did I get fewer products than maxResults?

Your filters or targets held fewer, or a list ended (about 200 per category, about 650 per keyword); the message then says it is everything Blinkit exposes for these settings.

#### What is the difference between inStock, availability and isSoldOut?

`availability` is Blinkit's state (`available`, `out_of_stock`, `coming_soon`), `inStock` is true when the product can be ordered now, and `isSoldOut` is Blinkit's own flag, `false` on all 12,000 proof rows.

#### Why does the same product have different prices in two cities?

Each city has its own dark store. Of 2,720 product ids from `express` stores seen in two or more proof cities, 20.3 % had a different selling price in at least one.

#### What is merchantId and why are there several stores in a city?

`merchantId` identifies the store behind the row. Beside the main `express` store a city can have an `instant` store (vouchers in Mumbai) or separate `longtail` stores (Delhi, Bengaluru). Use `uniqueKey`.

#### What are the "Instant Voucher" rows?

Digital e-cards for beauty, wellness and jewellery brands, sold by the `instant` store. Filter them out on `productType` when you want physical goods.

#### What do express, longtail and unicorn mean?

They are Blinkit's delivery-type labels, passed through unchanged. In the proof run 84.5 % of rows were `express`; `unicorn` rows were almost all pharmacy and wellness items, `longtail` rows mostly appliances, beauty, baby and home items.

#### Can I get ingredients, nutrition and FSSAI numbers?

Yes: set `includeDetails` or give `productIds` (recipe 8). Without it those columns are `null`; non-food items have no ingredients.

#### Can I get customer reviews?

No review text; you get `rating` and `ratingCount`.

#### Can I scrape a single product by URL or id?

Yes. `productIds` takes ids and `blinkit.com/prn/.../prid/<id>` URLs and reads each in every location. `ratingCount`, `isSponsored` and `position` are `null` in this mode.

#### Will I get duplicates?

No. Rows are de-duplicated by `uniqueKey` inside a run; the proof run had 0 duplicates in 12,000 rows. Across runs, de-duplicate on the same key.

#### How fast is the Blinkit scraper?

1,000 products in 11 s, and 12,000 products from 3 cities in 140 s (29 Oct 2026).

#### How much does it cost to scrape 10,000 Blinkit products?

$20 on the Free plan, $13 on the top tiers; see [What you pay](#what-you-pay).

#### Do I need my own proxy?

No. The default Apify datacenter proxy is used first and the residential fallback is built in.

#### Can an AI agent use this Actor?

Yes, through Apify's MCP server or the API, with the JSON inputs above.

#### Is it legal to scrape Blinkit?

The Actor reads public product and price data without logging in. Whether your use is lawful depends on your purpose, jurisdiction and Blinkit's terms; see [Legal and compliance](#legal-and-compliance). This is not legal advice.

#### What does inventory 50 mean?

"50 or more": the store caps the number it shows at 50.

#### Can I schedule a daily Blinkit price run?

Yes, with an Apify Schedule; keep the input, keep every dataset and diff them on `uniqueKey`.

#### Can I scrape Blinkit with Python or open the result in Excel?

Both. Call the Actor with the Python apify-client (snippet under Integrations) or press Export on the dataset and choose Excel or CSV.

### Glossary

- **Blinkit (ब्लिंकिट)**: Indian quick-commerce service of Eternal Limited (formerly Zomato Limited), formerly Grofers, hence image URLs on `cdn.grofers.com`.
- **Quick commerce, 10-minute delivery**: groceries and essentials delivered in minutes from nearby stores; `deliveryEtaMinutes` is what Blinkit promised at scrape time.
- **Dark store**: a small warehouse that serves online orders only; `merchantId` identifies it.
- **Kirana (किराना)**: India's neighbourhood general store, the traditional price benchmark.
- **MRP (अधिकतम खुदरा मूल्य)**: maximum retail price printed on the pack, taxes included. **GST**: goods and services tax.
- **FSSAI**: Food Safety and Standards Authority of India; its 14-digit licence number is printed on food products (`fssaiLicense`).
- **Rs, INR, rupee, ₹**: the Indian rupee; every price is in rupees. **Lakh or lac (लाख)**: 100,000. **Crore (करोड़)**: 10,000,000.
- **Pincode**: six-digit postal code; the Actor takes coordinates instead.
- **Atta (आटा)** wheat flour, **dal (दाल)** pulses, **ghee (घी)** clarified butter, **paneer (पनीर)** fresh cheese, **namkeen (नमकीन)** savoury snacks: staples that name Blinkit categories.
- **Express, instant, longtail, super_longtail, unicorn, dummy**: `merchantType` labels, passed through.
- **Group, section, category**: the three levels of the store menu in `categoryPath`. **L0, L1, L2**: Blinkit's catalogue levels (ids `l0CategoryId`, `l1CategoryId`, `l2CategoryId`); `menuCategoryId` is the id of the menu category page.

### 🤖 AI Agents, MCP & RAG Integration

**Blinkit Scraper** works natively as an on-demand data tool for AI assistants and autonomous workflows.

Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:

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

- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.

### Legal and compliance

The Actor collects what Blinkit shows publicly to every visitor, without logging in or using anyone's account: product names, prices, MRP, stock states, brands, categories, ratings, image URLs and the manufacturer, marketer and licence details printed on packs. It collects no customer, rider, reviewer or account data.

You decide what the data is used for and you are responsible for it under the laws that apply to you:

- **India, DPDP Act 2023.** The Act concerns personal data of individuals; product and price data are not. A manufacturer address on a pack can identify a sole proprietor, so treat such text with the care you give personal data.
- **EU and UK, GDPR.** It applies to any personal data you add or combine with these rows.
- **Blinkit's terms and rights.** Blinkit's terms of use may restrict automated access or reuse; whether and how they apply to you is for you and your lawyer. Images and descriptions belong to their owners: the Actor returns image URLs, not files, and you should not republish them as your own.

Nothing here is legal advice; ask a lawyer when in doubt.

### Changelog

- **2026-11-14**: Verified live production health run (2026-11-14): extracted **35** structured records in **4.9s** with valid schema output. Hardened internal proxy stall fallback and pay-per-event dataset instance budget protection.

- **2026-11-11**: Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration. Added direct Issues & Reviews support links and refreshed live maintenance verification.

- **2026-11-01**: Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.

- **1.0 (2026-10-29)**: First release: keyword search, category browse (every L1 category of a city store), city / coordinate locations (about 90 Indian cities) and product-id / URL detail mode. Rows carry price, MRP, discount, stock state, brand, pack size, category path, images, store id, delivery ETA, rating and (optional) full product page details.

- **1.0 (29 Oct 2026)**: first release. Keyword search, category browse of a city's whole store, product ids and URLs, about 90 city centres or coordinates, filters for stock, discount, price and brand, optional product-page details, fair sharing of the limit across targets, a clean stop at the maximum cost per run, restart-safe de-duplication. Proof: 12,000 unique products in one run.

### 💬 Support, Issues & Reviews

- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/blinkit-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/blinkit-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/blinkit-scraper/reviews) or bookmarking [logiover/blinkit-scraper](https://apify.com/logiover/blinkit-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.

# Changelog

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

# Actor input Schema

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

Where to shop. Blinkit prices, stock and delivery time belong to the dark store that serves a location, so every city has its own catalogue. Use a city name (Mumbai, Delhi, Bengaluru, Hyderabad, Pune, Chennai, Kolkata, Ahmedabad, Jaipur, Lucknow... about 90 cities work, common spellings such as Bangalore or Gurgaon too) or a 'latitude,longitude' pair such as 19.0760,72.8777. Several locations are collected one after another and share the result limit.

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

Products to look for, exactly as you would type them in the Blinkit search box: milk, amul butter, maggi, iphone charger, atta. Each keyword returns up to about 650 distinct products per city before Blinkit's own result list repeats. Leave empty to skip keyword search.

## `categories` (type: `array`):

Walk Blinkit's category pages. Type all to read every category of the city's store (about 290), or pick some by name (a top group such as Snacks & Drinks, a section such as Dairy, Bread & Eggs, or a category such as Chips & Wafers) or by number / category URL (https://blinkit.com/cn/.../cid/<l0>/<l1>). Every category is read page by page, breadth first, so a small result limit still samples many categories. If you give no keyword, category or product id, the Actor browses all categories.

## `productIds` (type: `array`):

Read single products with their full product page data (description, ingredients, nutrition, shelf life, manufacturer, FSSAI licence, country of origin). Paste Blinkit product URLs (https://blinkit.com/prn/amul-cow-milk/prid/160704) or plain product ids such as 160704. The price you get is the price in each selected location.

## `includeDetails` (type: `boolean`):

Open the product page of every result too: description, key features, ingredients, nutrition, shelf life, manufacturer, FSSAI licence, country of origin, veg / non-veg mark, all attributes and the category names (L0 / L1 / L2). About twice the requests, so slower. Product-id mode always reads the product page.

## `onlyInStock` (type: `boolean`):

Skip products that are out of stock or marked coming soon in that store (they have inventory 0).

## `minDiscountPercent` (type: `number`):

Keep only products whose selling price is at least this many percent below the MRP, for example 20.

## `minPrice` (type: `number`):

Keep only products whose selling price is at least this many rupees.

## `maxPrice` (type: `number`):

Keep only products whose selling price is at most this many rupees.

## `brands` (type: `array`):

Keep only products whose brand or name contains one of these words, for example Amul, Nestle, Haldiram's. Not case sensitive.

## `maxResults` (type: `integer`):

Stop after this many products, across all locations, keywords, categories and ids. You are charged per product saved. Several targets share the limit equally; a target that runs dry hands its unused share to the others.

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

How many browser-like sessions run side by side. 16 reads a whole city store in a few minutes. Lower it for a gentler run.

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

Apify datacenter proxy is the default and is used first. Blinkit sits behind Cloudflare and refuses most datacenter addresses at random, so the Actor tries fresh addresses until one is accepted and keeps it. If datacenter addresses stop working it moves to a small amount of Indian residential traffic by itself.

## Actor input object example

```json
{
  "locations": [
    "Mumbai"
  ],
  "categories": [
    "Dairy, Bread & Eggs"
  ],
  "includeDetails": false,
  "onlyInStock": false,
  "maxResults": 30,
  "maxConcurrency": 16,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All products collected in 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 = {
    "locations": [
        "Mumbai"
    ],
    "categories": [
        "Dairy, Bread & Eggs"
    ],
    "maxResults": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "locations": ["Mumbai"],
    "categories": ["Dairy, Bread & Eggs"],
    "maxResults": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "locations": [
    "Mumbai"
  ],
  "categories": [
    "Dairy, Bread & Eggs"
  ],
  "maxResults": 30
}' |
apify call logiover/blinkit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/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/XbcWgwApCoQHvSRat/builds/1fD9beKb1NtANLVKn/openapi.json
