# Flipkart Product Scraper · Prices, ratings, specs · $1/1K (`mlg14/flipkart-scraper`) Actor

Scrape Flipkart product listings from a search phrase or category page for price tracking, catalog analysis and competitor research. Prices, discounts, ratings, availability, images and key specs per product. $1/1K products.

- **URL**: https://apify.com/mlg14/flipkart-scraper.md
- **Developed by:** [MLG Data](https://apify.com/mlg14) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

Scrape Flipkart product listings from a search phrase or a public category URL, then export product data to JSON, CSV, or Excel. This Flipkart product data extractor gives price, discount, ratings, availability, images, and listing links in one row per product for catalog analysis and recurring price checks.

The actor reads public listing pages. It accepts a keyword such as `wireless mouse`, or a category URL such as the mobile phones listing, and follows result pages until it reaches your requested count or the available listing ends. Each product identifier appears once in the output, even when a large run visits more than one sort order.

### What data can you extract from Flipkart?

Every result is a flat product record. A value is `null` when a public listing card does not expose it. Prices are numeric Indian rupees; the text versions preserve a display friendly rupee format. The `ratingBreakdown` object uses keys `1` through `5` for star counts. `keySpecs` and `imageUrls` are arrays, so they remain usable in JSON exports.

| Field | Description | Example |
|---|---|---|
| `id` | Product identifier | `ACCHF448XHS2JPEH` |
| `itemId` | Item identifier from the product URL | `itm1e15fb3549151` |
| `listingId` | Listing identifier | `LSTACCHF448XHS2JPEHTIT6IR` |
| `title` | Full product title | `pTron Flick M1 Ambidextrous Optical Mouse...` |
| `subtitle` | Variant or short description | `2.4GHz Wireless, Bluetooth, Black` |
| `brand` | Brand label, or first title word if no label exists | `pTron` |
| `category` | Product vertical on the listing | `mouse` |
| `price` | Current numeric price in INR | `399` |
| `priceText` | Display price | `₹399` |
| `originalPrice` | Crossed out or original price | `1499` |
| `originalPriceText` | Display version of original price | `₹1,499` |
| `discountPercent` | Displayed percentage discount | `73` |
| `discountAmount` | Displayed amount saved | `1100` |
| `discountText` | Discount label | `73% off` |
| `rating` | Average customer rating | `4.3` |
| `ratingCount` | Number of ratings | `1096` |
| `reviewCount` | Number of reviews | `119` |
| `ratingBreakdown` | Counts by star rating, if present | `{"5": 669}` |
| `specifications` | Structured details, if supplied on the listing | `null` |
| `keySpecs` | Key feature bullets in some categories | `null` |
| `warrantySummary` | Warranty text where listed | `null` |
| `availabilityStatus` | Listing stock state | `IN_STOCK` |
| `isAvailable` | Whether the state is in stock | `true` |
| `buyabilityIntent` | Listing purchase state | `positive` |
| `isFlipkartAdvantage` | Advantage flag from the card | `true` |
| `swatchAvailable` | Whether variant swatches are shown | `true` |
| `currency` | Price currency | `INR` |
| `analyticsCategory` | Broad category label | `ComputerAccessory` |
| `analyticsSubCategory` | Category detail label | `LaptopAccessory` |
| `marketplace` | Marketplace code | `FLIPKART` |
| `imageUrl` | Main image URL | `https://rukmini1.flixcart.com/...` |
| `imageUrls` | All image URLs present on the card | `[...]` |
| `url` | Direct product link | `https://www.flipkart.com/.../p/itm...` |
| `sourceUrl` | Result page where the product appeared | `https://www.flipkart.com/search?q=wireless+mouse` |
| `position` | Position within the visited sort order | `1` |
| `isSponsored` | Whether an ad marker accompanies the card | `true` |
| `fetchedAt` | UTC time when the record was made | `2026-09-26T18:06:10.503377+00:00` |

This field list distinguishes a product identifier, a listing identifier, and the item identifier in the URL. Keep `id` as the stable deduplication key when comparing repeated exports. A listing identifier can change when a product is offered through a different listing. The item identifier is useful for joining product links, but a category may expose several listings for the same underlying item.

### How to scrape Flipkart products

1. Enter a search phrase in `keyword`, or paste a public Flipkart search or category listing into `startUrl`.
2. Select a sort order and set `results_wanted` to the maximum number of unique products you need.
3. Run the actor. It visits listing pages in sequence and stops as soon as the result limit is reached.
4. Open the dataset to inspect products, then download JSON, CSV, or Excel for your analysis.

If you provide both a keyword and a URL, the URL is used. To preserve a category, price filter, or other public filter, use the complete listing URL (the keyword is then ignored). The actor accepts HTTPS Flipkart search pages and category paths ending in `/pr`; a direct product page is not a listing input.

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keyword` | String | Empty | Search phrase. Used when `startUrl` is empty. |
| `startUrl` | String | Empty | Public search or category listing URL. Takes priority over `keyword`. |
| `sort` | String | `relevance` | `relevance`, `popularity`, `price_asc`, `price_desc`, or `newest`. |
| `results_wanted` | Integer | `40` | Maximum number of unique products to return. Minimum is one. |
| `proxyConfiguration` | Object | Available proxy, datacenter first | Connection settings for listing requests. |

A keyword search for a manageable price sample:

```json
{
  "keyword": "wireless mouse",
  "sort": "relevance",
  "results_wanted": 40
}
```

A category run with the URL's own category selection:

```json
{
  "startUrl": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io&marketplace=FLIPKART",
  "sort": "price_asc",
  "results_wanted": 120
}
```

The actor applies the selected sort to the URL. `newest` corresponds to the site's descending recency order. Some categories do not offer that order, so results may appear in the site's fallback order. For exact category or price filters, check the listing in a browser and paste the resulting full URL. Search terms are encoded before the first request, so spaces and punctuation can be entered normally.

### Output example

This is a shortened record from a successful 40 product run for `wireless mouse`. The actual dataset row also contains every field listed above, including all available image links.

```json
{
  "id": "ACCHF448XHS2JPEH",
  "itemId": "itm1e15fb3549151",
  "listingId": "LSTACCHF448XHS2JPEHTIT6IR",
  "title": "pTron Flick M1 Ambidextrous Optical Mouse High Precision,4 Buttons, Plug&Play",
  "subtitle": "2.4GHz Wireless, Bluetooth, Black",
  "brand": "pTron",
  "category": "mouse",
  "price": 399,
  "originalPrice": 1499,
  "discountPercent": 73,
  "rating": 4.3,
  "ratingCount": 1096,
  "reviewCount": 119,
  "ratingBreakdown": {"1": 88, "2": 24, "3": 78, "4": 237, "5": 669},
  "availabilityStatus": "IN_STOCK",
  "isAvailable": true,
  "currency": "INR",
  "isSponsored": true,
  "url": "https://www.flipkart.com/ptron-flick-m1-ambidextrous-optical-mouse-high-precision-4-buttons-plug-play/p/itm1e15fb3549151?pid=ACCHF448XHS2JPEH",
  "sourceUrl": "https://www.flipkart.com/search?q=wireless+mouse",
  "position": 1,
  "fetchedAt": "2026-09-26T18:06:10.503377+00:00"
}
```

The timestamp describes the extraction, not a product's publication or last price change. Store successive runs with their timestamps to create your own price history. Discount values come from the public card at that moment; they are not recomputed against an external price source.

### Use cases

- **Price monitoring:** Collect the same category or search daily, join results by `id`, and highlight price or discount changes. A repeated export is a snapshot, so retain prior runs if you want a historical trend.
- **Competitive catalog research:** Compare displayed prices, ratings, and listed features for similar products. Use a narrow keyword or category URL to reduce unrelated search results.
- **Assortment tracking:** Count available products by category and brand, then compare the count over time. Keep the same input and sort order for meaningful comparisons.
- **Promotion review:** Use `originalPrice`, `discountPercent`, and `isSponsored` to inspect how discounted and promoted products appear in a listing. The ad marker is sourced from the card and may vary between visits.
- **Product discovery:** Export titles, links, and images for a shortlist that a team can review. The direct `url` field makes each row easy to verify before purchasing or publishing a report.
- **Rating analysis:** Use average rating, total ratings, review counts, and the five star counts when available to compare product reception across a category.

### How much does it cost to scrape Flipkart?

The current event price is **$1.00 per 1,000 products delivered**. One product row is one result event. A 40 product run is about $0.04 in result charges; 500 delivered products are about $0.50; 2,000 delivered products are about $2.00. These examples count delivered rows, not visited pages or duplicate cards. Check the actor's current pricing before a large scheduled run because Store prices can change.

`results_wanted` is a hard output cap, which helps bound result charges. If only 80 products are available from a requested 200, the dataset contains 80 rows. A run that visits additional pages to find unique products does not create extra result events for duplicates. Proxy usage and any account level charges are separate from the arithmetic above, so your account's usage view is the source for final billing.

### Tips for best results

Start with a narrow phrase such as a product family, product type, or key specification. Broad searches can mix categories and make a price comparison misleading. When a category has useful filters, open that public listing, choose filters there, and paste its complete URL into `startUrl`. The actor retains its query parameters and updates only page and sort values while paginating.

Use 40 results for a quick first run. Search pages commonly return about 40 cards; some categories return fewer, so the number of page requests depends on the listing. Increase `results_wanted` after checking that the search returns the product type you need. For a stable recurring dataset, keep the query, category path, filters, and sort order consistent between runs.

The `sourceUrl` records which listing page supplied an item. Use it when investigating a surprising title, price, or category. `isSponsored` identifies cards with an ad marker; it does not state the advertising placement, spend, or targeting. `brand` is sometimes inferred from the first word of the title because the public card omits an explicit brand label. Verify that field before using it for strict brand reporting.

For image workflows, use `imageUrl` for a preview and `imageUrls` for the full set exposed on the listing card. The URLs use a fixed image size and quality setting. Image availability can change after a run, so archive images separately if you need permanent copies. Numeric prices and counts are easier to aggregate than their display text equivalents.

### Limits

A tested search exposed products through page 25 and returned no products at page 26. The actor stops at 25 pages per sort order. When more than roughly 1,000 products are requested, it also visits other public sort orders and deduplicates by product ID to seek additional results. Sort slices can overlap heavily, so a high requested count is not a promise that many unique products exist. Rows after the first sort slice are grouped by the subsequent sorts, not globally ranked under the selected sort.

Product cards vary by category. A mobile phone card can include key specification bullets and warranty text, while an accessory card may have neither. Full specification tables and seller names are usually found on product detail pages rather than listing cards; this actor does not visit every detail page. `specifications` may therefore be `null`, and no seller field is promised. Ratings can also be absent on new products.

Availability is the listing state returned during the run. It can change by time, delivery location, or site behavior, and it is not a checkout guarantee. Prices and discounts are likewise point in time values. An inaccessible page may yield fewer results than requested; the actor continues only while valid listing cards and pagination remain available. Public page layout and card data can change, which may require an extractor update.

### Automated workflows

Use a descriptive request such as “collect the first 100 wireless mouse listings sorted by price” to choose an input, then inspect the returned dataset before making a buying or pricing decision. For recurring research, save the same category URL and result limit in a schedule and compare exports by product ID and extraction timestamp.

An example analysis request is: “Find products in this export with a rating above 4 and a discount above 30%, then show their titles, current prices, review counts, and URLs.” Another is: “Compare yesterday's and today's exports by `id` and flag price changes greater than 10%.” These examples work on exported rows; they do not imply that every listing exposes every optional field.

### FAQ

#### Is it legal to collect these listings?

The actor accesses public product listing pages. You are responsible for complying with applicable law, site terms, and any privacy obligations in your use of the data. The output is product focused and does not seek account only or private customer information.

#### Do I need a proxy?

The default connection uses the available datacenter route first and can escalate when a page blocks requests. You can supply your own proxy configuration. Connection reliability depends on the site's current access controls and the account's available proxy resources.

#### How fast is a run?

A 40 product verification run completed successfully, with the product extraction lasting only a short part of the overall build and run process. Larger runs require more listing pages and can slow down if requests need retries or a browser challenge. Use the run log and dataset count to measure your particular query.

#### Can I schedule a daily price check?

Yes. Save an input and run it on a daily schedule. Join successive datasets on `id`; compare `price`, `availabilityStatus`, and `fetchedAt`. Keep the same filters for a fair comparison and account for occasional products leaving the public result set.

#### Can I export to a spreadsheet?

Yes. Download the dataset as CSV or Excel, or use JSON for a structured pipeline. Arrays and the rating breakdown are best preserved in JSON; a spreadsheet export may render them as serialized values.

#### Why are key specifications or warranty empty?

Many listing cards omit those details. A category may show only a title, image, price, and rating. The actor leaves absent values as `null` instead of inventing a specification or warranty. Product detail pages can contain more information than the listing output.

#### Why did I receive fewer products than requested?

A listing may have too few unique products, end before the requested count, hit the 25 page boundary, repeat products under several sorts, or temporarily return an inaccessible page. Narrower category filters can make the available pool smaller. Review `sourceUrl` and the run log when diagnosing a short dataset.

### Use with AI agents (MCP)

Add this actor to any MCP client (Claude, Cursor, VS Code, n8n and others) with one URL:

`https://mcp.apify.com?tools=mlg14/flipkart-scraper`

The actor returns one dataset item per Flipkart product (title, price, discount, rating, availability, images, key specs, listing URL). Keep `results_wanted` small so a run finishes in seconds and costs cents.

**Prompt 1:** "Get 40 wireless mouse products from Flipkart with prices and ratings."

```json
{
  "keyword": "wireless mouse",
  "results_wanted": 40
}
```

**Prompt 2:** "List the 30 cheapest running shoes on Flipkart."

```json
{
  "keyword": "running shoes",
  "sort": "price_asc",
  "results_wanted": 30
}
```

**Prompt 3:** "Scrape 50 mobile phones from this Flipkart category page."

```json
{
  "startUrl": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io&marketplace=FLIPKART",
  "results_wanted": 50
}
```

### Integrations

The dataset can feed a scheduled report, a webhook, a spreadsheet, or a database. A common workflow runs the same search periodically, stores the rows, joins records by `id`, and sends a notification only when price or availability changes. Exported JSON keeps nested `ratingBreakdown` and image arrays intact; CSV is convenient for quick sorting and filtering. Keep `fetchedAt` and `sourceUrl` alongside the product fields for auditability.

### Support

Open an issue on the Issues tab with the input, a representative product URL, the run time, and the field you expected. We reply within 24 hours and consider field requests for future updates.

# Actor input Schema

## `keyword` (type: `string`):

Search phrase used to find Flipkart products, e.g. wireless mouse or running shoes. Use it for a quick keyword search; leave empty when you provide a Listing URL, which takes priority.

## `startUrl` (type: `string`):

Public Flipkart search or category listing URL, e.g. https://www.flipkart.com/mobiles/pr?sid=tyy,4io\&marketplace=FLIPKART. Use it to scrape one exact category with filters; leave empty to search by keyword. Takes priority over keyword.

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

Product order. Allowed values: relevance, popularity, price_asc (low to high), price_desc (high to low), newest. Example: price_asc for the cheapest first. Use newest only in categories that expose it; keep relevance by default.

## `results_wanted` (type: `integer`):

Stop after this many unique products, e.g. 40. A listing exposes up to 25 pages per sort order. Use a small value like 40 for quick tests and price checks; raise it for full category exports.

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

Proxy settings for listing requests. The default uses the Apify datacenter proxy first and escalates only if needed.

## Actor input object example

```json
{
  "keyword": "wireless mouse",
  "startUrl": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io&marketplace=FLIPKART",
  "sort": "relevance",
  "results_wanted": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Scraped product listings in the default dataset.

# 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 = {
    "keyword": "wireless mouse",
    "results_wanted": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/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 = {
    "keyword": "wireless mouse",
    "results_wanted": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/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 '{
  "keyword": "wireless mouse",
  "results_wanted": 40
}' |
apify call mlg14/flipkart-scraper --silent --output-dataset

```

## MCP server setup

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