# Flipkart Scraper — India Products, Prices, Discounts & Specs (`haketa/flipkart-scraper`) Actor

Scrape product listings from Flipkart.com (India e-commerce marketplace): extract product title, brand, selling price, MRP, discount %, star rating, review count, key specifications, warranty, stock status, category and image URL by keyword or search URL. Export to JSON, CSV, Excel or API.

- **URL**: https://apify.com/haketa/flipkart-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Business, Marketing
- **Features:** Limited permissions
- **Stats:** 7 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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

## Flipkart Scraper 🛒🇮🇳 — Products, Prices, Discounts, Ratings & Specs

**This Flipkart scraper extracts product data from [Flipkart](https://www.flipkart.com), India's #1 online marketplace, into clean, structured records — no login, no coding.** Search by keyword (or paste a Flipkart search URL) and scrape Flipkart products with **title, brand, price, MRP, discount %, rating, number of ratings, review count, key specifications, warranty, availability, category and image** in one run.
Export to **JSON, CSV, Excel, or API**.

> Built for **price-monitoring teams, e-commerce analysts, pricing managers, competitor-intelligence researchers, marketplace sellers, affiliate publishers and data teams** who need fresh Indian e-commerce data at scale.

[![Actor](https://img.shields.io/badge/Apify-Actor-00b04f?style=flat-square\&logo=apify)](https://apify.com)
[![Market](https://img.shields.io/badge/Market-India%20🇮🇳-ff9933?style=flat-square)](https://apify.com)
[![Discount](https://img.shields.io/badge/Price%20%26%20Discount-Tracked-e4002b?style=flat-square)](https://apify.com)
[![Specs](https://img.shields.io/badge/Key%20specs-Included-brightgreen?style=flat-square)](https://apify.com)
[![Ratings](https://img.shields.io/badge/Ratings%20%26%20Reviews-Included-success?style=flat-square)](https://apify.com)
[![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-2b7489?style=flat-square)](https://apify.com)
[![Pagination](https://img.shields.io/badge/Pagination-Automatic-blue?style=flat-square)](https://apify.com)
[![No code](https://img.shields.io/badge/No--code-Friendly-9cf?style=flat-square)](https://apify.com)

***

### 🔎 Why scrape Flipkart?

Flipkart is India's largest online marketplace, with hundreds of millions of listings across mobiles, electronics, fashion, appliances, home and more. Every product page carries a rich commercial picture: a selling price, the maximum retail price (MRP), a discount, a star rating, thousands of ratings and reviews, a block of key specifications and a warranty summary. That data is extremely valuable — but Flipkart has **no open public product API**, and the numbers change constantly as prices, offers and stock move throughout the day.

Collecting it by hand is painful: you would have to open thousands of product cards, copy prices and specs one by one, and redo the whole thing every time a sale starts. This **Flipkart scraper** does it for you — it reads the exact product data Flipkart server-renders into each search page and returns a clean, de-duplicated dataset you can download or feed straight into your own tools.

**Common reasons people scrape Flipkart:**

- 💰 **Price & discount monitoring** — track selling price, MRP and discount % across brands and categories over time.
- 📊 **Competitor & assortment analysis** — see which brands, models and price points dominate a category.
- 🧩 **Catalog & price-comparison building** — power comparison sites, apps and dashboards with fresh Indian e-commerce data.
- ⭐ **Rating & review intelligence** — rank products by rating and review volume to find bestsellers and gaps.
- 🔬 **Product research** — compare models at scale using the captured key specifications.
- 📈 **Market research** — study Indian e-commerce pricing, demand and discount behaviour.

***

### ✨ What this Flipkart scraper does

Give it a **search query** (e.g. `smartphone`, `laptop`, `headphones`) or a **Flipkart search URL**, and the actor will:

- 🔎 **Search Flipkart by keyword** — run one or many queries in a single job.
- 📄 **Paginate automatically** through every result page (`&page=1`, `&page=2`, …) until it reaches your `maxItems` target.
- 💰 Capture the **full pricing picture**: selling `price`, `mrp`, `discountPercent`, `discountAmount` and `currency` (INR).
- ⭐ Include the **rating**, **ratingCount** (number of ratings) and **reviewCount**.
- 🧩 Return the **key specifications** (`keySpecs`) and a **warranty** summary for each product.
- 🏷️ Add **brand**, **category**, **subCategory**, **availability** and a **product image**.
- 🔗 Accept **Flipkart search URLs** so your filters and sorting are respected.
- 🧹 Deliver **clean, de-duplicated** records — each product appears once, keyed by its unique Flipkart product ID — with **no HTML or clutter**.
- ⬇️ **Export** to **JSON, CSV, Excel, HTML, RSS/XML or via the Apify API**.

Fast and reliable: a recent verification run collected **500 unique products in about 53 seconds** on the default Apify datacenter proxy, with **100% coverage on the core fields** (id, title, url, price, brand) and **0 duplicates**. No login, no browser extensions, no manual copy-paste.

***

### 🎯 Use cases

- **Pricing managers** — monitor Flipkart price and discount movements for your own and competitors' SKUs.
- **E-commerce & marketplace sellers** — benchmark your listings against the top results in each category.
- **Price-comparison & deal sites** — ingest Flipkart product data to keep listings and prices current.
- **Market & category analysts** — measure brand share, price bands and discount depth across a category.
- **Affiliate publishers** — build "best of" and deal pages ranked by discount %, rating or review volume.
- **Product & sourcing teams** — compare models using key specifications pulled at scale.
- **Data & BI teams** — feed a warehouse or dashboard with fresh Indian e-commerce data on a schedule.

***

### 📥 Input

The actor accepts a simple, no-code input form. Provide **search queries**, **Flipkart search URLs**, or both.

#### Option A — by query (easiest)

```json
{
    "searchQueries": ["smartphone", "laptop"],
    "maxItems": 500,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Option B — by URL (with filters / sorting)

```json
{
    "startUrls": [
        { "url": "https://www.flipkart.com/search?q=headphones&sort=popularity" }
    ],
    "maxItems": 500,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Input parameters

| Field | Type | Description |
| --- | --- | --- |
| `searchQueries` | array | Keywords to search on Flipkart (e.g. `laptop`, `smartphone`, `shoes`, `headphones`). The scraper paginates each query automatically. |
| `startUrls` | array | Flipkart search URLs with filters/sorting already applied. Scraped **in addition** to `searchQueries`. |
| `maxItems` | integer | Maximum number of products to collect across all queries and URLs. Default `100`. |
| `proxyConfiguration` | object | Proxy settings. **Apify Proxy is enabled by default** and recommended for reliable, uninterrupted results. |

***

### 📤 Output

Each product is returned as a clean, flat JSON object. Example from a live run:

```json
{
    "id": "MOBHPP59BYSJ98M8",
    "title": "BOLTT EVO (Arctic White, 64 GB)",
    "subtitle": "4 GB RAM",
    "url": "https://www.flipkart.com/boltt-evo-arctic-white-64-gb/p/itmf046d663a1fd7?pid=MOBHPP59BYSJ98M8",
    "brand": "BOLTT",
    "price": 8999,
    "mrp": 17999,
    "discountPercent": 50,
    "discountAmount": 9000,
    "currency": "INR",
    "rating": 4.1,
    "ratingCount": 5527,
    "reviewCount": 1700,
    "keySpecs": [
        "4 GB RAM | 64 GB ROM | Expandable Upto 1 TB",
        "17.25 cm (6.79 inch) HD+ Display",
        "50MP + 2MP | 8MP Front Camera",
        "6000 mAh Lithium ion Battery",
        "T7250 Processor"
    ],
    "warranty": "1 Year Manufacturer Warranty for Device and 6 Months Manufacturer Warranty for In-box Accessories.",
    "availability": "IN_STOCK",
    "category": "Mobile",
    "subCategory": "Handset",
    "image": "https://rukmini1.flixcart.com/image/416/416/xif0q/mobile/7/t/d/-original-imahs3pd5ghzsw8e.jpeg?q=70"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `id` | Unique Flipkart product ID (used as the de-duplication key). |
| `title` | Full product title. |
| `subtitle` | Short descriptor (e.g. colour / RAM / size). *Present when available.* |
| `url` | Direct link to the Flipkart product page. |
| `brand` | Brand name. |
| `price` | Selling price, numeric (INR). |
| `mrp` | Maximum retail price. *Present for discounted items (see below).* |
| `discountPercent` | Discount percentage off MRP. *Present for discounted items.* |
| `discountAmount` | Discount amount in INR. *Present for discounted items.* |
| `currency` | Currency code, e.g. `INR`. |
| `rating` | Average star rating (0–5). |
| `ratingCount` | Number of ratings. |
| `reviewCount` | Number of written reviews. |
| `keySpecs` | Array of the key specifications Flipkart lists for the product. |
| `warranty` | Warranty summary. |
| `availability` | Stock status, e.g. `IN_STOCK`, `COMING_SOON`. |
| `category` | Top-level category (e.g. `Mobile`). |
| `subCategory` | Sub-category (e.g. `Handset`). |
| `image` | Product image URL (served over `https`). |

**Field coverage (from a 500-product verification run):** core fields `id`, `title`, `url`, `price`, `brand`, plus `keySpecs`, `warranty`, `availability`, `category`, `subCategory` and `image` were **100%** populated; `rating`/`ratingCount` 99.8%, `reviewCount` 99.0%, `subtitle` 95.8%. The pricing-discount fields (`mrp`, `discountPercent`, `discountAmount`) populated for ~86% of products — they are **present only when a product is discounted**; items sold at MRP have no strike-through price, so these fields are legitimately absent, not missing. Empty values are omitted from each record rather than returned as `null`.

You can download the dataset as **JSON, CSV, Excel, HTML, RSS or XML**, or fetch it programmatically through the **Apify API**.

***

### 🔁 Pagination & scale

The **Flipkart scraper** handles pagination for you. For every search query and every Flipkart search URL you provide, it walks the result pages one by one (`&page=1`, `&page=2`, …), reading every product card Flipkart server-renders into `window.__INITIAL_STATE__`. It keeps going until it has collected your `maxItems` target, runs out of results (two consecutive empty pages end that query), or reaches the internal safety ceiling (page 100 per source).

Because Flipkart categories hold tens of thousands of listings, you can realistically pull **hundreds to thousands of products** in a single run — just raise `maxItems`. Every record is **de-duplicated by its unique Flipkart product ID**, so the same item never appears twice even when it surfaces on multiple pages or across several queries. Combine broad queries (e.g. `laptop`, `smartphone`, `shoes`) in one run to build a wide, de-duplicated catalog, and use `maxItems` to cap cost and volume exactly where you want it. In testing the actor returned **500 unique products in ~53 seconds** with zero duplicates.

***

### ⚙️ How to use

1. Click **Try for free** / **Start** on the Apify Console.
2. Type one or more **search queries** — or paste a **Flipkart search URL** into `startUrls`.
3. Set **maxItems** to how many products you want.
4. Click **Save & Start**.
5. When the run finishes, open the **Dataset** tab and **Export** to JSON, CSV or Excel — or fetch it via the API.
6. **Automate it:** run on a **schedule** (daily/weekly) to keep a live price feed, or trigger it from your backend. Push results to **Google Sheets, Airtable, Slack, Zapier, Make** or any **webhook**.

#### Call via API (example)

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~flipkart-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchQueries": ["smartphone"], "maxItems": 500 }'
```

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('haketa/flipkart-scraper').call({
    searchQueries: ['laptop'],
    maxItems: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

***

### 💡 Tips

- **Start narrow, then widen.** Test one query with a small `maxItems`, confirm the fields, then scale up.
- **Paste URLs for filtered pulls.** Apply category, brand, price or sort filters on Flipkart and copy the resulting URL into `startUrls`.
- **Rank by discount %.** Sort or segment by `discountPercent` to surface the best deals in a category.
- **Rank by demand.** Use `ratingCount` and `reviewCount` as proxies for sales volume to find bestsellers.
- **Combine queries for coverage.** Pass several keywords at once — results are de-duplicated across all of them.
- **Schedule for freshness.** Prices and discounts change throughout the day; a scheduled run keeps your data current.

***

### ❓ FAQ

**Is scraping Flipkart legal?**
This actor collects only publicly available product information for lawful uses like price monitoring, market research and analytics. You are responsible for how you use the data — respect Flipkart's Terms of Service and `robots.txt`, and comply with all applicable laws.

**Do I need a Flipkart account or API key?**
No. Just provide a search query or a Flipkart search URL. Flipkart has **no open public product API**, which is why this **Flipkart scraper** reads the product data Flipkart server-renders into each page.

**How many products can I collect, and how fast?**
As many as the search returns — Flipkart categories contain tens of thousands of products. Control the volume with `maxItems`. A recent run collected **500 unique products in ~53 seconds**.

**Do I need proxies to scrape Flipkart?**
No manual setup — **Apify Proxy is enabled by default** and rotates automatically for reliable, uninterrupted results. Datacenter proxy is sufficient; you do not need residential proxies for normal runs.

**Does it include discounts and MRP?**
Yes — selling `price`, `mrp`, `discountPercent` and `discountAmount`. These pricing-discount fields are present when a product is actually discounted; items sold at MRP have no strike-through price.

**Does it include ratings, reviews and specifications?**
Yes — average `rating`, `ratingCount`, `reviewCount`, plus the `keySpecs` array and a `warranty` summary.

**Is there a Flipkart API I can call?**
Flipkart has no public product API, but once your run finishes you get a clean dataset and a full **JSON API** endpoint on Apify to fetch results programmatically.

**How fresh is the data?**
Every run reads **live Flipkart pages**, so prices, discounts, ratings and stock status reflect the moment the run executes. Schedule the actor to keep a continuously refreshed price feed.

**Can I filter by category, brand or price?**
Yes. Apply the filters and sorting on Flipkart, then paste the resulting search URL into `startUrls`.

**Are results deduplicated?**
Yes. Each product is uniquely identified by its Flipkart product ID and appears once per run, even across multiple pages and queries.

**What export formats are supported?**
JSON, CSV, Excel, HTML, RSS and XML — via the Apify dashboard or the API.

***

### 🔗 Related scrapers

Looking for more **e-commerce**, **marketplace** and **B2B supplier** data? Try these scrapers from the same author:

- [IndiaMART Scraper](https://apify.com/haketa/indiamart-scraper) — supplier listings, prices and contacts from India's largest B2B marketplace.
- [TradeIndia Scraper](https://apify.com/haketa/tradeindia-scraper) — products, sellers and quotes from TradeIndia.
- [Made-in-China Scraper](https://apify.com/haketa/made-in-china-scraper) — manufacturer and wholesale product data from Made-in-China.
- [Woolworths Scraper](https://apify.com/haketa/woolworths-scraper) — grocery and retail product prices from Woolworths.
- [OfferUp Scraper](https://apify.com/haketa/offerup-scraper) — local marketplace listings, prices and seller details from OfferUp.
- [YallaMotor Scraper](https://apify.com/haketa/yallamotor-scraper) — car listings, prices and specs from YallaMotor.

***

### ⚖️ Legal & responsible use

This actor is intended for lawful data collection such as price monitoring, market research and analytics. You are responsible for how you use the collected data. Only collect publicly available information, respect the target website's Terms of Service and `robots.txt`, and comply with all applicable laws and regulations. This actor is an independent tool and is **not affiliated with, endorsed by, or connected to Flipkart** or its parent companies. All trademarks belong to their respective owners.

***

⭐ **If this Flipkart scraper saves you time, please leave a review — it really helps!** Questions or feature requests? Open an issue on the actor's page.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/flipkart-scraper/changelog.md

# Actor input Schema

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

Keywords to search on Flipkart (e.g. laptop, smartphone, shoes, headphones). The scraper paginates automatically.

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

Paste Flipkart search URLs with filters applied (e.g. https://www.flipkart.com/search?q=smartphone\&sort=popularity). Scraped in addition to the search queries.

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

Maximum number of products to collect across all queries and URLs.

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

Proxy settings. Apify Proxy is enabled by default and recommended for reliable, uninterrupted results.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `id` (type: `string`):

Flipkart product ID

## `title` (type: `string`):

Product title

## `url` (type: `string`):

Product page URL

## `brand` (type: `string`):

Brand

## `price` (type: `string`):

Selling price (INR)

## `mrp` (type: `string`):

Maximum retail price

## `discountPercent` (type: `string`):

Discount percentage

## `rating` (type: `string`):

Average rating

## `ratingCount` (type: `string`):

Number of ratings

## `reviewCount` (type: `string`):

Number of reviews

## `warranty` (type: `string`):

Warranty summary (present for electronics)

## `category` (type: `string`):

Category

## `image` (type: `string`):

Product image URL

# 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": [
        "laptop"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/flipkart-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": ["laptop"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/flipkart-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 '{
  "searchQueries": [
    "laptop"
  ],
  "maxItems": 100
}' |
apify call haketa/flipkart-scraper --silent --output-dataset

```

## MCP server setup

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