# Flipkart Listings Scraper (`khadinakbar/flipkart-listings-scraper`) Actor

Extract public Flipkart search and category listings: product titles, prices, MRP, discounts, ratings, images, availability, and source URLs. Batch queries or listing URLs in, structured listing cards out.

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

## Pricing

from $6.00 / 1,000 listing scrapeds

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?

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

### What is Flipkart Listings Scraper?

Flipkart Listings Scraper extracts public Flipkart search and category listing cards and returns one dataset row per product card. Send keywords or Flipkart browse URLs and each row includes the product ID, title, product URL, current price, MRP, discount percentage, rating count and review count, thumbnail, sponsored flag, page and position, plus the source query or URL. Ecommerce analysts, brand teams, pricing managers and AI agents use it to monitor prices, rankings and assortment on Flipkart India, with exports to JSON, CSV or Excel.

### Why ecommerce teams choose this Flipkart scraper

- **Listing-grade speed.** It reads search and category pages only, so a keyword sweep stays quick and light.
- **Price and MRP together.** `currentPrice`, `originalPrice` and `discountPercent` show the real deal on every card.
- **Ranking context.** `position`, `page` and `isSponsored` show where each product appears and whether the slot is paid.
- **Batch inputs.** Mix many `searchQueries` and `listingUrls` in one run, each with its own `maxItemsPerInput` cap.
- **Built-in filters.** `minPrice`, `maxPrice` and `minRating` keep only the cards you want, and filtered cards carry no event.
- **India routing by default.** Apify Residential in India is the default proxy for local Flipkart pages.

### Best fit for this Actor

- Best fit for price and discount monitoring, share-of-shelf tracking and assortment research on Flipkart.
- Designed for keyword and category sweeps where one card per product is the right level of detail.
- When you want specifications, sellers, offers or descriptions for the products you found, continue with [Flipkart Product Scraper](https://apify.com/khadinakbar/flipkart-product-scraper) and pass it the `productUrl` values.
- When you want shopper feedback on a shortlist, then pass the same URLs to [Flipkart Reviews Scraper](https://apify.com/khadinakbar/flipkart-reviews-scraper).

### Example workflow: from a keyword sweep to a pricing report

A consumer-electronics brand manager starts a daily sweep with `searchQueries` for "air purifier" and "wireless earbuds", `maxItemsPerInput` at 50 and `sortBy` at `relevance`. The dataset returns each card's `title`, `currentPrice`, `originalPrice`, `discountPercent`, `position` and `isSponsored`. The team exports the rows to a spreadsheet, compares their own products' positions and discounts with competitors, flags any competitor discount above their own, and schedules the same input daily so the pricing report always reflects today's listings.

### Input

```json
{
  "searchQueries": ["wireless earbuds", "air purifier"],
  "listingUrls": ["https://www.flipkart.com/mobiles/pr?sid=tyy,4io"],
  "maxItemsPerInput": 50,
  "maxTotalItems": 150,
  "maxPagesPerInput": 10,
  "sortBy": "price_asc",
  "minPrice": 500,
  "maxPrice": 20000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
```

| Field | Type | What it controls |
|---|---|---|
| `searchQueries` | array of strings | Product keywords. |
| `listingUrls` | array of strings | Public Flipkart search, category, browse or collection URLs. |
| `maxItemsPerInput` | integer | Cards per query or URL. Default 50. |
| `maxTotalItems` | integer | Cards across the whole run. Default 500. |
| `maxPagesPerInput` | integer | Pages read per input. Default 10. |
| `sortBy` | string | For keyword searches: `relevance` (default), `price_asc`, `price_desc`, `popularity` or `newest`. |
| `minPrice`, `maxPrice` | integer | Price range in INR, applied after extraction. |
| `minRating` | number | Keep cards at or above this visible rating. |
| `proxyConfiguration` | object | Defaults to Apify Residential in India. |

### Output

| Field | What it contains |
|---|---|
| `productId`, `title`, `productUrl` | Product identity and link |
| `currentPrice`, `originalPrice`, `discountPercent`, `currency` | Selling price, MRP, discount and currency |
| `rating`, `ratingCount`, `reviewCount` | Rating signals shown on the card |
| `thumbnailUrl` | Product image |
| `isSponsored` | Whether the card is a paid placement |
| `position`, `page` | Rank on the results page |
| `sourceType`, `sourceQuery`, `sourceUrl` | The query or URL that produced the card |
| `scrapedAt` | Collection time |

```json
{
  "productId": "APFGVYWXBAFUXAMU",
  "title": "Qubo Q400 Up to 400 Sq. Ft.| True HEPA H13 | Removes 99.99% Dust, Allergens, Smoke, Virus & PM2.5 | 33...",
  "productUrl": "https://www.flipkart.com/qubo-q400-up-400-sq-ft-true-hepa-h13-removes-99-99-dust-allergens-smoke-virus-pm2-5-330-m-h-cadr-5-stage-filter-app-voice-control-9000-hrs-filter-life-portable-room-air-purifier/p/itmb160298fe29ae?pid=APFGVYWXBAFUXAMU",
  "sourceUrl": "https://www.flipkart.com/search?q=air+purifier",
  "sourceType": "search",
  "sourceQuery": "air purifier",
  "page": 1,
  "position": 1,
  "currentPrice": 8990,
  "originalPrice": 17990,
  "discountPercent": 50,
  "ratingCount": 21744,
  "reviewCount": 307,
  "thumbnailUrl": "https://rukminim2.flixcart.com/image/312/312/xif0q/air-purifier/c/t/m/-original-imahz9zyzhgfrgtg.jpeg?q=70",
  "isSponsored": false,
  "currency": "INR",
  "scrapedAt": "2026-10-01T05:15:45.676Z"
}
```

Fields a card does not display are left out of that row rather than guessed. Each run also writes `OUTPUT` (outcome) and `RUN_SUMMARY` (source, paging and charged-event counts) to the key-value store.

### Pricing

This Actor uses Pay per event plus Apify platform usage. The events are **Actor Start** (once per run) and **Listing scraped** (one per validated listing card saved to the dataset). Filtered, duplicate and incomplete cards carry no listing event. For example, two keywords with `maxItemsPerInput` at 50 is at most one start event plus 100 listing events, plus the platform usage of the job. The live Pricing tab on this page shows the current price of each event, and `maxTotalItems` keeps the listing part predictable.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~flipkart-listings-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["wireless earbuds"], "maxItemsPerInput": 25, "maxTotalItems": 25}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("khadinakbar/flipkart-listings-scraper").call(run_input={
    "searchQueries": ["air purifier"],
    "maxItemsPerInput": 50,
    "sortBy": "popularity",
})
for card in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(card["position"], card["title"][:60], card["currentPrice"], card.get("discountPercent"))
```

### Use with AI agents (MCP)

The Actor is available through [Apify MCP](https://mcp.apify.com) for Claude, ChatGPT, Cursor and other MCP clients. Example prompt:

> Search Flipkart for "wireless earbuds", collect the first 40 listings, and tell me the median price, the three deepest discounts, and how many of the top 10 slots are sponsored.

The agent sends `searchQueries` with `maxItemsPerInput`, reads rows with `get-dataset-items`, and works with `currentPrice`, `discountPercent`, `position` and `isSponsored`. Keep `productUrl`, `sourceUrl` and `scrapedAt` for provenance. For cost and scope, set `maxTotalItems` before starting and read `OUTPUT.outcome` to confirm the outcome.

### Best results

| Starting situation | Helpful action | Expected outcome |
|---|---|---|
| Daily price monitoring | Schedule the same `searchQueries` with a fixed `maxItemsPerInput` | Comparable price and discount snapshots |
| Category tracking | Paste the Flipkart category URL into `listingUrls` | Cards from that exact category |
| Budget-band research | Set `minPrice` and `maxPrice` | Only cards in your price band |
| Cheapest offers first | Use `sortBy: "price_asc"` | Low-price cards at the top |
| Large sweeps | Set `maxTotalItems` as the overall cap | Predictable volume across many inputs |

Rating fields appear when Flipkart shows them on the card; for full ratings and specifications per product, use the product scraper on your shortlist.

### Builder's note

I designed this Actor to stay at the listing-card level: most pricing and ranking questions are answered by the search page itself, and skipping detail pages keeps a wide sweep quick. I bill a card only after its record is validated and stored, and I attach `position`, `page` and `isSponsored` to every row because rank and paid placement matter as much as price on Flipkart.

### FAQ

#### Does it visit each product page?

No. It reads search and category listing pages. Use Flipkart Product Scraper when you want detail-page data.

#### Which country does it target?

Flipkart India, with prices in INR. The default proxy uses residential IPs in India.

#### Can I combine keywords and category URLs?

Yes. Send both `searchQueries` and `listingUrls`; each input gets its own `maxItemsPerInput` cap.

### Responsible use

This Actor collects public Flipkart listing data only and works without logins or orders. Use it for lawful research in line with Flipkart's terms, Apify's terms and applicable laws. Flipkart is a trademark of its owner; this independent Actor is not affiliated with or endorsed by Flipkart.

# Changelog

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

# Actor input Schema

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

Use this when you want to discover products by keyword. Each query is run on Flipkart search, such as 'wireless earbuds' or 'gaming laptop'. You may combine this with listing URLs. The actor returns listing cards only; it does not open every product page for full specifications.

## `listingUrls` (type: `array`):

Use this when you already have a public Flipkart search, category, browse, or collection URL. Each URL is paginated independently. Do not enter product detail URLs containing '/p/'; use the separate Flipkart Product Scraper for product-page details.

## `maxItemsPerInput` (type: `integer`):

Use this when you need a predictable per-query or per-URL budget. The actor stops after this many validated listings for each input. Set a lower value for quick checks and a higher value for catalog exports. Each persisted listing is billed once.

## `maxTotalItems` (type: `integer`):

Use this when several inputs share one run budget. This hard cap applies across all queries and listing URLs, even when their combined per-input limits would be larger. It prevents accidental over-collection and caps per-listing event charges.

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

Use this when you need a pagination safety limit. Flipkart typically shows roughly 24 listing cards per page, but layouts vary. The listing cap normally stops first; this setting bounds requests when cards are filtered or repeated.

## `sortBy` (type: `string`):

Use this when search-query order matters. This setting is applied to generated keyword searches and does not rewrite a supplied listing URL. Choose relevance for Flipkart's default ranking or a price/popularity order for monitoring workflows.

## `minPrice` (type: `integer`):

Use this when you want only listing cards at or above an INR price. Filtering happens after extraction, so the source listing URL and its pagination remain unchanged. Leave empty to keep listings with any displayed price.

## `maxPrice` (type: `integer`):

Use this when you want only listing cards at or below an INR price. This is an actor-side filter rather than a promise that Flipkart's own facets use the same buckets. Leave empty to keep listings with any displayed price.

## `minRating` (type: `number`):

Use this when you only need products meeting a visible average-rating threshold from 0 to 5. Listings without a visible rating do not pass this filter. Leave empty to retain both rated and unrated listings.

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

Use this when you need to override the network route. Flipkart is geo-targeted and frequently challenges datacenter IPs, so this actor defaults to Apify Residential Proxy in India. Keep that default for reliable public listing access.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds",
    "iphone 15 case"
  ],
  "listingUrls": [
    "https://www.flipkart.com/mobiles/pr?sid=tyy,4io"
  ],
  "maxItemsPerInput": 50,
  "maxTotalItems": 500,
  "maxPagesPerInput": 10,
  "sortBy": "price_asc",
  "minPrice": 1000,
  "maxPrice": 5000,
  "minRating": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Validated Flipkart listing records emitted by this run.

## `output` (type: `string`):

Stable OUTPUT key containing the terminal outcome and counts.

## `runSummary` (type: `string`):

RUN_SUMMARY key with safe diagnostics and per-source counters.

# 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": [
        "wireless earbuds"
    ],
    "listingUrls": [],
    "maxItemsPerInput": 50,
    "maxTotalItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/flipkart-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": ["wireless earbuds"],
    "listingUrls": [],
    "maxItemsPerInput": 50,
    "maxTotalItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/flipkart-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": [
    "wireless earbuds"
  ],
  "listingUrls": [],
  "maxItemsPerInput": 50,
  "maxTotalItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call khadinakbar/flipkart-listings-scraper --silent --output-dataset

```

## MCP server setup

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