# Blinkit Scraper (`scrapedo/blinkit-scraper`) Actor

Scrape Blinkit categories with real pagination: price, MRP, discount, units in stock and rating for any delivery location, plus FSSAI licence and shelf life. Free trial, no per-result fee. Powered by Scrape.do.

- **URL**: https://apify.com/scrapedo/blinkit-scraper.md
- **Developed by:** [scrapedo](https://apify.com/scrapedo) (community)
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Scrape product data from [Blinkit](https://blinkit.com), India's 10-minute grocery app: **price, MRP, discount, units in stock, rating and pack size** for every product in a category, **for the dark store that serves your delivery location**, with real pagination. Optionally add the **FSSAI licence, shelf life, country of origin, ingredients and manufacturer** from each product page.

**Free to try:** run it without any setup and get up to 50 products per run. Add your free Scrape.do API token to remove the limit.

### Why most Blinkit scrapers fail

1. **Cloudflare.** Blinkit answers scripts with HTTP 403 and an error page. This actor fetches every page through the [Scrape.do](https://scrape.do/?utm_source=apify\&utm_medium=actor\&utm_campaign=blinkit-scraper) web scraping API with residential proxies in India.
2. **One store per location.** Prices, assortment and stock belong to one dark store, picked from the delivery address. Without a location you get Gurugram. In our test the chips category had 673 products in Gurugram and 524 in Mumbai, and the same pack had 5 units in one store and 1 in the other. Pick a city or enter exact coordinates.
3. **Pagination is a POST API.** A category page holds 30 products. The rest come from Blinkit's listing API, 15 per call, each call returning the address of the next. The actor follows that chain for you and keeps out-of-stock products.

### What data you get

| Field | Description |
|---|---|
| `productId`, `name`, `brand`, `packSize` | Blinkit product id, name, brand and pack size ("60 g") |
| `priceInr`, `mrpInr`, `discountPct` | Selling price and printed MRP in rupees, and the discount |
| `inStock`, `inventory` | Whether the store can sell it now, and how many units it holds (Blinkit stops counting at 50) |
| `rating`, `ratingCount` | Average rating and number of ratings ("7 lac" becomes 700000) |
| `variants`, `storeId` | Other pack sizes on the card, and the dark store (merchant) id |
| `image`, `url` | Product image and product page |
| `fssaiLicense`, `shelfLife`, `countryOfOrigin` | With **Add product details** on, or for product URLs |
| `ingredients`, `manufacturer`, `returnPolicy`, `categoryIds`, `images`, `attributes` | The rest of the product sheet |
| `latitude`, `longitude`, `sourceUrl`, `scrapedAt` | The delivery location used, where and when the row was scraped |

### How to use it

1. **Categories:** paste category URLs (`blinkit.com/cn/chips-crisps/cid/1237/940`). Find them by opening a category on blinkit.com. Set **Pages per category**: page 1 is 30 products, each further page 15.
2. **Location:** choose a **City**, or enter **Latitude** and **Longitude** for an exact address.
3. **Product details:** turn on **Add product details** to open each product page as well (one extra request per product), or paste product URLs (`blinkit.com/prn/<name>/prid/<id>`) directly.

#### Input example

```json
{
    "startUrls": ["https://blinkit.com/cn/chips-crisps/cid/1237/940"],
    "maxPagesPerCategory": 5,
    "city": "mumbai",
    "includeProductDetails": false,
    "maxItems": 500,
    "scrapeDoToken": "YOUR_SCRAPEDO_TOKEN"
}
```

#### Output example

One item per product. Example (fictional product, illustrative values, details on):

```json
{
    "productId": 1001,
    "name": "Example Salted Chips",
    "brand": "Northwind Snacks",
    "packSize": "60 g",
    "priceInr": 43,
    "mrpInr": 70,
    "discountPct": 38,
    "inStock": true,
    "inventory": 5,
    "rating": 4.31,
    "ratingCount": 120000,
    "variants": 2,
    "storeId": 90001,
    "fssaiLicense": "10000000000001",
    "shelfLife": "180 days",
    "countryOfOrigin": "India",
    "url": "https://blinkit.com/prn/example-salted-chips/prid/1001",
    "latitude": 19.076,
    "longitude": 72.8777,
    "sourceUrl": "https://blinkit.com/cn/chips-crisps/cid/1237/940",
    "scrapedAt": "2026-11-04T05:00:00.000Z"
}
```

Download the results as JSON, CSV, Excel or HTML from the run's **Output** tab, or pull them through the Apify API.

### Pricing and your Scrape.do token

There is no per-result fee for this actor; Apify only bills its normal platform usage. Pages are fetched through the Scrape.do web scraping API:

1. **Free trial, no token:** leave the **Scrape.do API token** field empty and you get up to 50 products per run.
2. **Your own Scrape.do token:** no product limit. Each request is 10 Scrape.do credits (residential proxies in India): one per category page 1, one per further page of 15, one per product page. Five pages of a category (90 products) cost 50 credits. [Create a free Scrape.do account](https://scrape.do/?utm_source=apify\&utm_medium=actor\&utm_campaign=blinkit-scraper) for 1,000 free credits a month.

### Good to know

- **Location matters.** Every row records the latitude and longitude it was scraped for. Run the same category for two cities to compare stores.
- **Stock cap.** Blinkit reports at most 50 units per product.
- **Search pages** (`/s/`) are disallowed in Blinkit's robots.txt and not supported; use category pages.
- **Prefer Python?** The same logic is an open-source package: `pip install blinkit-scraper` ([GitHub](https://github.com/bugrahansss/blinkit-scraper)).

### FAQ

**Is scraping Blinkit legal?** The actor reads category and product pages, which Blinkit's robots.txt allows, plus the listing API those pages call, and never touches search, cart, checkout or account paths. Product names, prices and stock are not personal data. Read Blinkit's terms of use for your use case and keep request rates modest. This is not legal advice.

**Something broke or a field is missing?** Open an issue in the Issues tab and we will look at it.

# Actor input Schema

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

Category URLs (blinkit.com/cn/chips-crisps/cid/1237/940) and/or product URLs (blinkit.com/prn/<name>/prid/<id>).

## `maxPagesPerCategory` (type: `integer`):

Page 1 holds 30 products; every further page is one request to Blinkit's listing API and holds 15. Out-of-stock products come last.

## `includeProductDetails` (type: `boolean`):

Also open each product page and add FSSAI licence, shelf life, country of origin, ingredients, manufacturer, return policy, images and the full attribute list. One extra request per product.

## `city` (type: `string`):

Used when latitude and longitude are empty. Gurugram is Blinkit's own default.

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

Optional. Exact delivery latitude, e.g. 12.9352. Overrides the city.

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

Optional. Exact delivery longitude, e.g. 77.6245. Overrides the city.

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

Stop after this many products in total. Set 0 for no limit. Without your own Scrape.do token the free trial returns up to 50 products per run.

## `scrapeDoToken` (type: `string`):

Optional. Find it in your Scrape.do dashboard. Leave empty for the free trial (up to 50 products per run).

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

How many product pages are fetched at the same time when you use your own token. Keep it at or below your Scrape.do plan's concurrency.

## Actor input object example

```json
{
  "startUrls": [
    "https://blinkit.com/cn/chips-crisps/cid/1237/940"
  ],
  "maxPagesPerCategory": 1,
  "includeProductDetails": false,
  "city": "gurugram",
  "maxItems": 10,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `allFields` (type: `string`):

No description

# 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 = {
    "startUrls": [
        "https://blinkit.com/cn/chips-crisps/cid/1237/940"
    ],
    "maxPagesPerCategory": 1,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapedo/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 = {
    "startUrls": ["https://blinkit.com/cn/chips-crisps/cid/1237/940"],
    "maxPagesPerCategory": 1,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapedo/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 '{
  "startUrls": [
    "https://blinkit.com/cn/chips-crisps/cid/1237/940"
  ],
  "maxPagesPerCategory": 1,
  "maxItems": 10
}' |
apify call scrapedo/blinkit-scraper --silent --output-dataset

```

## MCP server setup

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