# Blinkit Product Listings & Delivery ETA Scraper (`krazee_kaushik/blinkit-product-results-scraper`) Actor

🛒 Collect Blinkit product data across multiple locations and keywords with real-time delivery ETA.
📊 Includes prices, stock status, ratings, merchant info, and images.
⚡ Ready for analytics, dashboards, and automation. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/krazee\_kaushik/blinkit-product-results-scraper.md
- **Developed by:** [Krazee](https://apify.com/krazee_kaushik) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 94 total users, 6 monthly users, 82.7% runs succeeded, 1 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Product Data Scraper – Search Results, Prices, Availability & Delivery ETA
Collect live Blinkit product listings exactly as customers see them, including **real-time delivery ETA**, **pricing**, **availability**, ratings, and images.

Run searches across **multiple locations and keywords** to capture Blinkit product data as it appears to users in different cities and neighborhoods.

The scraper automatically collects and structures Blinkit search results, making it easy to access Blinkit product data for **pricing intelligence, quick-commerce research, dashboards, and automation workflows**.

### 📚 Table of Contents

  - [🤔 What Does This Blinkit Scraper Do?](#-what-does-this-blinkit-scraper-do)
  - [🎯 Who Uses Blinkit Product Data?](#-who-uses-blinkit-product-data)
  - [⬇️ What You Need to Provide](#️-what-you-need-to-provide)
  - [🧪 Example Input](#-example-input)
  - [📦 What You’ll Get (Output)](#-what-youll-get-output)
  - [📤 Blinkit Product Data You Will Get](#-blinkit-product-data-you-will-get)
  - [🔒 Reliability & Stability](#-reliability--stability)
  - [🔗 Need product data from Zepto as well?](#-need-product-data-from-zepto-as-well)

---

### 🤔 What Does This Blinkit Scraper Do?

Think of this as a smart Blinkit shopper that can **search across multiple locations and keywords automatically**.

For each location you provide, the scraper:

- 📍 Sets the delivery coordinates and optionally fetches **live ETA data** from nearby Blinkit stores

- 🔍 Runs your **search keywords** exactly like a real user would on Blinkit

- 🛒 Collects product listings **exactly as shown in the Blinkit app**

- 📦 Converts the results into **clean, structured data ready for analysis**

This allows you to collect product data across **different cities, neighborhoods, and search queries in a single run**.

---

### 🎯 Who Uses Blinkit Product Data?

This scraper is designed for anyone who needs **structured Blinkit product data across locations and search queries**.

It is especially useful for:

- 📊 **Market & Pricing Researchers**  
  Compare product pricing, availability, and delivery speeds across cities and neighborhoods.

- 🛒 **Quick-commerce & Retail Teams**  
  Monitor how products appear on Blinkit search results across different locations.

- 📈 **Data Analysts & BI Teams**  
  Build dashboards tracking pricing trends, stock availability, and delivery performance.

- 🤖 **Automation & Data Pipelines**  
  Feed structured Blinkit datasets into internal tools, analytics platforms, or machine learning workflows.

- 🧠 **Anyone Tracking Blinkit Product Visibility**  
  Understand how products appear in search results and how availability varies by location.

---

### ⬇️ What You Need to Provide

- **🔎 Search Queries**
Keywords you would normally type into Blinkit (e.g. milk, snacks, personal care)

- **🔢 Products Limit (per query)**
How many products to collect for each search term

- **📍 Locations**  
Provide **one or more delivery locations** where Blinkit should simulate a customer.  
For each location, the scraper fetches **live ETA, product availability, and search results** exactly as they would appear to users in that area.

- **🚚 Include Delivery ETA (optional)**
Set `includeETA: true` to fetch real-time delivery ETA.
⚠️ This requires additional API calls per location and may increase runtime and cost.

---

### 🧪 Example Input

Here is a sample JSON input you can provide when running the scraper:

```json
{
    "includeEtaDetails": false,
    "locations": [
        "Vasant kunj, delhi",
        "uttam nagar, delhi"
    ],
    "searchQueries": [
        "chocolate"
    ]
}

````

***

### 📦 Blinkit Product Data You Will Get

Each product record contains structured data collected from Blinkit search results.

- **🏷 Product Details** – product ID, name, variant, and brand

- **💰 Pricing Information** – MRP, selling price, and active offer text

- **🚚 Delivery Intelligence** – delivery ETA (in minutes) based on the selected location

- **📍 Location Context** – location name along with latitude and longitude used for the search

- **🏬 Store Information** – merchant ID and merchant type serving the product

- **📦 Inventory Status** – current stock count and out-of-stock indicator

- **⭐ Customer Ratings** – product rating value when available

- **🖼 Product Images** – all available product image URLs

- **⏱ Data Timestamp** – ISO timestamp indicating when the data was collected

***

### 📤 Example Output (JSON)

```json
  {
    "product_id": "709802",
    "name": "Right Shift Jaggery Atta Cookies (No Maida/ No Palm Oil)",
    "variant": "120 g",
    "brand": "Right Shift",
    "mrp": 90,
    "price": 81,
    "offer_text": "10% OFF",
    "out_of_stock": false,
    "inventory": 1,
    "merchant_id": "37070",
    "merchant_type": "express",
    "rating_value": 4.66,
    "images": [
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-497.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-475.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-473.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-471.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-495.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-493.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-491.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-489.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-487.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-485.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-483.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-481.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-479.png",
      "https://cdn.grofers.com/da/cms-assets/cms/product/rc-upload-1772432009525-477.png"
    ],
    "eta_in_minutes": 10,
    "timestamp": "2026-03-06T10:14:12.368Z",
    "location": "Mumbai Central",
    "longitude": 72.8205292,
    "latitude": 18.9690247
  },


```

***

### 🔒 Reliability & Stability

- 🔁 Automatic retries for temporary failures

- 🔄 Rotating sessions to avoid blocks

- ⚡ Optimized for high-speed, multi-query runs

> 💡 What this means for you:
> Occasional warnings are normal — the scraper keeps working until data is collected or retries are exhausted.

***

### ❓ FAQ

#### Can I scrape Blinkit product data for multiple locations?

Yes.

You can provide multiple locations in the input. The scraper will run the search queries for each location and collect product listings as they appear to users in that area.

Because Blinkit inventory and delivery times depend on nearby warehouses, results may vary between locations.

#### Can I scrape multiple search queries in the same run?

Yes.

You can provide multiple search queries in the input configuration. The scraper will execute each query and collect product listings up to the specified limit for every location.

#### Will delivery ETA be included in the dataset?

Yes.

Each product record includes the **latest delivery ETA** for the selected location at the time of the search. This allows you to analyze delivery performance alongside pricing and availability.

#### How many locations can I run in a single run?

There is no fixed limit.

You can include as many locations as needed in the input. For very large inputs, it is recommended to monitor the run and ensure your configuration allows enough time for completion.

#### Is scraping Blinkit data legal?

This tool collects publicly accessible product listings from Blinkit search results. It does not bypass authentication or access private user data.

However, users are responsible for ensuring their usage complies with Blinkit's terms of service and applicable laws in their jurisdiction.

#### Can the collected data be used in dashboards or analytics pipelines?

Yes.

The output is a structured dataset containing product details, pricing, availability, delivery ETA, and images. The dataset can be downloaded or accessed programmatically through the Apify API and integrated into analytics tools, dashboards, or automation workflows.

***

### 🔗 Related Scrapers

- ⚡ [Zepto Product Listings & Delivery Eta Scraper](https://apify.com/krazee_kaushik/zepto-scraper) – Hyperlocal delivery intelligence
- 🛒 [B\&H Product Scraper](https://apify.com/krazee_kaushik/b-h-product-scraper) – Global product data and pricing
- 🛍️ [Meesho Products & Reviews Scraper](https://apify.com/krazee_kaushik/meesho-search-results-scraper) – Marketplace product listings and customer reviews

# Actor input Schema

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

List of product keywords to scrape.

## `productsLimit` (type: `integer`):

Products count for each query

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

Blinkit delivery locations list

## `includeEtaDetails` (type: `boolean`):

Whether to include Estimated time of arrival.

## Actor input object example

```json
{
  "searchQueries": [
    "Chocolate"
  ],
  "productsLimit": 45,
  "locations": [
    "Vasant Kunj, New Delhi",
    "Mayur Vihar Phase 1"
  ],
  "includeEtaDetails": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "Chocolate"
    ],
    "locations": [
        "Vasant Kunj, New Delhi",
        "Mayur Vihar Phase 1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("krazee_kaushik/blinkit-product-results-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["Chocolate"],
    "locations": [
        "Vasant Kunj, New Delhi",
        "Mayur Vihar Phase 1",
    ],
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "Chocolate"
  ],
  "locations": [
    "Vasant Kunj, New Delhi",
    "Mayur Vihar Phase 1"
  ]
}' |
apify call krazee_kaushik/blinkit-product-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=krazee_kaushik/blinkit-product-results-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Blinkit Product Listings & Delivery ETA Scraper",
        "description": "🛒 Collect Blinkit product data across multiple locations and keywords with real-time delivery ETA.\n📊 Includes prices, stock status, ratings, merchant info, and images.\n⚡ Ready for analytics, dashboards, and automation. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "Nohyhno7W22qjPVLX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/krazee_kaushik~blinkit-product-results-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-krazee_kaushik-blinkit-product-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/krazee_kaushik~blinkit-product-results-scraper/runs": {
            "post": {
                "operationId": "runs-sync-krazee_kaushik-blinkit-product-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/krazee_kaushik~blinkit-product-results-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-krazee_kaushik-blinkit-product-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of product keywords to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productsLimit": {
                        "title": "Products limit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Products count for each query",
                        "default": 45
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Blinkit delivery locations list",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeEtaDetails": {
                        "title": "Include ETA?",
                        "type": "boolean",
                        "description": "Whether to include Estimated time of arrival.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
