# Flipkart Product Scraper (`insights_data/flipkart-product-scraper`) Actor

Scrape Flipkart products by keyword or category URL — prices, discounts, ratings, specs, sellers, and offers. A Flipkart API alternative for price monitoring, catalog research, and competitive analysis. Export structured product data as JSON/CSV.

- **URL**: https://apify.com/insights\_data/flipkart-product-scraper.md
- **Developed by:** [Insights Data](https://apify.com/insights_data) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### What does Flipkart Product Scraper do?

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Flipkart Internet Private Limited or any of its subsidiaries. "Flipkart" is referenced only to describe the publicly available website this Actor collects data from.

This **Flipkart product scraper** turns Flipkart search, category, and product surfaces into clean, structured **Flipkart product data** you can export, schedule, and reuse. Paste keywords, category URLs, or search URLs (or a bulk mix) — then pull listings with prices, discounts, ratings, specifications, seller info, offers, images, and sample reviews. ✅

As a full **Flipkart data scraper** and practical **Flipkart API alternative**, it powers **Flipkart price monitoring**, catalog research, and **Flipkart competitive analysis** for anyone who needs an **ecommerce product scraper India** without building a private crawler.

Open it in [Apify Console](https://console.apify.com), paste your targets, hit **Start** — products stream into your dataset as they arrive.

#### ✨ What can this Flipkart marketplace scraper do?

- 🔗 **One smart `urls` field** — mix plain keywords and Flipkart category / search URLs in one list
- 🔬 **Optional deep detail** — enrich each item with specs, rating breakdown, seller, offers, EMI, exchange, return policy, variants, and sample reviews
- ↕️ **Sort controls** — relevance, popularity, price low→high / high→low, newest
- 📍 **Delivery pincode** — optional PIN so availability reflects a location where supported
- 🧹 **Auto de-duplication** — skip products already collected when targets overlap
- 🗂️ **Sectioned output** — Products · Specifications & Ratings · Search Progress
- ⚡ **Live results + combined file** — dataset rows land as they scrape, plus one `OUTPUT` JSON array
- 🧩 **Apify platform powers** — scheduling, monitoring, API access, MCP, webhooks, and 1,000+ integrations

#### 📦 What data can you extract from Flipkart?

| 🗂️ Section | 📌 What you get |
|---|---|
| 🛍️ Listing core | Title, brand, category, URL, image, rank, currency |
| 💰 Pricing | Price, original price, discount %, price text — core of a **Flipkart price scraper** |
| ⭐ Ratings | Average rating, rating count, optional breakdown & aspect ratings |
| 📦 Availability | Stock status and availability flags |
| 🧾 Specs & detail | Full **Flipkart product specifications**, warranty, breadcrumbs, variants |
| 🏪 Seller & policy | Seller info, return policy, offers, EMI, exchange offer |
| 💬 Sample reviews | Short review snippets from the detail page |
| 📊 Progress | Per-keyword / URL pages scraped and products found |

### 🌟 Why scrape Flipkart products?

Flipkart is one of India’s richest public catalogs. A dedicated **Flipkart catalog scraper** and **Flipkart ecommerce intelligence** workflow helps you:

- 📉 Run **Flipkart price monitoring** across SKUs, brands, and categories
- 🗂️ Build catalogs with a **Flipkart search scraper** / **Flipkart category scraper**
- 🕵️ Compare sellers, discounts, and ratings for **Flipkart competitive analysis**
- 📋 Capture deep **Flipkart product details** and **Flipkart product listings** for BI or ML
- 🏷️ Track **Flipkart discount scraper** signals and promotional offers over time
- 📤 **Flipkart product export** into Sheets, warehouses, or agent pipelines

### 🚀 How to scrape Flipkart products (Apify Console)

1. Open **Flipkart Product Scraper** in [Apify Console](https://console.apify.com)
2. Paste keywords and/or Flipkart URLs into **Keywords or Flipkart URLs** (bulk paste supported)
3. Set **Maximum products per URL**, sort order, and whether to fetch full product detail pages
4. Optionally add a delivery **pincode**
5. Click **Start** and watch the Output table fill in real time
6. Export JSON / CSV / Excel / XML / RSS — or download the combined `OUTPUT` file from Storage

💡 Tip: mix `"bluetooth headphones"` and a pasted category URL in the same `urls` list — this **Flipkart marketplace scraper** auto-detects each line.

### 📥 Input

One field does almost everything:

```json
{
    "urls": ["watch", "https://www.flipkart.com/laptops/pr?sid=6bo,b5g"],
    "maxProductsPerUrl": 20,
    "sort": "relevance",
    "scrapeProductDetails": true
}
```

| Field | Description |
|---|---|
| 🔗 `urls` *(required)* | Keywords and/or Flipkart category / search URLs — powers this **Flipkart product scraper** |
| 📦 `maxProductsPerUrl` | Stop after N products per target |
| ↕️ `sort` | `relevance` · `popularity` · `price_asc` · `price_desc` · `newest` |
| 🔎 `scrapeProductDetails` | Enrich with full **Flipkart product details** (specs, seller, offers…) |
| 📄 `maxPagesPerTarget` | Safety cap on result pages per keyword / URL |
| 🧹 `dedupeProducts` | Skip duplicate product IDs within a run |
| 📍 `pincode` | Optional Indian PIN for location-aware availability |
| Performance | Search / detail concurrency, retries, timeouts, polite delay |
| Raw options | Keep Flipkart’s raw listing / detail JSON when needed |

See the **Input** tab for every field with helpful defaults.

### 📤 Output

Results stream live into the dataset (switch views in **Output**), plus one combined file — ready for **Flipkart inventory data** pipelines and catalog syncs:

```json
{
    "recordType": "product",
    "id": "WATHGFT7PPUGUFDK",
    "item_id": "itmbef4b86b7aad2",
    "title": "SABR Premium Analog Series white Polycarbonate Plastic Strap, Analog Watch - For Men & Women",
    "brand": "SABR",
    "category": "WristWatch",
    "price": 242,
    "price_text": "₹242",
    "original_price": 1952,
    "discount_percent": 87,
    "rating": 3.9,
    "rating_count": 905,
    "rating_breakdown": { "1": 133, "2": 63, "3": 87, "4": 107, "5": 515 },
    "availability_status": "IN_STOCK",
    "is_available": true,
    "currency": "INR",
    "image_url": "http://rukmini1.flixcart.com/image/832/832/.../original.jpeg?q=75",
    "url": "https://www.flipkart.com/sabr-.../p/itmbef4b86b7aad2?pid=WATHGFT7PPUGUFDK",
    "seller": { "name": null, "id": "a2d6cbd925d0469b", "rating": 0.0 },
    "return_policy": { "return_days": 10, "category": "MerchantReturnFiniteReturnWindow", "fees": "FreeReturn" },
    "sample_reviews": [{ "title": "Super!", "author": "Flipkart Customer", "rating": 5.0, "text": "very nice" }],
    "rank": 1,
    "detail_fetched": true,
    "sourceEntry": "watch",
    "fetched_at": "2026-09-07T06:06:13.320Z"
}
```

#### 🗂️ Output views & files

| View / file | Shows |
|---|---|
| 🛍️ **Products** | Shopping-focused columns (price, discount, rating, availability, seller…) |
| 📋 **Specifications & Ratings** | Spec tables, rating breakdown, offers, sample reviews |
| 📊 **Search Progress & Stats** | Per-target pages scraped and products found |
| 📄 **`OUTPUT` combined** | Full run as one JSON array in the key-value store |

```
GET https://api.apify.com/v2/key-value-stores/{storeId}/records/OUTPUT
```

### 🤖 Use via API (Flipkart API alternative)

Call the Actor like a lightweight **Flipkart API alternative** and get dataset items back:

```bash
curl -X POST "https://api.apify.com/v2/acts/<YOUR_USERNAME>~flipkart-product-scraper/run-sync-get-dataset-items" \
     -H "Authorization: Bearer $APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"urls": ["watch"], "maxProductsPerUrl": 20}'
```

Prefer one view? Use dataset views from the Output tab. Schedule **Flipkart price monitoring**, connect Zapier / Make / n8n, or pipe **Flipkart product data** into agents via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).

### 🎯 Best use cases for this Flipkart data scraper

- 📉 **Flipkart price monitoring** and **Flipkart discount scraper** alerts over time
- 🗂️ Catalog & market research with a **Flipkart catalog scraper** / **Flipkart category scraper**
- 🕵️ **Flipkart competitive analysis** on pricing, ratings, and **Flipkart seller data**
- 📊 **Flipkart ecommerce intelligence** into BI tools, sheets, or your database
- 🧾 Deep **Flipkart product specifications** and offer / EMI / return-policy research
- 💬 Pair with reviews for full VOC — listing fields + sample reviews out of the box

### 🔗 Integrations & related Actors

This **ecommerce product scraper India** works with Apify’s API, schedules, webhooks, and popular destinations (Sheets, Slack, warehouses, and more).

| Actor | What it helps with |
|---|---|
| [Flipkart Reviews Scraper](https://apify.com) | Full customer reviews, ratings, photos, and rating summaries |
| [Google Ads Transparency Center Scraper & API](https://apify.com) | Competitor ad creatives and brand ad tracking |
| [Y Combinator Scraper](https://apify.com) | Startup directory, founders, and job listings |
| [Stocktwits Scraper](https://apify.com) | Live stock & crypto social sentiment |

Need a custom pipeline (multi-marketplace sync, enrichment, or private catalog feeds)? Email **hello.insights.data@gmail.com**.

### ❓ FAQ

#### Can I search by keyword and by URL in the same run?

Yes — mix plain keywords and pasted Flipkart URLs freely in `urls`. This **Flipkart search scraper** treats each line as its own target.

#### Do I need the detail-page fetch?

Only if you want deeper **Flipkart product details** (full specs, rating breakdown, seller, offers, sample reviews). Turn `scrapeProductDetails` off for a faster listing-only run.

#### Can I get one combined file instead of browsing the dataset?

Yes — every run also saves a single JSON array to key-value store **`OUTPUT`** for classic **Flipkart product export**.

#### Why are some fields null?

Some products or categories do not expose every field. A `null` / empty value means it was not present on the page — not an error.

#### Can I get results in Python or JavaScript?

Yes. Use the Apify API / SDKs to pull **Flipkart product data** into Python, Node.js, or any HTTP client — the same pattern as a lightweight **Flipkart API alternative**.

#### Is scraping Flipkart allowed for research?

This Actor collects only publicly available listing and product pages. Use the data responsibly and in line with Flipkart’s terms and applicable laws. For compliance questions on a custom deployment, contact **hello.insights.data@gmail.com**.

### 🛟 Support & custom solutions

Bugs or feature ideas? Open an issue on this Actor’s **Issues** tab in Apify Console.

For custom scrapers, scheduled **Flipkart price monitoring**, private enrichment, or enterprise exports of **Flipkart product listings**, email **hello.insights.data@gmail.com** — we build tailored solutions on top of this Actor.

***

*Data is collected only from Flipkart’s publicly available search, category, and product pages. Intended for legitimate market research, price monitoring, and ecommerce intelligence. Not affiliated with Flipkart.*

# Actor input Schema

## `urls` (type: `array`):

✨ The one field you need. Add one entry per line, bulk paste supported. Each line is auto-detected as either a 🔍 plain keyword (e.g. "bluetooth headphones") or a 📋 Flipkart category/search page URL (e.g. "https://www.flipkart.com/search?q=watch"). Every entry becomes its own scrape target, paginated up to 'Maximum products per URL'.

## `maxProductsPerUrl` (type: `integer`):

Stop paginating one target once this many products have been collected from it.

## `sort` (type: `string`):

Applied to every target that doesn't already carry its own sort order in the pasted URL.

## `scrapeProductDetails` (type: `boolean`):

Adds one extra request per unique product to enrich it with rating breakdown, full specifications, warranty, seller, offers, EMI, exchange offer, return policy, sample reviews, breadcrumbs and variants — everything the search-results page alone doesn't carry. Turn off for a faster, lighter run with just the search-listing fields.

## `maxPagesPerTarget` (type: `integer`):

Safety cap on how many result pages a single keyword/URL is paginated through, regardless of 'Maximum products per URL'.

## `dedupeProducts` (type: `boolean`):

Skip a product already collected earlier in the same run (by its Flipkart product ID) — useful when several of your URLs/keywords overlap.

## `pincode` (type: `string`):

Optional Indian PIN code, sent along with each request so prices/availability reflect that delivery location where Flipkart supports it. Leave empty to use Flipkart's default.

## `searchConcurrency` (type: `integer`):

How many keywords/URLs are paginated at the same time.

## `detailConcurrency` (type: `integer`):

How many individual product detail pages are fetched at the same time. Only relevant when 'Fetch full product detail page' is on.

## `maxRequestRetries` (type: `integer`):

How many times one failed/blocked request is retried (with backoff) before it's given up on.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single response before treating it as failed.

## `requestDelay` (type: `number`):

A polite minimum pace shared across every concurrent request. Raise this if you see a lot of retry/backoff activity in the log.

## `includeRawProductData` (type: `boolean`):

Keep Flipkart's own raw listing-tile object (field 'productData') embedded in every result, verbatim — handy for power users and debugging, or if a future Flipkart field isn't mapped yet.

## `includeRawDetailPage` (type: `boolean`):

Also keep Flipkart's raw product detail-page object on every result. Off by default — verbose, mainly for debugging.

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

🚦 Default is NO proxy — the actor talks to Flipkart directly. If a request ever gets rejected or blocked, it automatically escalates step-by-step: 🚫 no proxy → 🖥️ datacenter proxy → 🏠 residential proxy (retrying up to 3× on residential), and then sticks with residential for the rest of the run. Every escalation is logged clearly. Force a tier yourself here if you already know what a target needs.

## Actor input object example

```json
{
  "urls": [
    "watch",
    "https://www.flipkart.com/laptops/pr?sid=6bo,b5g"
  ],
  "maxProductsPerUrl": 20,
  "sort": "relevance",
  "scrapeProductDetails": true,
  "maxPagesPerTarget": 50,
  "dedupeProducts": true,
  "pincode": "110001",
  "searchConcurrency": 5,
  "detailConcurrency": 8,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 30,
  "requestDelay": 0,
  "includeRawProductData": true,
  "includeRawDetailPage": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every scraped record — products and search-progress bookkeeping together, in scrape order.

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

Only product records, with the shopping-focused columns.

## `specifications` (type: `string`):

Only the detail-page enrichment fields (specs, rating breakdown, offers, reviews) per product.

## `searchProgress` (type: `string`):

Per-target bookkeeping: pages scraped and products found for each keyword/URL.

## `outputJson` (type: `string`):

Every product from this run in a single combined JSON array — the classic output.json shape — saved to the run's key-value store under the 'OUTPUT' key.

# 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 = {
    "urls": [
        "watch"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insights_data/flipkart-product-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 = {
    "urls": ["watch"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("insights_data/flipkart-product-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 '{
  "urls": [
    "watch"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call insights_data/flipkart-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insights_data/flipkart-product-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/hc5gYDhZ2nD6aYN6j/builds/LNrofMKb8feRp1sJZ/openapi.json