# Blinkit Products Scraper (`automation-lab/blinkit-category-products-scraper`) Actor

Extract location-specific Blinkit category and search products with variants, prices, MRP, stock, ratings when available, images, listing rank, and store identifiers.

- **URL**: https://apify.com/automation-lab/blinkit-category-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Blinkit Products Scraper

Export location-specific **Blinkit products** from category pages and product searches.

The Actor returns one typed row per product and delivery location, including variants, price, MRP, calculated discount, stock, exposed inventory, images, listing rank, category or search context, and Blinkit store identifiers.

Use it for recurring assortment monitoring, local price comparisons, stock checks, category research, and data-pipeline exports across serviceable Indian delivery locations.

### What does Blinkit Products Scraper do?

Blinkit shows different products, stores, prices, and availability depending on the delivery coordinates.

This Actor lets you provide:

- public Blinkit category URLs;
- product search queries;
- one or more latitude/longitude pairs; and
- a maximum output size.

It then resolves each location's Blinkit service region and store, extracts category or search listings, follows pagination, deduplicates product IDs per location, and saves normalized records to the default Apify dataset.

No Blinkit login, phone number, or OTP is required.

### Who is it for?

#### Retail and pricing analysts

Track current selling prices, MRP, discounts, pack sizes, and stock signals for a defined product set.

#### Brands and category managers

Measure whether products appear in a category or search result at different delivery locations and where they rank.

#### Marketplaces and data teams

Feed normalized Blinkit catalog records into a warehouse, spreadsheet, dashboard, or change-detection workflow.

#### Researchers

Create reproducible location-stamped snapshots instead of relying on a manually selected browser location.

#### Automation builders

Schedule runs in Apify and connect their datasets to webhooks, Make, Zapier, Google Sheets, or your own API consumer.

### Why use this Actor?

- **Category and search inputs:** collect a specific category, a keyword result, or both.
- **Location-specific output:** every row includes the coordinates, label, resolved city/region, and merchant ID.
- **Variants included:** grouped pack-size choices found in listing cards are emitted as individual product records.
- **Pagination:** the Actor follows Blinkit's returned listing cursors until it reaches the requested limit or the source ends.
- **Typed dataset:** stable fields are ready for JSON, CSV, Excel, and API integrations.
- **Efficient HTTP runtime:** catalog extraction does not launch a browser.
- **Automatic cloud recovery:** if Blinkit blocks direct cloud traffic, the Actor retries through one sticky Apify residential session in India.
- **Bounded failure behavior:** invalid URLs, unserviceable coordinates, and unexpected upstream responses fail clearly instead of silently returning an empty success.

### What Blinkit product data is extracted?

| Field | Meaning |
| --- | --- |
| `productId` | Blinkit product identifier |
| `name` | Product display name |
| `brand` | Brand when supplied in the listing |
| `variant` | Pack size or variant, such as `1 kg` |
| `price` | Current selling price in INR |
| `mrp` | Maximum retail price in INR |
| `discountPercent` | Discount calculated from price and MRP |
| `inStock` | Availability at the selected location |
| `inventory` | Inventory quantity exposed by Blinkit, when available |
| `rating` | Product rating when present in the listing response |
| `ratingCount` | Rating count when present |
| `imageUrl` / `imageUrls` | Primary and additional product images |
| `rank` | One-based listing position for that source and location |
| `merchantId` | Store identifier serving the product |
| `merchantType` | Blinkit assortment or merchant type |
| `eta` | Delivery timing label exposed in the card |
| `categoryId` / `subcategoryId` | IDs parsed from category URLs |
| `categoryName` | Category heading supplied by Blinkit |
| `sourceType` | `category` or `search` |
| `sourceUrl` | Category or search URL represented by the row |
| `searchQuery` | Search term for search records; otherwise `null` |
| `location` | Coordinates, label, and resolved city/region |
| `scrapedAt` | ISO 8601 extraction timestamp |

Fields not exposed for a particular product are returned as `null` rather than guessed.

### How to scrape Blinkit products

1. Open the Actor in Apify Console.
2. Add at least one Blinkit category URL or search query.
3. Keep the default Noida coordinates or provide your own serviceable Indian delivery locations.
4. Set `maxItems` to the largest total dataset size you need.
5. Click **Start**.
6. Open the **Dataset** tab to inspect, export, or connect the records.

A valid category URL ends with `/cid/<category>/<subcategory>`.

For example:

```text
https://blinkit.com/cn/fresh-vegetables/cid/1487/1489
```

### Input parameters

#### `startUrls`

Optional array of public Blinkit category URLs.

Each URL must use `blinkit.com` and end in two numeric category IDs.

#### `searchQueries`

Optional array of product terms such as `milk`, `coffee`, or `detergent`.

At least one `startUrls` entry or one non-empty `searchQueries` entry is required.

#### `locations`

Array of delivery locations.

Each item accepts:

- `latitude` — number from -90 to 90;
- `longitude` — number from -180 to 180; and
- `label` — optional name included in output.

The default location is a serviceable point in Noida.

A location that Blinkit reports as unserviceable causes a clear failed run.

#### `maxItems`

Maximum unique location-product records saved across all sources.

Allowed range: 1 to 10,000.

When multiple locations or sources are supplied, the Actor allocates the limit across them so an early large category does not silently prevent later inputs from running.

### Example: search products in Noida

```json
{
  "searchQueries": ["milk"],
  "locations": [
    {
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    }
  ],
  "maxItems": 25
}
```

This is useful for a one-time search export or a scheduled keyword availability check.

### Example: scrape a Blinkit category

```json
{
  "startUrls": [
    {
      "url": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489"
    }
  ],
  "locations": [
    {
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    }
  ],
  "maxItems": 30
}
```

Use this pattern for category assortment, variant, price, and stock snapshots.

### Example: compare two Blinkit locations

```json
{
  "searchQueries": ["milk"],
  "locations": [
    {
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    },
    {
      "latitude": 12.9716,
      "longitude": 77.5946,
      "label": "Bengaluru"
    }
  ],
  "maxItems": 100
}
```

Schedule this input and compare snapshots by `productId`, `location.label`, `price`, `inStock`, and `scrapedAt`.

### Output example

The following shape is based on a real current category run; values change with location and time.

```json
{
  "productId": "530158",
  "name": "Onion (Pyaz)",
  "brand": "Freshbury",
  "variant": "1 kg",
  "price": 41,
  "mrp": 50,
  "discountPercent": 18,
  "currency": "INR",
  "inStock": true,
  "inventory": 50,
  "rating": null,
  "ratingCount": null,
  "imageUrl": "https://cdn.grofers.com/da/cms-assets/cms/product/example.png",
  "imageUrls": [
    "https://cdn.grofers.com/da/cms-assets/cms/product/example.png"
  ],
  "productUrl": "https://blinkit.com/prn/product/prid/530158",
  "rank": 1,
  "merchantId": "35702",
  "merchantType": "express",
  "eta": "earliest",
  "categoryId": "1487",
  "subcategoryId": "1489",
  "categoryName": "Buy Vegetables Online",
  "sourceType": "category",
  "sourceUrl": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489",
  "searchQuery": null,
  "location": {
    "latitude": 28.5653836,
    "longitude": 77.3826511,
    "label": "Noida",
    "city": "UP-NCR"
  },
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

### How much does it cost to scrape Blinkit products?

The Actor uses pay-per-event pricing:

- a **$0.005 start event** once per run; and
- one **product event** for each saved dataset row.

The current product-event tiers are:

| Tier | Price per saved product |
| --- | ---: |
| Free | $0.00184 |
| Bronze | $0.00160 |
| Silver | $0.001248 |
| Gold | $0.00096 |
| Platinum | $0.00064 |
| Diamond | $0.000448 |

At the Bronze tier, illustrative totals are about:

- 25 products: **$0.045** including the start event;
- 100 products: **$0.165** including the start event;
- 1,000 products: **$1.605** including the start event.

Apify Console shows the applicable tier and maximum charge before a run.

Failed validation before product rows are saved does not create product events; the one-time start event may still apply.

### Build a recurring assortment monitor

Use an Apify Schedule to run the same input daily or weekly.

Store or export the resulting dataset ID after every run.

Join snapshots using:

```text
location.label + merchantId + productId
```

Then detect:

- products added or removed from a category;
- price or MRP changes;
- stock changes;
- variant changes;
- listing-rank movement; and
- store changes at the same coordinates.

The Actor emits snapshots, not a built-in historical diff table.

### Export and integrate the data

The default dataset supports:

- JSON;
- CSV;
- Excel;
- XML;
- RSS; and
- direct API access.

Useful workflows include:

1. send each scheduled dataset to a data warehouse;
2. append selected fields to Google Sheets;
3. trigger a webhook when a run finishes;
4. compare the latest two snapshots in Make or your own script; and
5. build a dashboard grouped by location, category, brand, or merchant ID.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~blinkit-category-products-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["milk"],
    "locations": [{
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    }],
    "maxItems": 25
  }'
```

#### JavaScript

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

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

const run = await client.actor(
  'automation-lab/blinkit-category-products-scraper'
).call({
  searchQueries: ['milk'],
  locations: [{
    latitude: 28.5653836,
    longitude: 77.3826511,
    label: 'Noida',
  }],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor(
    "automation-lab/blinkit-category-products-scraper"
).call(run_input={
    "searchQueries": ["milk"],
    "locations": [{
        "latitude": 28.5653836,
        "longitude": 77.3826511,
        "label": "Noida",
    }],
    "maxItems": 25,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Blinkit Products Scraper with MCP

Add the Actor as an Apify MCP tool in Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/blinkit-category-products-scraper"
```

#### Claude Desktop setup

Add this server to the `mcpServers` object in your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/blinkit-category-products-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `apify` server URL in **Cursor Settings → MCP** or in your project's MCP JSON configuration.

#### VS Code setup

Add the same HTTP server URL through your VS Code MCP extension or workspace MCP configuration, then enable the Apify Actor tool.

Example prompts:

- "Search Blinkit for milk near these Noida coordinates and return 25 products."
- "Extract the fresh vegetables category for Bengaluru and summarize out-of-stock items."
- "Run the same Blinkit search for Noida and Bengaluru, then compare prices by product ID."

### Reliability, limits, and data freshness

Blinkit is an upstream service and can change its public page or response format.

The Actor validates recognizable category state and search responses and fails if the shape is no longer safe to interpret.

Other limits:

- cloud runs can use paid residential proxy traffic when Blinkit blocks direct egress; this fallback is automatic and uses India geography;
- results reflect the source at run time, not guaranteed future availability;
- some cards do not expose ratings, rating counts, inventory, or ETA;
- coordinates outside Blinkit's service area fail serviceability validation;
- `maxItems` is a maximum, not a promise that the source contains that many unique products;
- categories and searches can contain overlapping product IDs, which are deduplicated per location; and
- rank is scoped to one category/search input and location, not a universal Blinkit rank.

### Responsible use and legality

This Actor extracts publicly reachable catalog listings without logging into a customer account.

You are responsible for:

- complying with Blinkit's terms and applicable laws;
- using reasonable schedules and dataset sizes;
- avoiding attempts to identify individuals or collect private account information;
- respecting trademarks and database rights; and
- confirming that your storage, analysis, and redistribution purpose is lawful.

Product availability and prices are informational snapshots and should be verified before commercial or purchasing decisions.

### Troubleshooting

#### The run says the location is not serviceable

Check that latitude and longitude are in the correct order and point to a Blinkit delivery area in India.

Try the coordinates in Blinkit's own location picker before rerunning.

#### A category URL is rejected

Use a public `blinkit.com` category URL ending in:

```text
/cid/<numeric-category-id>/<numeric-subcategory-id>
```

Search pages and product pages should be supplied through `searchQueries`, not `startUrls`.

#### The dataset contains fewer rows than `maxItems`

The source may contain fewer unique items, multiple inputs may overlap, or the limit may be divided across several locations and sources to preserve coverage.

Check logs for the number saved and inspect `sourceType`, `sourceUrl`, and `location` in the dataset.

#### Ratings are null

Blinkit does not expose ratings on every product listing card.

The Actor returns `null` rather than fabricating a value.

#### A run fails after Blinkit changes

Keep the failed run ID and logs and report them through the Actor issue form.

Do not repeatedly launch identical runs after a deterministic response-shape error.

### FAQ

#### Does the Actor need a Blinkit login?

No.

Catalog category and search extraction works without a customer account, phone number, or OTP.

#### Does it support multiple cities?

Yes.

Provide multiple serviceable coordinate objects in `locations`.

Every result records the exact coordinates, label, resolved region, and merchant ID.

#### Can I scrape by category and keyword in one run?

Yes.

Provide both `startUrls` and `searchQueries`.

The total limit is allocated across inputs and locations so each receives coverage where data exists.

#### Does it download product images?

No.

It returns image URLs supplied by Blinkit, which avoids unnecessary bandwidth and storage charges.

#### Can I schedule monitoring?

Yes.

Use Apify Schedules and compare datasets from consecutive runs.

#### Is the output a complete national Blinkit catalog?

No.

Blinkit assortment is location-dependent, and the Actor only returns listings for the coordinates and sources you request.

### Related Automation Lab Actors

For broader web retail discovery beyond Blinkit, use [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper).

Use this Actor when you specifically need Blinkit's local category/search assortment, stock, rank, and merchant context.

# Actor input Schema

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

One or more public Blinkit category URLs ending in /cid/<category>/<subcategory>. You can combine these with search queries.

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

Product searches to run at every configured delivery location, for example milk, coffee, or detergent.

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

Coordinates that determine Blinkit store, assortment, stock, and prices. The default is a serviceable location in Noida.

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

Maximum unique location-product records saved across all category URLs and searches.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489"
    }
  ],
  "searchQueries": [],
  "locations": [
    {
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

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

Product records with prices, availability, variants, images, rank, store identifiers, and delivery location.

# 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": [
        {
            "url": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489"
        }
    ],
    "searchQueries": [],
    "locations": [
        {
            "latitude": 28.5653836,
            "longitude": 77.3826511,
            "label": "Noida"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/blinkit-category-products-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": [{ "url": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489" }],
    "searchQueries": [],
    "locations": [{
            "latitude": 28.5653836,
            "longitude": 77.3826511,
            "label": "Noida",
        }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/blinkit-category-products-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": [
    {
      "url": "https://blinkit.com/cn/fresh-vegetables/cid/1487/1489"
    }
  ],
  "searchQueries": [],
  "locations": [
    {
      "latitude": 28.5653836,
      "longitude": 77.3826511,
      "label": "Noida"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/blinkit-category-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/blinkit-category-products-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/qaEbdznw0X6pgjOcf/builds/oU0BM31305umlhQ7t/openapi.json