# Flipkart Product Extractor (`kawsar/flipkart-product-extractor`) Actor

Flipkart product scraper that extracts prices, ratings, specs, and images from any search keyword or URL, so you can monitor deals and build clean product data in minutes.

- **URL**: https://apify.com/kawsar/flipkart-product-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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?

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 Extractor

Extract Flipkart product data at scale. Type a keyword like `smartphone`, `laptop`, or `running shoes`, and this actor returns every matching product from Flipkart search results, with the product name, brand, current and original price, discount, rating, key specifications, images, and a direct link to each product page. You can also paste a full Flipkart search URL and pull that whole listing.

Built for price monitoring, product research, catalog building, and SEO work. No login, no browser extension, no manual copy pasting.

### Table of contents

- [Why use this actor](#why-use-this-actor)
- [Features](#features)
- [How it works](#how-it-works)
- [Input](#input)
- [Output](#output)
- [Use cases](#use-cases)
- [Integrations and export](#integrations-and-export)
- [Running the actor](#running-the-actor)
- [Tips for better results](#tips-for-better-results)
- [FAQ](#faq)
- [Limitations](#limitations)
- [Support](#support)

### Why use this actor

Collecting Flipkart product data by hand is slow. Prices change, stock moves, and new models show up every day. This actor turns any Flipkart search into a clean, structured dataset in seconds, so you can track what matters instead of clicking through pages.

- Search by keyword or by Flipkart URL
- Pull multiple result pages in a single run
- Structured fields ready for a spreadsheet, database, or API
- Runs on a schedule so your data stays current
- No account, cookies, or manual setup required

### Features

| Feature | Description |
|---------|-------------|
| Keyword search | Pass one or more keywords and get every matching Flipkart product. |
| URL scraping | Paste a Flipkart search URL to extract that listing. |
| Multi page | Fetch several result pages per keyword to build larger datasets. |
| Full pricing data | Current price, original price (MRP), and discount percentage. |
| Ratings and reviews | Average rating, rating count, and review count for each product. |
| Key specifications | The highlight specs Flipkart shows on each product card. |
| Product images | Full resolution image URLs for every product. |
| Direct links | A clean link to every product detail page. |
| Batch input | Queue multiple searches and URLs in a single run. |
| Deduplication | Repeated products within a search are removed automatically. |

### How it works

1. You provide search keywords, Flipkart URLs, or both.
2. For each keyword, the actor builds the matching Flipkart search page and loads it.
3. It reads the product data embedded in the page and shapes it into clean records.
4. Each product is saved to the dataset, ready to view, export, or pipe into another tool.

Every search runs independently, so if one keyword fails, the rest of the run still finishes.

### Input

Configure the run from the Apify Console UI, or pass a JSON input through the API. All fields are optional on their own, but you need at least one keyword or one URL.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | array of text | `["smartphone"]` | Flipkart search keywords, one search per keyword. Example: `smartphone`, `laptop`, `headphones`. |
| `startUrls` | array of URLs | none | Optional full Flipkart search URLs, for example `https://www.flipkart.com/search?q=laptop`. |
| `maxItems` | integer | `20` | Maximum number of products to collect per run. The actor pages through the results automatically until it reaches this many. Range 1 to 1000. |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout in seconds. Range 5 to 120. |

#### Example input

Search by keyword:

```json
{
    "searchQueries": ["smartphone", "laptop"],
    "maxItems": 100
}
```

Scrape a specific Flipkart search page:

```json
{
    "startUrls": [
        { "url": "https://www.flipkart.com/search?q=headphones" }
    ],
    "maxItems": 200
}
```

Combine both:

```json
{
    "searchQueries": ["gaming laptop"],
    "startUrls": [
        { "url": "https://www.flipkart.com/search?q=smartwatch" }
    ],
    "maxItems": 500
}
```

### Output

Results are stored in the run's dataset. Each item is one product.

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The keyword or URL this product came from. |
| `productName` | string | Full product name. |
| `shortName` | string | Shorter display name Flipkart shows on the card. |
| `subtitle` | string | Secondary detail, for example "8 GB RAM" for devices or "Size: 32" for fashion. |
| `brand` | string | Brand name. Taken from the Flipkart brand label, or the leading word of the title when no label is set. |
| `productId` | string | Flipkart product identifier. |
| `listingId` | string | Flipkart listing identifier. |
| `category` | string | Product category, for example `mobile`. |
| `currency` | string | Currency code for the prices, for example `INR`. |
| `currentPrice` | number | Current selling price. |
| `originalPrice` | number | Original list price (MRP) before discount. |
| `discountPercentage` | number | Discount percentage off the MRP. |
| `discountAmount` | number | Absolute discount value when available. |
| `rating` | number | Average customer rating out of 5. `null` when the product has no ratings yet. |
| `ratingCount` | number | Number of ratings, or `null` when none. |
| `reviewCount` | number | Number of written reviews, or `null` when none. |
| `keySpecs` | array | Highlight specifications from the product card. Present for devices, empty for most fashion items. |
| `warranty` | string | Warranty summary when available. |
| `availability` | string | Stock state, for example `IN_STOCK`. |
| `imageUrl` | string | Primary product image URL. |
| `images` | array | All product image URLs. |
| `productUrl` | string | Direct link to the Flipkart product page. |
| `scrapedAt` | string | ISO timestamp of when the product was scraped. |

#### Example output item

```json
{
    "searchQuery": "smartphone",
    "productName": "Tecno Pova 8 Pro 5G (Arc White, 256 GB)",
    "shortName": "Pova 8 Pro 5G (Arc White, 256 GB)",
    "subtitle": "8 GB RAM",
    "brand": "Tecno",
    "productId": "MOBHQFDZTHKKVGKG",
    "listingId": "LSTMOBHQFDZTHKKVGKGEJNJSP",
    "category": "mobile",
    "currency": "INR",
    "currentPrice": 49999,
    "originalPrice": 59999,
    "discountPercentage": 16,
    "discountAmount": 10000,
    "rating": 4.5,
    "ratingCount": 1200,
    "reviewCount": 98,
    "keySpecs": [
        "8 GB RAM | 256 GB ROM",
        "17.22 cm (6.78 inch) Display",
        "50MP + 8MP | 13MP Front Camera",
        "6500 mAh Lithium Polymer Battery",
        "Dimensity 7400 Processor"
    ],
    "warranty": "1 Year Manufacturer Warranty for Phone",
    "availability": "IN_STOCK",
    "imageUrl": "https://rukmini1.flixcart.com/image/832/832/xif0q/mobile/-original-imahqdc3gzjbz5gj.jpeg?q=70",
    "images": [
        "https://rukmini1.flixcart.com/image/832/832/xif0q/mobile/-original-imahqdc3gzjbz5gj.jpeg?q=70"
    ],
    "productUrl": "https://www.flipkart.com/tecno-pova-8-pro-5g-arc-white-256-gb/p/itmff783095ed31c?pid=MOBHQFDZTHKKVGKG",
    "scrapedAt": "2026-08-27T10:24:01.902977+00:00"
}
```

### Use cases

- **Price monitoring.** Run the actor on a schedule and watch how prices and discounts move across a product line.
- **Product research.** Pull full search results to compare specs, ratings, and prices across brands.
- **Catalog building.** Feed a store, affiliate site, or price comparison tool with fresh product data.
- **SEO and market research.** Gather names, specs, and prices for keyword and trend analysis.
- **Deal and coupon sites.** Surface products with the biggest discounts and rank them by savings.
- **Review analysis.** Track rating and review counts to spot popular and trending products.

### Integrations and export

Everything the actor collects can leave Apify in the format you need.

- Export to JSON, CSV, Excel, XML, or RSS from the dataset tab
- Send results to Google Sheets, Airtable, or a database
- Trigger webhooks when a run finishes
- Connect to Make, Zapier, and other automation tools
- Pull results programmatically through the Apify API and client libraries

Fetch the dataset through the API:

```
GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json
```

### Running the actor

#### From the Apify Console

1. Open the actor and go to the Input tab.
2. Add one or more keywords under `searchQueries`, or paste Flipkart URLs under `startUrls`.
3. Set `maxItems` to size the result set. The actor pages through the results automatically until it reaches that number.
4. Click Start and watch the log. Results appear in the Dataset tab.

#### On a schedule

Use the Schedules tab to run the actor every hour, day, or week. This keeps a rolling record of prices and new products with no manual work.

#### Through the API

Start a run and get results in one call using the Apify API or one of the official clients for Python and JavaScript. See the API tab of the actor for ready to copy snippets.

### Tips for better results

- Use specific keywords like `iphone 15` or `gaming laptop` to narrow the results.
- Use broad keywords like `mobile` or `shoes` to pull large catalogs.
- Raise `maxItems` when you need more results. The actor pages through Flipkart automatically to reach it.
- To scrape a filtered or sorted listing, copy the URL straight from your browser after filtering on flipkart.com.
- Schedule short, frequent runs rather than one huge run if you are tracking price changes over time.

### FAQ

**Do I need a Flipkart account?**
No. The actor works with public Flipkart search and product pages.

**How many products can I get from one search?**
Flipkart shows about 24 products per page, and the actor keeps paging through them automatically until it reaches your `maxItems` cap.

**Can I scrape a specific category or filtered page?**
Yes. Paste the full Flipkart search URL into `startUrls` and the actor reads that listing.

**What currency are the prices in?**
Flipkart is an India storefront, so prices are in Indian Rupees (`INR`).

**Why do some fashion products have empty rating or specs fields?**
The actor returns what Flipkart shows for each product. Devices like phones and laptops carry ratings and spec highlights on every card. Many fashion items, especially new listings, have no ratings or spec bullets yet, so those fields come back empty. Fields that do exist, like name, brand, price, and images, are always filled.

**Can I get seller or full specification detail?**
This actor focuses on product listing data. Deep per product detail like every seller and full spec sheet is not included.

**Is my input private?**
Yes. Runs and datasets are tied to your Apify account and are not shared.

### Limitations

- Results reflect what Flipkart shows on its public search pages at run time.
- Flipkart returns about 24 products per page; raise `maxItems` for larger sets and the actor pages through automatically.
- Per product seller lists and full specification sheets are out of scope for this actor.
- Very broad keywords may return unrelated products. Refine the keyword for cleaner results.

### Support

Found a bug or want a new field added? Open an issue on the actor page or contact the developer through Apify. Feature requests are welcome.

# Actor input Schema

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

Product keywords to search on Flipkart. Each keyword returns a page of matching products, for example "smartphone" or "running shoes".

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

Full Flipkart search URLs to extract products from. Use this to target a specific category, filter, or sorted result page.

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

Maximum number of products to save per run. The actor pages through the results automatically until it reaches this many products.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQueries": [
    "smartphone",
    "laptop"
  ],
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Extract Flipkart product listings, prices, ratings, specs, and images from any search keyword or search URL.

# 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": [
        "smartphone"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/flipkart-product-extractor").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": ["smartphone"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/flipkart-product-extractor").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": [
    "smartphone"
  ]
}' |
apify call kawsar/flipkart-product-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/flipkart-product-extractor"
        }
    }
}

```

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/M3Ou2wfLLyVDVvUKm/builds/zmJD7yxEHrre41ihy/openapi.json