# Flipkart Scraper — Prices, Discounts & Price Drops in India (`northbell/flipkart-scraper`) Actor

Scrape Flipkart search and category results: price, MRP, discount, rating, ratings count, stock, F-Assured and sponsored flags for every product. Run it again or on a schedule for price drops, rank changes and new products since the last run. Search words or Flipkart URLs. No login.

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

## Pricing

from $0.80 / 1,000 products

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 — Prices, Discounts & Price Drops

Give it search words or Flipkart list URLs and get one clean row per product: **price, MRP, discount %, rating, ratings count, stock, F-Assured and sponsored flags**, image and link, in the order Flipkart lists them. **$1 per 1,000 products**, up to 1,000 products per search, no login, no API key.

Run it again — or put it on a daily schedule — and every row also tells you **what changed since the last run**: the **previous price and the change**, the **lowest price seen so far**, **rank moves** and **new products**.

### What you get

One row per product (`type: "product"`):

| Field | What it is |
|---|---|
| `search`, `sort`, `rank`, `page` | which search found it, the order used, its position in that order (sponsored slots count) and the page it came from |
| `productId`, `url`, `title`, `brand`, `imageUrl` | the product. `brand` is filled when Flipkart's card carries it (see Notes) |
| `price`, `mrp`, `discountPct`, `currency` | selling price in whole rupees, the struck-through list price (MRP), the discount % as Flipkart shows it (it rounds down), `INR` |
| `rating`, `ratingsCount`, `reviewsCount` | average stars, number of ratings, number of written reviews. Counts only: no reviewer names or review texts. `rating` is empty (not 0) for products with no ratings yet |
| `inStock` | `true` when Flipkart lets you buy it, `false` when it is out of stock, unavailable or coming soon |
| `isAssured`, `isSponsored` | has the F-Assured badge (`null` when the page Flipkart sent carried no badge data for that card, see Notes); is shown as a paid placement in the list |
| `keySpecs`, `tags` | headline specs where Flipkart lists them (mostly electronics and appliances) and the card's tags such as "Bank Offer", "Only 3 left" or "Lowest price in the year" |
| `previousPrice`, `priceChange`, `priceChangePct`, `lowestPriceSeen` | price in your previous run, the change (negative = cheaper), the change in %, and the lowest price this Actor has seen for the product |
| `previousRank`, `rankChange`, `isNew` | rank in your previous run, `rankChange` (positive = moved up), and `true` when the product was not in the earlier results |
| `observedAt` | when it was read (ISO time) |

On the first run the change fields (`previousPrice`, `priceChange`, `priceChangePct`, `previousRank`, `rankChange`, `isNew`) are `null` and `lowestPriceSeen` is the current price.

One free **summary row** per search (`type: "summary"`): `productsReturned`, `pagesRead`, `totalResultsOnFlipkart` (the count Flipkart reports), `sponsoredProducts`, `duplicatesSkipped`, `pagesRefetched`, `newProducts`, `priceDrops`, `priceRises`, `droppedOut` (products from the last run that are no longer in the results; `null` when this run did not read as far as the last one), `stoppedBecause` (`limit`, `end-of-results`, `no-results` or `error`), `previousRunAt`, `searchUrl`.

### Run it again and again

- **On a schedule** — save your input as a task and add a **Schedule**: the same searches every day. Send each run to Google Sheets, Slack or email with an integration on the task.
- **Watch for changes** — Keep the same input on the schedule. Each run is its own dataset with the date it ran, so the series builds up run by run and you can compare one day with the last.
- **In bulk** — Put every search in **Searches** in one run.

### Use it for

- **Price-drop and deal tracking** — schedule it daily and keep the rows where `priceChange` is below 0, or where `price` equals `lowestPriceSeen`
- **New arrivals** — sort by newest and keep `isNew: true`
- **Category and competitor research** — discount depth, F-Assured share, ratings counts and brands for any search or category list
- **Reselling and sourcing** — compare selling price with MRP across a whole category

### Input

```json
{
  "searches": ["iphone 15", "running shoes", "https://www.flipkart.com/mobiles/pr?sid=tyy%2C4io"],
  "maxProductsPerSearch": 100,
  "sort": "price_low_to_high"
}
```

- `searches` — words or phrases, or Flipkart list URLs: a search URL (`flipkart.com/search?q=…`) or a category list (`flipkart.com/…/pr?sid=…`). Product page URLs are refused with a message.
- `maxProductsPerSearch` — 1 to 1000, default 100.
- `sort` — `relevance` (default), `popularity`, `price_low_to_high`, `price_high_to_low` or `newest`.
- `readProductPages` — off by default and rarely needed. Turn it on to open the product page of every product that still has no rating data after the list was read (see Notes).

The previous run's prices and ranks are kept per search and sort in a named key-value store in your Apify account, so the second run of the same search already shows changes. The store also holds the anonymous visitor cookie Flipkart gave the Actor for that search (see Notes). Schedule it (Apify → Schedules) for a daily history.

### Pricing

**$1 per 1,000 products**, plus $0.01 per run. Error rows and the per-search summary rows are free. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

All numbers below were measured on 9 October 2026 (JST) with this Actor, 200 products per search unless stated.

- Public data only: what any visitor sees on flipkart.com without signing in. The Actor does not set a delivery PIN code. It never returns reviewer names or review texts. **Flipkart is India-only**, so there is no country or language setting; prices are in rupees.
- **Stock depends on location for groceries.** For "fresh vegetables" 199 of 200 results said "Currently unavailable" (`inStock: false`) with no PIN set. Flipkart also lists out-of-stock products in ordinary searches: 127 of the first 200 "iphone 15" results were unavailable, nearly all on pages 4 to 10.
- **Flipkart sends some visitors a thinner list.** The same page fetched 8 times without cookies gave full cards twice and thin cards six times (T-shirt page 1). Thin cards have no rating, stock, F-Assured, brand or key specs. The Actor keeps Flipkart's anonymous visitor cookie, and when a page comes back thin it asks again with a new cookie, up to 6 times per search (`pagesRefetched` in the summary says how often). Result: a rating on 182 of 200 T-shirts, 184 watches, 189 shoes, 195 books and 190 sofas. Without this, repeated runs gave a rating on 5 to 45 of 200 T-shirts and 0 to 88 of 200 watches. If every try is thin, `rating`, `ratingsCount`, `reviewsCount`, `keySpecs` and `isAssured` stay empty (`isAssured` is `null`, not `false`) and `inStock` comes from whether Flipkart lets you buy the product. Then `readProductPages` can fill rating, counts and stock from the product pages (about one extra second per product).
- **The order is more stable when the same visitor cookie is used**, so the Actor saves the cookie with each search's previous results and sends it again next time. For "wireless earbuds" in relevance order, 77 of 80 results kept the same rank 20 seconds later with the same cookie and 13 of 80 with a new one. It is still not exact: in two repeat runs 15 seconds apart (60 products per search, relevance order, three searches) 26 to 55 products per search kept their exact rank, and 1 to 4 per search were flagged `isNew` within those seconds. Read `isNew` as "was not in the list last time", not "just launched". `priceChange` compares the same product and is not affected. Price order shuffles products with equal prices: for "wireless earbuds" sorted by price only 29 of 80 kept their rank 20 seconds later, though 79 of 80 were the same products.
- **About 1,000 products per search at most.** "mobile cover" sorted by newest: 25 pages of 40 cards = 1,000 cards (932 different products), page 26 empty. "laptop" sorted by price: 41 pages of 24 = 984 cards (913 different products).
- **Flipkart repeats products across pages.** In relevance order the same sponsored placements come back on every page: for "watch", pages 2 to 6 each repeated 14 to 25 of their 40 cards, and 14 to 16 of those were sponsored. The Actor keeps each product once, at its first position (`duplicatesSkipped` counts the repeats: about 30 per 200 products for "iphone 15" and 110 to 175 for most other searches I tried), so reading 200 products took 7 to 16 pages, and a search may return fewer products than you asked for.
- **`isNew` and `droppedOut` compare with your previous run of the same search and sort.** If you raise `maxProductsPerSearch`, products beyond the earlier range get `isNew: null` (unknown) instead of `true`; a run with a lower limit replaces the saved range with its own. A run that stops early with an error does not replace the saved results unless it read at least as many products as the earlier one.
- **Some fields are only filled in some cases.** `mrp` is empty when Flipkart shows no struck-through price (13 or 14 of 200 "iphone 15" results had one, 6 of 200 "fresh vegetables"; 190 or more of 200 for laptops, washing machines and books). `brand` is empty when the card has no brand field: filled for all 200 "iphone 15", "mobile cover", "washing machine", "tshirt", "watch" and "books", none of 200 "laptop" in my last run (0 to 64 in four runs), 3 of 200 "fresh vegetables"; the `title` normally starts with the brand. `keySpecs` was filled for all 200 results of "laptop", "washing machine", "iphone 15", "tshirt", "watch" and "books", for none of "fresh vegetables", and for 0 and 40 of 200 "mobile cover" in two runs. `tags` is empty when the card has none.
- **`isSponsored`** marks the list's paid placements (none in "iphone 15", 21 to 32 of 200 T-shirts and 18 to 32 of 200 watches across my runs). They keep their position in `rank`.
- **Flipkart widens searches it does not understand:** the made-up word "asdfqwerzxcv" still returned over 4,000 results, so check `title` when a search is vague.
- If Flipkart answers with its bot-check page, the Actor stops, returns a free error row for the search and the ones it did not read, and does not try to get around it. Five searches of 200 products (1,000 rows, 45 pages) took 67 seconds.

To track **Shopify stores** the same way — prices, new products and sold-out items — see [Shopify Store Products & Price Tracker](https://apify.com/northbell/shopify-store-products-tracker).

### For AI agents

`{"searches": ["iphone 15"], "maxProductsPerSearch": 5}` returns the first 5 Flipkart products for "iphone 15" with price, MRP, discount, rating and stock, plus one summary row. Rows have `type`: `product`, `summary` or `error`. Only `product` rows are charged.

# Actor input Schema

## `searches` (type: `array`):

One per line: a search word or phrase (iphone 15, running shoes) or a Flipkart list URL (flipkart.com/search?q=… or a category list like flipkart.com/mobiles/pr?sid=…). Product page URLs are not accepted here.

## `maxProductsPerSearch` (type: `integer`):

How many products to read for each search, in the order Flipkart lists them. Flipkart serves about 1,000 products per search at most, so 1000 is the highest useful value.

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

The order Flipkart lists the products in. Use a price or newest order for tracking: Flipkart's relevance order moves around between requests.

## `readProductPages` (type: `boolean`):

Usually not needed: the Actor already asks Flipkart again when a list page comes back without ratings or stock. Turn this on to open the product page of every product that still has no rating data and fill in rating, ratings count and stock. Slower: about one extra second per product.

## Actor input object example

```json
{
  "searches": [
    "iphone 15"
  ],
  "maxProductsPerSearch": 100,
  "sort": "relevance",
  "readProductPages": false
}
```

# Actor output Schema

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

Prices, discounts, ratings and stock, with price and rank changes since the last run.

## `searches` (type: `string`):

One summary row per search: products read, Flipkart's result count, new products and price drops since the last run.

# 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 = {
    "searches": [
        "iphone 15"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/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 = { "searches": ["iphone 15"] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/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 '{
  "searches": [
    "iphone 15"
  ]
}' |
apify call northbell/flipkart-scraper --silent --output-dataset

```

## MCP server setup

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