# Flipkart Products Scraper (`automation-lab/flipkart-product-listings-scraper`) Actor

Extract Flipkart search and category product listings with IDs, prices, discounts, ratings, availability, highlights, images, and canonical URLs.

- **URL**: https://apify.com/automation-lab/flipkart-product-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 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

## Flipkart Products Scraper

Extract **Flipkart products** from public search results and category pages into a clean Apify dataset.
The Actor captures stable product identity, current price, MRP, discount, rating counts, availability signals, product highlights, images, rank, and canonical URLs.

Use it to refresh product catalogs, compare displayed prices, create repeatable assortment snapshots, or feed marketplace research pipelines.
No Flipkart login is required.

### What does Flipkart Products Scraper do?

The Actor accepts either:

- search phrases such as `iphone 15` or `gaming laptop`;
- public Flipkart search URLs; or
- public Flipkart category listing URLs ending in `/pr`.

It follows normal listing pagination, deduplicates products by Flipkart product ID, and stops at your item or page limit.
Primary results are written to the run's default dataset.

The extractor reads server-rendered listing data instead of opening every product detail page.
This keeps runs focused on catalog monitoring and avoids unnecessary media downloads.

### Who is it for?

#### E-commerce analysts

Build current assortment and price snapshots for a product segment.

#### Retail and brand teams

Track displayed prices, discounts, ratings, and low-stock messages for relevant searches.

#### Data engineers

Send normalized listing records to a warehouse, spreadsheet, webhook, or scheduled comparison job.

#### Researchers

Collect reproducible public search-result samples with source URLs and extraction timestamps.

### Why use it?

- **Two input routes:** query text and exact Flipkart listing URLs.
- **Stable identity:** records are keyed by Flipkart `pid`, not only by title.
- **Monitoring-ready:** every row includes rank, source page, and scrape time.
- **Typed output:** prices and counts are numbers rather than formatted strings.
- **Bounded pagination:** control both total output and pages per input.
- **Layered recovery:** direct HTTP is attempted first, followed by a sticky India residential HTTP session and a resource-blocked browser only when lighter routes fail.
- **No duplicate charges:** duplicate product IDs are not saved or charged twice.

### What Flipkart product data is extracted?

| Field | Meaning |
| --- | --- |
| `productId` | Stable Flipkart product identifier from `pid` |
| `title` | Product title shown in the listing |
| `productUrl` | Canonical product URL |
| `imageUrl` | Listing image URL, when shown |
| `price` | Current displayed selling price in INR |
| `currency` | `INR` |
| `mrp` | Displayed maximum retail price, when shown |
| `discountPercent` | Displayed percentage discount |
| `rating` | Average displayed rating |
| `ratingCount` | Number of ratings shown |
| `reviewCount` | Number of reviews shown |
| `availability` | Messages such as `Only 2 left` or `Coming Soon` |
| `seller` | Seller context when present; usually null on listing cards |
| `highlights` | Specifications shown on the card |
| `rank` | One-based extraction rank across the run |
| `searchQuery` | Search query from the listing URL, or null for categories |
| `sourceUrl` | Exact paginated page used for the row |
| `scrapedAt` | UTC extraction timestamp |

Fields can be null when Flipkart does not display them on a particular card.
Seller offers hidden behind a product-detail page are outside this listing-focused Actor's scope.

### How to scrape Flipkart products

1. Open the Actor in Apify Console.
2. Add one or more values under **Search queries**, or add Flipkart listing URLs.
3. Choose **Maximum products**.
4. Set **Maximum pages per input** as a safety bound.
5. Click **Start**.
6. Open the **Dataset** tab to preview, download, or integrate the records.

Start with a small limit while confirming that the chosen Flipkart search represents your intended catalog.
For recurring work, save the input as an Apify Task and add a schedule.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | string array | — | Search phrases to run on Flipkart |
| `startUrls` | URL array | — | Flipkart `/search` or category `/pr` listing URLs |
| `maxItems` | integer | `50` | Maximum unique products across all inputs; 1–10,000 |
| `maxPagesPerInput` | integer | `5` | Maximum listing pages for each query or URL; 1–100 |

At least one non-empty search query or start URL is required.
Non-Flipkart URLs and product-detail URLs fail validation instead of being treated as empty results.

#### Query input example

```json
{
  "searchQueries": ["iphone 15", "gaming laptop"],
  "maxItems": 100,
  "maxPagesPerInput": 3
}
```

#### Category input example

```json
{
  "startUrls": [
    { "url": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io" }
  ],
  "maxItems": 50,
  "maxPagesPerInput": 2
}
```

### Output example

A real run produces records in this shape:

```json
{
  "productId": "MOBGTAGPTB3VS24W",
  "title": "Apple iPhone 15 (Black, 128 GB)",
  "productUrl": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPTB3VS24W",
  "imageUrl": "https://rukminim2.flixcart.com/image/312/312/xif0q/mobile/example.jpeg?q=70",
  "price": 57749,
  "currency": "INR",
  "mrp": 59900,
  "discountPercent": 3,
  "rating": 4.6,
  "ratingCount": 247029,
  "reviewCount": 9616,
  "availability": "Only 2 left",
  "seller": null,
  "highlights": ["128 GB ROM", "15.49 cm display"],
  "rank": 1,
  "searchQuery": "iphone 15",
  "sourceUrl": "https://www.flipkart.com/search?q=iphone+15&page=1",
  "scrapedAt": "2026-08-15T12:00:00.000Z"
}
```

Values change with Flipkart's current public listing page.
The example demonstrates the schema, not a price guarantee.

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

Pricing has two events:

- a **$0.002 start event** once per run;
- one **item event** for each unique product saved.

The current BRONZE item price is **$0.0049285 per product**, with lower per-item prices at higher platform tiers.
At that tier, 10 products cost about **$0.0513**, 100 products about **$0.4949**, and 1,000 products about **$4.9305** including the start event.

Apify shows the applicable tier and maximum charge before a run.
Residential proxy transfer may affect platform usage, but the Actor does not create extra result charges for retries or duplicates.

### Scheduled price and catalog monitoring

Create an Apify Task with a stable query or category URL.
Schedule it daily or weekly.
Export each dataset to your storage destination and compare rows by `productId`.

Useful comparisons include:

- `price` and `mrp` changes;
- discount changes;
- rank movement within the same query;
- new or missing product IDs;
- rating-count growth; and
- newly displayed availability warnings.

The Actor provides snapshots; it does not maintain historical state or send alerts by itself.
Use Apify schedules, webhooks, or your data pipeline for those steps.

### Export and integration options

The default dataset can be downloaded as JSON, CSV, Excel, XML, or RSS through Apify.
Common workflows include:

1. schedule a Task and send run webhooks to an ETL service;
2. sync rows into Google Sheets for a small monitored assortment;
3. load records into BigQuery, Snowflake, or PostgreSQL keyed by `productId`;
4. trigger an automation when a run finishes; or
5. call the Actor from another Actor as one stage of a marketplace pipeline.

Preserve `sourceUrl` and `scrapedAt` when comparing snapshots so each observation remains traceable.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~flipkart-product-listings-scraper/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["iphone 15"],"maxItems":20,"maxPagesPerInput":1}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/flipkart-product-listings-scraper').call({
  searchQueries: ['iphone 15'],
  maxItems: 20,
  maxPagesPerInput: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/flipkart-product-listings-scraper").call(
    run_input={
        "searchQueries": ["iphone 15"],
        "maxItems": 20,
        "maxPagesPerInput": 1,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/flipkart-product-listings-scraper"
```

Claude Desktop, Cursor, and VS Code can use the same MCP server URL in their MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/flipkart-product-listings-scraper"
    }
  }
}
```

Example prompts:

- “Extract the first 20 Flipkart listings for iphone 15 and summarize price ranges.”
- “Run the Flipkart mobiles category Task and return products showing low-stock messages.”
- “Collect two pages of laptop listings and group them by displayed rating.”

AI-generated analysis should retain product URLs so results can be checked against their public source.

### Reliability, pagination, and limits

Flipkart can vary HTML, ranking, stock messages, and product availability by time and location.
A repeated query may therefore return different rows or order.

The Actor retries transient failures with bounded backoff.
It starts with direct HTTP, can rotate a bounded India residential session after a block, and uses one resource-blocked residential browser only after lighter HTTP routes are exhausted.
A healthy fallback session is reused across pagination instead of opening a browser for every product.

Pagination ends when:

- `maxItems` is reached;
- `maxPagesPerInput` is reached; or
- a page yields no new product IDs.

A challenge or unexpected upstream response fails visibly rather than returning a misleading successful empty dataset.

### Troubleshooting

#### The run says the start URL is unsupported

Use a public Flipkart search URL beginning with `/search` or a category listing ending in `/pr`.
Product-detail URLs are intentionally rejected because this Actor extracts listings.

#### The dataset has fewer records than `maxItems`

The source may have fewer unique visible products, pagination may have ended, or several inputs may overlap.
`maxItems` is a ceiling, not a promise to invent rows.

#### Some values are null

Flipkart listing cards do not show every field for every category.
For example, seller names and MRP may be absent.
Null preserves that distinction instead of guessing.

#### A run fails after retries

Check the run log for the exact HTTP or content error.
Retry later if Flipkart is temporarily unavailable.
If a stable page changed shape, include the source URL and run link when reporting the issue.

### Responsible use and legality

This Actor extracts information displayed on public Flipkart listing pages.
You are responsible for your input, run frequency, storage, and downstream use.

Follow applicable laws, Flipkart's terms, and Apify's policies.
Avoid collecting personal data, overwhelming the source, republishing protected content without permission, or using results for deceptive practices.
Use conservative schedules and request only the volume needed for a legitimate purpose.
This documentation is not legal advice.

### FAQ

#### Does it require a Flipkart account?

No. It targets public search and category listing pages.

#### Does it scrape reviews or product-detail descriptions?

No. It exports review counts and highlights visible on listing cards, not review text or full detail pages.

#### Can it scrape several searches in one run?

Yes. Add multiple `searchQueries` and/or `startUrls`; the overall `maxItems` applies across them.

#### Are prices historical?

No. Each row is a current public snapshot with `scrapedAt`.
Build history by scheduling repeat runs and storing their datasets.

#### Does it expose Flipkart customer-care or careers data?

No. Those unrelated keyword associations are outside the supported product-listing workflow.

### Related Automation Lab Actors

For broader marketplace monitoring, consider these Automation Lab Actors:

- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper) for Amazon product pages and offers.
- [Blinkit Category Products Scraper](https://apify.com/automation-lab/blinkit-category-products-scraper) for location-specific quick-commerce assortment snapshots.
- [Jumia Products & Sellers Scraper](https://apify.com/automation-lab/jumia-products-sellers-scraper) for supported African Jumia storefronts.

Choose a source-specific Actor because marketplace identifiers, prices, availability, and geography are not directly interchangeable.

# Actor input Schema

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

Product searches to run on Flipkart, such as iphone 15 or gaming laptop.

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

Optional Flipkart search or category listing URLs. Product-detail and non-Flipkart URLs are rejected.

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

Stop after saving this many unique product records across all inputs.

## `maxPagesPerInput` (type: `integer`):

Safety limit for pagination of each query or listing URL.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone 15"
  ],
  "startUrls": [
    {
      "url": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io"
    }
  ],
  "maxItems": 20,
  "maxPagesPerInput": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all extracted product records.

# 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": [
        "iphone 15"
    ],
    "startUrls": [
        {
            "url": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flipkart-product-listings-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": ["iphone 15"],
    "startUrls": [{ "url": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flipkart-product-listings-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": [
    "iphone 15"
  ],
  "startUrls": [
    {
      "url": "https://www.flipkart.com/mobiles/pr?sid=tyy,4io"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/flipkart-product-listings-scraper --silent --output-dataset

```

## MCP server setup

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