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:

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

{
  "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

{
  "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

{
  "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.

{
  "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:

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

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

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

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:

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:

{
  "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:

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

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