# Flipkart Product Reviews Scraper (`automation-lab/flipkart-product-reviews-scraper`) Actor

Export individual public Flipkart product reviews with text, ratings, reviewer names, displayed dates, variant attributes, purchase flags and helpful votes from product URLs.

- **URL**: https://apify.com/automation-lab/flipkart-product-reviews-scraper.md
- **Developed by:** [Automation Lab](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

from $0.96 / 1,000 review exporteds

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 Product Reviews Scraper

Turn public **Flipkart product reviews** into a structured customer-feedback dataset. Supply product URLs to export individual review text, titles, star ratings, displayed reviewers and dates, purchase-verification flags, variant attributes and helpfulness counts.

Built for ecommerce analysts, brand teams and researchers who want recurring snapshots for downstream sentiment analysis—not another table of product cards or aggregate ratings. The Actor does not generate sentiment scores, discover products or access private accounts.

### Why use this Actor?

- Keep stable review IDs for comparing separate snapshots.
- Distinguish the requested product from the reviewed variant when Flipkart shares a review feed across colors or storage options.
- Preserve displayed dates rather than inventing exact timestamps.
- Export typed rows to the default Apify dataset for JSON, CSV or Excel downloads.
- Bound collection by a global review limit and a per-product page cap.

### Who is it for?

Brand teams can compare recurring feedback snapshots; ecommerce analysts can group complaints by reviewed variant; researchers can build bounded public-review datasets for downstream analysis. It is not a product search or reviewer-contact tool.

### Getting started

1. Copy a full public Flipkart product URL, including its `pid` query parameter.
2. Paste it into **Flipkart product URLs**.
3. Choose the maximum reviews per run and maximum pages per product.
4. Start the Actor and wait for its terminal status.
5. Open the default dataset and download the required format.

No login, customer API key or proxy subscription is required. Requests run directly without an automatic paid proxy fallback.

### Input example

```json
{
  "startUrls": [{
    "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPNRQA7CS3"
  }],
  "maxItems": 25,
  "maxPagesPerProduct": 3
}
```

### Input parameters

| Parameter | Default | Behavior |
| --- | --- | --- |
| `startUrls` | Required | 1–20 full HTTPS `flipkart.com` or `www.flipkart.com` product or product-reviews URLs with `pid`. Use `{ "url": "..." }` entries in the request list. |
| `maxItems` | 100 | Global maximum unique review rows across all products, in input order. Integer 1–10000. |
| `maxPagesPerProduct` | 10 | Maximum review pages for each normalized product URL. Integer 1–100. |

Zero is invalid, not unlimited. Duplicate normalized input URLs are fetched once. Page size is controlled by Flipkart, currently about ten reviews. Source exhaustion, timeouts or spending limits can yield fewer records than requested.

Extra URL parameters—including filters, sorting and page—are discarded. Collection always begins at page 1 using the source's default helpfulness order. The Actor has no rating/date/text filters or recent-first mode. Short links, search URLs and bare product IDs are not accepted.

### Extracted data

| Field | Meaning |
| --- | --- |
| `reviewId` | Stable source review identifier, deduplicated within the run. |
| `reviewUrl` | Individual source review link. |
| `productId`, `productUrl` | Requested product identity. |
| `reviewProductId` | Reviewed variant identity when exposed in the review link. |
| `title`, `text`, `rating` | Source review headline, body and 1–5 star rating. |
| `reviewer` | Public displayed name or generic customer label. |
| `displayedDate` | Original date label, often month/year; not a precise publication time. |
| `certifiedBuyer`, `verifiedPurchase` | Source flags, not independent verification by this Actor. |
| `helpfulCount`, `unhelpfulCount` | Displayed upvote/downvote counts. |
| `variant` | Array of exposed attribute names and values, such as Color and Storage. |
| `sourceUrl`, `scrapedAt` | Listing page and UTC extraction timestamp. |

Unavailable optional fields are `null`; absent variant attributes produce an empty array. Flipkart can pool reviews across a product family. Do not assume every row describes exactly the requested color or storage capacity. `reviewProductId` and `variant` preserve that distinction.

### Output example

This shortened example follows the current emitted structure; reviewer and review ID are anonymized.

```json
{
  "reviewId": "00000000-0000-4000-8000-000000000001",
  "productId": "MOBGTAGPNRQA7CS3",
  "reviewProductId": "MOBGTAGPE4F2HAW7",
  "title": "Great product",
  "text": "Go for it without any hesitation\nCamera and battery are just awesome",
  "rating": 5,
  "reviewer": "Example Customer",
  "displayedDate": "Apr, 2024",
  "certifiedBuyer": true,
  "verifiedPurchase": true,
  "helpfulCount": 356,
  "unhelpfulCount": 67,
  "variant": [{"name": "Color", "value": "Blue"}, {"name": "Storage", "value": "128 GB"}]
}
```

The full dataset also contains the review URL, product URL, source page and extraction time. The `SUMMARY` key-value record contains saved rows, pages, requests, response bytes, retries and configured limits. It is an operational summary, not a billed review.

### How much does it cost to export Flipkart product reviews?

Pay per event: **$0.0005 per started run**, plus each unique review delivered. No item fee is charged for duplicates, invalid inputs or failed pages. A valid run with no reviews can still incur the start fee.

| Apify Store spend tier | Per review |
| --- | --- |
| FREE | $0.0018308 |
| BRONZE | $0.001592 |
| SILVER | $0.0012418 |
| GOLD / PLATINUM / DIAMOND | $0.0009552 |

At BRONZE, estimates including one start are $0.002092 for one review, $0.01642 for ten, and $0.1597 for 100. At FREE, 100 reviews cost an estimated $0.18358. Spend tiers depend on qualifying aggregate monthly Apify Store spending, not review volume in this Actor. The live pricing panel is authoritative. These are usage estimates, not guaranteed invoices; billing adjustments and refunds can apply.

### Limits and failure behavior

- This is a bounded public snapshot, not a guarantee of every historical review.
- Pages are fetched sequentially. Global deduplication keeps the first occurrence of each review ID; it does not persist across runs.
- A network failure or temporary 429/5xx receives at most one retry. Permanent errors and challenge pages fail clearly, without an empty-success substitute.
- A completely repeated page fails rather than pretending pagination succeeded.
- A failure after some successful pages can leave partial rows and corresponding charges. Check run status before treating an export as complete.
- Public data can change or disappear between pages. The Actor does not translate, infer missing dates, fetch media files, summarize ratings or generate AI content.

### Integrations and recurring datasets

Use Apify schedules to refresh the same input. Store exports in your own warehouse and compare `reviewId` values between runs. Downstream tools can compute sentiment, deduplicate snapshots and group feedback by `reviewProductId` or `variant`. The Actor itself does not retain cross-run state, send alerts or identify only-new reviews.

Connect the dataset to Make, Zapier or a spreadsheet workflow after checking terminal success. For large exports, process full files outside an LLM context. Keep personal data access limited to the intended research team.

### API usage

Set `APIFY_TOKEN` in your own secure environment. Never put it in a shared URL or source file.

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  'https://api.apify.com/v2/acts/automation-lab~flipkart-product-reviews-scraper/runs' \
  --data @input.json
```

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-reviews-scraper').call(input);
if (run.status !== 'SUCCEEDED') throw new Error(`Partial/failed export: ${run.id}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/flipkart-product-reviews-scraper').call(run_input=actor_input)
if run['status'] != 'SUCCEEDED':
    raise RuntimeError('Export did not finish successfully: ' + run['id'])
rows = client.dataset(run['defaultDatasetId']).list_items(limit=25).items
```

For asynchronous starts, retain the returned run ID and inspect that same run until terminal. A run object is metadata, not review rows.

### MCP setup

For Claude Code:

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

Claude Desktop, Cursor and VS Code configuration (for clients supporting remote HTTP MCP):

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

Authenticate using the client's supported Apify authorization flow. This scoped endpoint selects this Actor and supporting run/data tools, not exactly one tool. Discover actual names and schemas with read-only `tools/list` before invocation.

Example prompt: “Export at most 25 public reviews from this full Flipkart product URL. Show ratings, review text and variant context. Do not generate sentiment labels.”

Start once and retain the run/status/storage IDs. If using `call-actor`, choose `waitSecs` within 0–45 seconds and set client timeout above that wait plus transport margin. If still running, poll `get-actor-run` for the same ID with 2/4/8-second backoff capped at 10 seconds and a 120-second overall deadline. On timeout, check the known run instead of restarting; if its ID is unknown, report uncertainty. At the deadline, report pending and stop.

After success, use `get-dataset-items` with explicit dataset ID, offset, limit and needed fields. Example consumer budget: pages of 20 untransformed source rows, at most 100 rows and 64 KiB serialized UTF-8 admitted to model context. Enforce byte limits host-side, disclose omitted/oversized rows, track source offsets and report continuation offset when truncated. If the client cannot intercept oversized responses, do not claim a hard byte guarantee. Full exports remain in storage. Discovery/cache behavior depends on the client; no numeric token savings are promised.

### Legality

Use public review data only for purposes permitted by applicable law and source terms. You remain responsible for your use and downstream processing. This is not legal advice or permission to bypass access restrictions.

### Privacy, retention and responsible use

Only public product review data is collected. Displayed reviewer names can be personal data; collect only for a lawful purpose, respect source terms and applicable law, and avoid profiling sensitive traits or contacting reviewers. This Actor is not affiliated with or endorsed by Flipkart or Apify. It uses Apify's standard user terms, with no additional end-user terms.

The Actor uses no AI at runtime and sends no review dataset to a model provider. Apify hosts inputs, datasets, run logs and summary records under your account's retention settings; the Actor does not create a private historical cache or fixed global dataset. Delete run storage through Apify when it is no longer needed, and separately delete downloaded/downstream copies. Account backups can follow platform retention policies.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. Successful review bodies and reviewer names are not logged or included in deliberate diagnostic payloads. Diagnostic records are separate from your Apify dataset deletion.

### Troubleshooting and FAQ

**Why are there fewer reviews than `maxItems`?** The page cap, available public reviews, spending cap or upstream coverage may be smaller. Raise the page cap only when more pages are needed.

**Why does a Black product show Blue reviews?** Flipkart shares review feeds across variants. Check `reviewProductId` and `variant`; this is not a claim that all reviews match the requested variant.

**Can I get only recent reviews or filter by rating?** Not in this version. Extra source URL parameters do not activate filters. Filter exported rows downstream, understanding that the snapshot starts in default helpfulness order.

**What does a blocked-page error mean?** The source did not return recognizable public review data. Check the full URL and retry later; repeated failures should be reported through the Actor's Apify Issues tab with a run link and a non-sensitive input example.

### Related workflows and support

This is a standalone Flipkart review dataset tool, not a product-listing scraper. Pair it with your existing product inventory and analytics pipeline; no additional Actor is required. Report bugs through the Apify Issues tab. Do not submit credentials, cookies or private customer data in a public issue.

# Changelog

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

# Actor input Schema

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

Supply 1–20 full HTTPS flipkart.com product or product-reviews URLs including pid. Duplicate normalized URLs are fetched once. Other query parameters, including sorting, filters and starting page, are discarded; extraction starts at page 1 in source default order. Short links and search URLs are not supported.

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

Global cap on unique review rows across all products in input order, after deduplication by review ID. Default 100; range 1–10000. Zero is invalid. Source exhaustion, per-product page cap, timeout or spending limits may yield fewer rows. Not a guarantee of complete historical coverage.

## `maxPagesPerProduct` (type: `integer`):

Fetch at most this many review pages for each unique product URL, starting at page 1. Default 10; range 1–100. Stops earlier at source exhaustion or the global maxItems cap. Pages currently contain about ten reviews; counts may vary. Zero is invalid.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPNRQA7CS3"
    }
  ],
  "maxItems": 20,
  "maxPagesPerProduct": 3
}
```

# Actor output Schema

## `reviews` (type: `string`):

Default dataset containing unique review records.

## `summary` (type: `string`):

Saved reviews, fetched pages, requests, bytes and retries.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPNRQA7CS3"
        }
    ],
    "maxItems": 20,
    "maxPagesPerProduct": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flipkart-product-reviews-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 = {
    "startUrls": [{ "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPNRQA7CS3" }],
    "maxItems": 20,
    "maxPagesPerProduct": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flipkart-product-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4?pid=MOBGTAGPNRQA7CS3"
    }
  ],
  "maxItems": 20,
  "maxPagesPerProduct": 3
}' |
apify call automation-lab/flipkart-product-reviews-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-reviews-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/zroaUnKsbL74Hii5U/builds/AmTdNAwUyKNQPMpAs/openapi.json