# Flipkart Products Scraper (`fetch_cat/flipkart-products-scraper`) Actor

Scrape Flipkart product listings for prices, discounts, ratings, availability, offers, images, product IDs, and seller/catalog data.

- **URL**: https://apify.com/fetch\_cat/flipkart-products-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.44 / 1,000 item extracteds

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/platform/actors/running/actors-in-store#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 Products Scraper

Scrape Flipkart product search results and product pages for ecommerce monitoring, price tracking, catalog research, and marketplace analysis. The Actor exports structured Flipkart product rows with prices, discounts, ratings, availability, product URLs, images, and scrape status so you can analyze marketplace data in JSON, CSV, Excel, or through the Apify API.

### What does this Flipkart scraper do?

This Actor accepts Flipkart search terms, direct Flipkart product URLs, or both. It visits the public Flipkart pages, extracts product listing and product-page signals, and saves normalized product records to the default dataset. Use it when you need repeatable Flipkart product data without building your own crawler, proxy handling, output schema, or Apify integration.

### Who is it for?

- Ecommerce analysts tracking Flipkart prices, discounts, ratings, and availability.
- Marketplace sellers researching competing products and category positioning.
- Retail teams monitoring catalog coverage and product detail changes.
- Agencies building dashboards or alerts for Indian ecommerce categories.
- Developers who need a structured Flipkart dataset for internal workflows.

### Example inputs

#### Search Flipkart listings

```json
{
  "searchQueries": ["wireless earbuds"],
  "maxItems": 20,
  "pageLimit": 2,
  "includeProductDetails": false
}
```

#### Scrape direct product URLs

```json
{
  "productUrls": [
    { "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8" }
  ],
  "maxItems": 10
}
```

#### Combine searches and URLs

```json
{
  "searchQueries": ["laptop backpack", "running shoes"],
  "productUrls": [
    { "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8" }
  ],
  "maxItems": 50,
  "pageLimit": 2,
  "sortBy": "relevance"
}
```

### Input options

- `searchQueries` — Flipkart search keywords to scrape.
- `productUrls` — direct HTTPS Flipkart product URLs.
- `maxItems` — maximum number of product rows to save across the run.
- `pageLimit` — maximum Flipkart search pages per query.
- `sortBy` — optional search sorting mode.
- `includeProductDetails` — optionally visit product detail pages for enrichment.
- `requestTimeoutSecs` — per-request timeout.
- `proxyConfiguration` — optional Apify Proxy settings.

### Output data

Each dataset item includes `query`, `inputType`, `status`, `error`, `warnings`, `sourceMethod`, `position`, `page`, `rankOnPage`, `title`, `productUrl`, `pid`, `price`, `originalPrice`, `currency`, `discount`, `rating`, `ratingCount`, `reviewCount`, `availability`, `brand`, `sellerName`, `offers`, `imageUrl`, `categoryBreadcrumbs`, `sourceUrl`, and `scrapedAt`.

Rows with `status: "ok"` contain extracted product data. Rows with `status: "error"` let you audit URLs that could not be read during the run.

### Pricing and cost notes

The Actor uses pay-per-event pricing: a small start charge per run and an item charge for each product row saved. Optional Apify Proxy use can add platform proxy costs. Keep `maxItems` and `pageLimit` aligned with the size of the dataset you actually need.

### API usage

Run this Actor from the Apify API or client libraries by passing the same JSON input shown in the examples above. After the run succeeds, read the default dataset to consume product rows in JSON, CSV, Excel, or through the dataset items API.

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/flipkart-products-scraper').call({
  searchQueries: ['wireless earbuds'],
  maxItems: 20,
  pageLimit: 2
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/flipkart-products-scraper').call(run_input={
    'searchQueries': ['wireless earbuds'],
    'maxItems': 20,
    'pageLimit': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~flipkart-products-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["wireless earbuds"],"maxItems":20,"pageLimit":2}'
```

### MCP usage

You can use this Actor through Apify MCP-compatible tools by selecting `fetch_cat/flipkart-products-scraper` and providing the same JSON input. This is useful for agent workflows that need current Flipkart product prices, availability, and product URLs as structured context.

Install the Apify MCP server in Claude Desktop or another MCP client with a command such as:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/flipkart-products-scraper
```

A JSON MCP server configuration can look like this:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/flipkart-products-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts for MCP clients:

- "Run the Flipkart Products Scraper for wireless earbuds and summarize the cheapest products."
- "Scrape this Flipkart product URL and tell me the current price, rating, and availability."
- "Collect the first 20 laptop backpack listings from Flipkart and return a CSV-ready table."

### Tips for reliable runs

Flipkart may challenge automated traffic, especially from datacenter IP ranges. If direct requests produce empty or error rows, enable Apify Proxy. Residential Indian proxy exits are recommended for production monitoring. Keep `includeProductDetails` disabled when listing-level data is enough, because product-page enrichment requires more requests.

### Limitations

Flipkart page layout, availability text, and offer labels can change. Some public pages omit seller, rating, review, or availability information. The Actor saves warnings and error rows so you can separate unavailable data from successfully extracted products.

### Legality and responsible use

This Actor extracts publicly available Flipkart pages. You are responsible for using the data lawfully, respecting applicable terms, and ensuring that your use case complies with privacy, consumer protection, and marketplace rules. Avoid collecting personal data or using the output for prohibited purposes.

### FAQ

- **Can Flipkart block requests?** Yes. Flipkart may challenge datacenter traffic. Use Apify Proxy, preferably residential Indian exits, when direct requests fail.
- **Can I combine searches and URLs?** Yes. Provide `searchQueries`, `productUrls`, or both.
- **Why are some fields empty?** Flipkart page markup changes and public pages may omit seller, rating, or availability details.
- **Can I export results?** Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML.

### Related actors

Use this Actor with other ecommerce and marketplace scrapers for catalog comparison, pricing intelligence, and product availability monitoring.

### Support

If a run does not return the product data you expected, share the run URL and input with support. Include whether you used direct connections or Apify Proxy so the issue can be reproduced quickly.

# Actor input Schema

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

Flipkart search terms to scrape, for example product categories, brands, or competitor keywords.

## `productUrls` (type: `array`):

Optional HTTPS Flipkart product URLs to scrape. Product-page rows are best-effort and may be partial when the public page is unavailable.

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

Maximum number of product records to save across all queries and product URLs.

## `pageLimit` (type: `integer`):

How many Flipkart search result pages to scan for each query.

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

Optional Flipkart search sorting mode.

## `includeProductDetails` (type: `boolean`):

Best-effort enrichment from each product page. Keep disabled for faster and more reliable listing exports.

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

Maximum time in seconds for one Flipkart request before a bounded retry.

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

Optional Apify Proxy settings. Flipkart frequently challenges cloud data-center traffic; Apify Residential with country code IN is the recommended route. Proxy use adds platform proxy charges.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "productUrls": [
    {
      "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8"
    }
  ],
  "maxItems": 20,
  "pageLimit": 2,
  "sortBy": "relevance",
  "includeProductDetails": false,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

No description

## `pendingWork` (type: `string`):

No description

## `overview` (type: `string`):

No description

# 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"
    ],
    "productUrls": [
        {
            "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/flipkart-products-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"],
    "productUrls": [{ "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8" }],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/flipkart-products-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "productUrls": [
    {
      "url": "https://www.flipkart.com/realme-buds-t110-rma2306-ai-enc-calls-38-hours-playback-deep-bass-bluetooth/p/itma5620a39a816e?pid=ACCH4HY6GRGJYUU8"
    }
  ]
}' |
apify call fetch_cat/flipkart-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/flipkart-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/HbrtCLbEevbNkqdgt/builds/1dXxdQPqkxu7QZJuA/openapi.json