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

Collect Flipkart product reviews with ratings, text, authors, dates, helpful votes and certified-buyer flags. Paste links or IDs, pick helpful, recent, positive or negative order.

- **URL**: https://apify.com/apt\_marble/flipkart-product-reviews-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 reviews

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?

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

Collect every written review for any Flipkart product — text, rating, author, date, helpful votes, certified-buyer flag and variant info — in the order you choose: most helpful, most recent, positive first or negative first. Paste product links or bare product IDs and get back a clean row for each review, ready for sentiment analysis, competitor monitoring or voice-of-customer research. Built for anyone who needs Flipkart's customer feedback as data: brands tracking what shoppers say, sellers watching rivals, analysts mining real shopper language and teams feeding review text into topic or sentiment models.

### What you can do with it

- **Mine customer language** — pull the review text, titles and star rating for any product in one dataset, ready for analysis.
- **Isolate complaints or praise** — sort positive-first or negative-first to surface what delights or frustrates buyers first.
- **Monitor a product over time** — sort by most recent and schedule the actor to catch fresh feedback as it appears.
- **Read Flipkart the way shoppers do** — every row carries the review date, helpful votes, whether it was a certified purchase and the variant the reviewer bought.
- **Reuse a link you already have** — paste full Flipkart product addresses or just the product ID; mixed together in the same list is fine.
- **Cap the volume per product** — set the maximum reviews per product and the actor stops paging as soon as the cap is reached.

### What you get

One row per review. Abridged sample of a single review:

```json
{
  "reviewId": "fk-MOBGTAGQ-p1-i0",
  "productId": "MOBGTAGQ",
  "productTitle": "Apple iPhone 15 (Blue, 128 GB)",
  "rating": 5,
  "title": "Excellent phone",
  "text": "Superb camera and battery life. Delivery was quick and the product was sealed.",
  "author": "Rahul S.",
  "date": "2024-03-15T00:00:00.000Z",
  "helpfulCount": 42,
  "certifiedBuyer": true,
  "variantInfo": "Color: Blue, Storage: 128 GB",
  "images": ["https://rukminim1.flixcart.com/blobio/612/612/imr/blobio-imr_abc123.jpg?q=70"]
}
```

`date` is an ISO timestamp when the original wording can be parsed. Flipkart usually states review age relatively ("3 months ago"), which is converted against the run date and so is approximate to that granularity. When a date cannot be parsed, `date` is empty. Where a review omits a field the actor leaves it empty rather than guessing.

### Input reference

| Setting | Type | Default | What it does |
| --- | --- | --- | --- |
| Product links | list of text | — | Flipkart product links whose reviews you want (flipkart.com/.../p/itm...?pid=...). Mixed with bare IDs is fine. |
| Product IDs | list of text | — | Alias for the links above: bare product IDs or full links. Combined into one de-duplicated product list. |
| Maximum reviews per product | whole number | `50` | Stop after this many reviews per product. Products with fewer reviews simply return what exists. Maximum 2,000. |
| Review order | choice | `helpful` | `helpful` (most helpful first), `recent` (newest first), `positive` (praise first), or `negative` (complaints first). |

Provide at least one product link or ID; the actor reads each product's review listing in the order you chose.

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `reviewId` | text | The review's stable identifier. |
| `productId` | text | Flipkart's product ID the review belongs to. |
| `productTitle` | text | Product title as published, when available on the page. |
| `rating` | number | Stars given, 1 to 5. |
| `title` | text | Review headline / title. |
| `text` | text | Full review body. |
| `author` | text | Who wrote it, as Flipkart publishes it. |
| `date` | text | ISO timestamp parsed from Flipkart's date; empty when the wording cannot be parsed. |
| `helpfulCount` | number | How many shoppers found the review helpful. |
| `certifiedBuyer` | true/false | Whether Flipkart marks it as a certified purchase. |
| `variantInfo` | text | Variant the reviewer bought (color, size, storage), when shown. |
| `images` | list of text | Customer-uploaded review photos, when the review has any; empty otherwise. |

### Example use cases

- **Brand listening** — pull recent reviews for your products weekly and track what buyers praise or complain about.
- **Complaint triage** — sort negative-first to surface one-star problems before they spread.
- **Launch watch** — schedule most-recent reads after a launch and catch fresh feedback daily.
- **Competitor comparison** — collect helpful-first reviews for rival products and compare recurring themes.
- **Review corpus** — export up to 2,000 reviews per product with ratings and dates for sentiment or topic models.

### Pricing

You pay per result, with no monthly minimum.

| What you are charged for | Price |
| --- | --- |
| Review — one review added to your dataset | **$2.50 per 1,000** |

**Worked example.** A run over 5 products collecting 200 reviews each is 1,000 review rows: 1,000 × $0.0025 = **$1.00**. A quick check collecting 100 reviews costs about **$0.25**. A daily watch collecting 50 reviews is about $0.13 per run, roughly $3.75 a month.

### Limits & what this actor cannot do

- Ratings, review ordering and availability are a snapshot at the moment of collection and keep changing afterwards.
- Only written reviews Flipkart publishes openly are returned. Star-only ratings without review text do not produce a review row.
- There is a practical ceiling per product imposed by what Flipkart will actually serve; the actor stops when the reviews run out rather than inventing more.
- Where a review omits a field the actor leaves it empty rather than guessing.
- Dead or removed products produce no rows and are reported in the run summary rather than charged.
- Speed depends on the size of the job and on Flipkart's own response times; no fixed throughput is promised.
- Flipkart's terms govern automated access. You are responsible for using the data lawfully and in line with the source site's terms, and for handling any personal data in line with applicable privacy law.

### FAQ

**Do I need a Flipkart account?**
No. The actor reads only what Flipkart shows the public on its product and review pages.

**Does it need my login or password?**
No. There is nothing to connect and nothing to configure — enter a product link or ID and press start.

**Can I paste a product link I already have?**
Yes. Paste any Flipkart link that contains `/p/` and a product id, or a `pid=` value. A bare product ID works too.

**How many reviews can I get per product?**
Up to 2,000 per product in one run. Flipkart stops serving sooner when the product has fewer, so the actor stops when the reviews run out.

**How does sorting work?**
Most helpful is Flipkart's default ranking. Most recent surfaces fresh feedback first. Positive and negative surface praise or complaints. The option sets the order sent to each review page.

**What if a product has no reviews?**
It is reported as an empty product in the run summary and costs nothing — no review rows are added.

**Can I schedule it?**
Yes. Schedule it hourly, daily or weekly from the Apify console, and each run writes a fresh dataset you can compare against the last — ideal for tracking new feedback over time.

**Is the data complete?**
It is complete for what Flipkart publishes openly on its review pages. Where a page omits a field the actor leaves it empty rather than guessing, and it reports exactly the review rows Flipkart actually serves rather than an estimated total.

# Actor input Schema

## `urls` (type: `array`):

Flipkart product links whose reviews you want, e.g. https://www.flipkart.com/.../p/itm...?pid=.... Mixed with bare product IDs is fine.

## `productIds` (type: `array`):

Alias for product links: bare Flipkart product IDs (pid values like MOBGTAGQ...) or full links. Combined with the links above; duplicates are collected once.

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

Stop after this many reviews per product. Products with fewer reviews simply return what exists.

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

The order reviews are collected in. Use recent to monitor fresh feedback.

## Actor input object example

```json
{
  "urls": [
    "https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm...?pid=MOBGTAGQ..."
  ],
  "productIds": [],
  "maxItems": 50,
  "sort": "helpful"
}
```

# Actor output Schema

## `results` (type: `string`):

Every row this run produced.

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

What this run collected, and anything it could not read.

# 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 = {
    "urls": [
        "https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm...?pid=MOBGTAGQ..."
    ],
    "productIds": [],
    "maxItems": 50,
    "sort": "helpful"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/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 = {
    "urls": ["https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm...?pid=MOBGTAGQ..."],
    "productIds": [],
    "maxItems": 50,
    "sort": "helpful",
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/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 '{
  "urls": [
    "https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm...?pid=MOBGTAGQ..."
  ],
  "productIds": [],
  "maxItems": 50,
  "sort": "helpful"
}' |
apify call apt_marble/flipkart-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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