# Flipkart Scraper (`parseforge/flipkart-scraper`) Actor

Scrape Flipkart product listings with prices, discounts, star-by-star rating histograms, key specs and offers. Export to CSV, Excel, JSON or XML.

- **URL**: https://apify.com/parseforge/flipkart-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (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 $1.40 / 1,000 product 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛒 Flipkart Scraper

> 🚀 **Export Flipkart product listings in seconds.** 30 fields per product, including the star-by-star rating breakdown (9 one-star, 6 two-star, 6 three-star, 38 four-star, 70 five-star) that the product card only ever shows you as "4.2".

Flipkart is India's largest marketplace, and its search and category pages already carry every number a pricing or merchandising team needs. This Actor reads those public listing pages directly and returns each product as one flat row: the selling price and the struck-through maximum retail price, the discount in both percent and rupees, the full rating histogram, key specifications, the bank and exchange offers attached to the card, the F-Assured badge, the sponsored flag and the whole image gallery. No login, no API key, no browser.

Every run returns **30 fields per product** and collects 24 to 40 products per request, so a thousand-product pull finishes in well under a minute. Eight server-side filters - price band, minimum rating, minimum discount, brand, F-Assured, GST invoice, new arrivals and out-of-stock - are applied by Flipkart itself before anything is downloaded.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Pricing and revenue teams | Track competitor prices, MRP and discount depth across a category, day by day. |
| E-commerce sellers and brands | See where your listings rank and how your price compares inside the same search. |
| Category and merchandising managers | Map assortment, brand share and rating quality across an entire vertical. |
| Market researchers and analysts | Build datasets on Indian retail pricing and consumer sentiment at scale. |

### 📋 What the Flipkart Scraper does

> 💡 **Why it matters:** A "4.2 stars from 129 ratings" badge tells you almost nothing. A product at 4.2 built from 70 five-star and 9 one-star ratings is a very different proposition from one at 4.2 built from a flat spread, and only the histogram tells them apart. Flipkart publishes that histogram on three of its five card layouts, covering electronics, books and grocery, and this Actor returns it in full wherever Flipkart publishes it.

- ⭐ **Full rating histogram.** `ratingBreakup` gives the exact count in each of the five star buckets, and the buckets sum precisely to `ratingCount`, validated on every record that carries one.
- 🃏 **Self-explaining rows.** `cardLayout` records which of Flipkart's five card layouts a row came from, so a blank rating is visibly a Flipkart limitation rather than a silent gap.
- 💰 **Complete price picture.** Selling price, struck-through maximum retail price, discount percent and discount in rupees, all as numbers rather than formatted strings.
- 🎛 **Eight server-side filters.** Price band, minimum rating, minimum discount, brand, F-Assured only, GST invoice only, new arrivals only, include out of stock. Flipkart applies them, so you pay for the rows you actually wanted.
- 🏷 **Offers on the card.** Bank offers and exchange values such as "Upto ₹42,600 Off on Exchange" are pulled out of Flipkart's rich-text badges into a clean array.
- 🔍 **Two ways in.** Search terms, or Flipkart search and category URLs you have already built in the browser.
- 🖼 **Whole gallery.** Every product image, resolved from Flipkart's templated CDN paths to real 832x832 URLs you can fetch.
- 📦 **One fixed schema.** Every product lands with the same 29 columns and sentinels instead of nulls, so your spreadsheet or database mapping never breaks.

### 🎬 Full Demo (🚧 Coming soon)

A short walkthrough video is in production and will land here.

### 📊 Output

Each product becomes one flat row. These are the fields:

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | Primary product image at 832x832. |
| 📌 `title` | string | Full product title as Flipkart lists it. |
| 📝 `subtitle` | string | Flipkart's variant line, for example "15.6 Inch, Steel Grey, 1.59 Kg". |
| 🔗 `url` | string | Canonical product link. |
| 🆔 `productId` | string | Flipkart's product ID (PID). |
| 🧾 `listingId` | string | Seller listing ID, unique per offer. |
| 💵 `price` | integer | Current selling price. |
| 🏷 `originalPrice` | integer | Struck-through maximum retail price. |
| 💱 `currency` | string | Always INR. |
| 📉 `discountPercent` | integer | Discount off the maximum retail price. |
| 💸 `discountAmount` | integer | The same discount in rupees. |
| ⭐ `rating` | number | Average customer rating out of 5. |
| 🔢 `ratingCount` | integer | Number of ratings. |
| 💬 `reviewCount` | integer | Number of written reviews. |
| 📊 `ratingBreakup` | object | Counts for `oneStar` through `fiveStar`. |
| 📦 `availability` | string | Flipkart's stock state, for example `IN_STOCK`. |
| ✅ `inStock` | string | Yes or No. |
| 🛡 `isFlipkartAssured` | string | Yes or No, Flipkart's quality and delivery badge. |
| 📣 `isSponsored` | string | Yes or No, whether the card was a paid placement. |
| 🔧 `warranty` | string | Warranty summary when the category has one. |
| 📂 `category` | string | Flipkart's category, for example Laptops. |
| 🗂 `subCategory` | string | One level down, for example Laptop. |
| 🗃 `superCategory` | string | One level up, for example LaptopAndDesktop. |
| 🧭 `vertical` | string | Flipkart's internal vertical key. |
| 🃏 `cardLayout` | string | Which of Flipkart's five card layouts the row came from, which tells you why a rating or spec is absent. |
| 🔩 `keySpecs` | array | Flipkart's key specification bullets. |
| 🎁 `offers` | array | Bank and exchange offers shown on the card. |
| 🖼 `images` | array | Every gallery image at 832x832. |
| 🕒 `scrapedAt` | string | ISO 8601 collection time. |
| ❌ `error` | string | Populated only on rows that failed. Error rows are never billed. |

Three real records from a live run:

```json
{
  "imageUrl": "https://rukmini1.flixcart.com/image/832/832/xif0q/computer/u/p/m/-original-imah2pf2u98xefzx.jpeg?q=70",
  "title": "Acer Aspire Lite AMD Ryzen 3 Quad Core 5400U - (8 GB/256 GB SSD/Windows 11 Home) AL15-41 Thin and Light Laptop",
  "subtitle": "15.6 Inch, Steel Grey, 1.59 Kg",
  "url": "https://www.flipkart.com/acer-aspire-lite-amd-ryzen-3-quad-core-5400u-8-gb-256-gb-ssd-windows-11-home-al15-41-thin-light-laptop/p/itm1bc0bcb4598e7?pid=COMH2TPSVSGUVKY4",
  "productId": "COMH2TPSVSGUVKY4",
  "listingId": "LSTCOMH2TPSVSGUVKY4MJENVA",
  "price": 39990,
  "originalPrice": 44990,
  "currency": "INR",
  "discountPercent": 11,
  "discountAmount": 5000,
  "rating": 4.2,
  "ratingCount": 129,
  "reviewCount": 13,
  "ratingBreakup": { "oneStar": 9, "twoStar": 6, "threeStar": 6, "fourStar": 38, "fiveStar": 70 },
  "availability": "IN_STOCK",
  "inStock": "Yes",
  "isFlipkartAssured": "Yes",
  "isSponsored": "No",
  "warranty": "1 Year Carry-in Warranty",
  "category": "Laptops",
  "subCategory": "Laptop",
  "superCategory": "LaptopAndDesktop",
  "vertical": "computer",
  "cardLayout": "LIST_LARGE",
  "keySpecs": ["AMD Ryzen 3 Quad Core Processor", "8 GB DDR4 RAM", "Windows 11 Operating System", "256 GB SSD", "39.62 cm (15.6 Inch) Display"],
  "offers": ["Upto ₹28,650 Off on Exchange", "Bank Offer"],
  "scrapedAt": "2026-08-28T14:40:12.346Z",
  "error": null
}
```

```json
{
  "title": "Lenovo Ultra 5 225U Intel Core Ultra 5 225U - (16 GB/1 TB SSD/Windows 11 Home) 21SKA0FTIG Laptop",
  "subtitle": "16 inch, Arctic Grey, 1.7 kg, With MS Office",
  "productId": "COMHNNHG5N32TYQF",
  "price": 110999,
  "originalPrice": 120990,
  "discountPercent": 8,
  "discountAmount": 9991,
  "rating": 0,
  "ratingCount": 0,
  "ratingBreakup": { "oneStar": 0, "twoStar": 0, "threeStar": 0, "fourStar": 0, "fiveStar": 0 },
  "inStock": "Yes",
  "isFlipkartAssured": "Yes",
  "warranty": "1 Year Onsite Service",
  "cardLayout": "LIST_LARGE",
  "keySpecs": ["Intel Core Ultra 5 Processor", "16 GB DDR5 RAM", "Windows 11 Operating System", "1 TB SSD", "40.64 cm (16 inch) Display"],
  "offers": ["Upto ₹42,600 Off on Exchange", "Bank Offer"]
}
```

```json
{
  "title": "HP Victus (i5 14th Gen) Intel Core 5 210 H - (16 GB/512 GB SSD/Windows 11 Home/6 GB Graphics/NVIDIA GeForce RTX 4050) 15-fa2203TX Gaming Laptop",
  "subtitle": "15.6 inch, Performance blue, 2.29 kg, With MS Office",
  "productId": "COMHK77SZSZHTEV7",
  "price": 94990,
  "rating": 4.1,
  "ratingCount": 61,
  "category": "Laptops",
  "subCategory": "Laptop",
  "superCategory": "LaptopAndDesktop",
  "cardLayout": "LIST_LARGE",
  "isFlipkartAssured": "Yes",
  "isSponsored": "No"
}
```

### ✨ Why choose this Actor

- **The histogram, not just the average.** Five exact star-bucket counts wherever Flipkart publishes them, summing precisely to the rating total.
- **Filters that Flipkart applies, not filters applied after download.** Eight real facets narrow the result set at the source, which is also the only practical way past Flipkart's own page ceiling.
- **Fast and light.** Plain HTTP against the server-rendered listing page. No browser, no 4 GB of RAM, 24 to 40 products per request.
- **No proxy needed.** It runs on ordinary datacenter traffic by default, verified on the Apify platform. Apify Proxy is exposed but off.
- **Honest about its limits.** The ceiling below is stated before you spend anything.
- **Clean, stable schema.** 30 columns, identical on every row, sentinels instead of nulls so CSV and Excel imports stay predictable.

### 📈 How it compares to alternatives

| | This Actor | Typical Flipkart listing scrapers |
|---|---|---|
| Star-by-star rating histogram | Yes, wherever Flipkart publishes it | Rare. One of the 40 Flipkart Actors in the Store returns it |
| Server-side filters | 8 (price band, rating, discount, brand, F-Assured, GST, new arrivals, stock) | Usually none. The volume leader exposes sort only |
| Discount in rupees as well as percent | Yes | Percent only, when present |
| Bank and exchange offers | Yes, parsed into an array | Usually dropped |
| Sponsored placement flag | Yes | Sometimes |
| Product detail page enrichment | **No.** See the ceiling below | Some competitors do this |
| Fields per product | 30 | 14 to 25 where a schema is published |
| Browser required | No | Often yes |
| Price per 1,000 results | $2.00, down to $1.40 at volume | $0.84 to $20.00, median $3.50 |

**The ceiling, stated plainly.** Flipkart serves at most **41 pages per query**. Page 41 returns products and page 42 returns nothing, for both search and category browse, so a single query yields roughly 984 to 1,640 products depending on the vertical's page size even when Flipkart reports 2,336 matches. This is Flipkart's limit, not the Actor's, and it applies to every tool that reads the same listing surface. The eight filters exist precisely to work around it: split a large category by price band or by brand and each slice gets its own 41 pages. The Actor logs Flipkart's reported total on every source so you always know your coverage.

**The second ceiling: not every category publishes ratings.** Flipkart serves five different card layouts and they carry different depths of data. Electronics use a detailed 24-per-page card with ratings, key specs, warranty and stock state. Books and grocery use 40-per-page grids that carry ratings but no specs or warranty. Footwear, apparel and watches use lean 40-per-page cards that carry no rating at all, and there is no second door to it: the quick-view endpoint those cards link to returns 404 when requested directly, and the fashion category pages use the same lean card. Rows from those layouts report `Not Disclosed` rather than a fabricated zero, and `cardLayout` on every row names the layout so you always know which case you are looking at. Price, title, image gallery, discount percent, product and listing IDs and the full category tree are present on all five layouts.

| Layout | Categories | Rating and histogram | Key specs | Warranty |
|---|---|---|---|---|
| `LIST_LARGE` | Laptops, mobiles, TVs | Yes | Yes | Yes |
| `GRID_DEFAULT` | Books | Yes | No | No |
| `GRID_FURNITURE_V2` | Grocery | Yes | No | No |
| `QUICK_VIEW` | Footwear, apparel | No | No | No |
| `GRID_LIFESTYLE` | Watches | No | No | No |

Seller names, full specification tables and the long product description live only on the product detail page, which Flipkart renders as deeply nested widget trees with no stable schema. This Actor does not read them. If seller-level data is what you need, a detail-page Actor is the right tool and this one is not.

### 🚀 How to use

1. **Create a free Apify account.** New accounts get $5 in free credit. [Sign up here](https://console.apify.com/sign-up?fpr=vmoqkp).
2. **Open the Actor** and go to the Input tab.
3. **Type your search terms**, for example `laptop` or `running shoes`. Or paste Flipkart search and category URLs into Flipkart URLs instead.
4. **Set Max Items** to the number of products you want back.
5. **Optionally set filters** - a price band, a minimum rating, a minimum discount, specific brands, F-Assured only.
6. **Click Start** and watch the log. It reports how many products Flipkart says match, so you can see your coverage.
7. **Download your data** from the Storage tab as CSV, JSON, Excel or XML, or pull it from the API.

### 💼 Business use cases

**📊 Competitive price tracking.**

A consumer electronics brand runs the Actor every morning against its own category with a price band around its hero product. Because `price`, `originalPrice` and `discountAmount` come back as numbers, the daily file drops straight into a pricing model and a competitor's ₹5,000 promotion is visible the day it starts.

**🛍 Assortment and brand share analysis.**

A category manager pulls an entire vertical in brand-sized slices, using the Brands filter to stay inside Flipkart's page ceiling, then counts listings and average rating per brand to see who actually owns shelf space in that search.

**⭐ Review quality screening.**

A sourcing team screens hundreds of candidate products by `ratingBreakup` rather than by average. Two products both sitting at 4.2 are separated by their one-star counts, which is the signal that predicts returns.

**🎯 Seller rank and visibility auditing.**

A marketplace seller searches its own keywords and records where its `listingId` appears in the result order, alongside `isSponsored`, to tell organic ranking apart from competitors' paid placements.

### 🔌 Automating Flipkart Scraper

- **Make:** trigger a run on a schedule and route the rows into your pricing sheet.
- **Zapier:** connect the Actor to thousands of apps and start a run from any trigger.
- **Slack:** post a summary of each run into a team channel so price moves arrive where the team already is.
- **Airbyte:** sync the dataset into your warehouse for long term price and rating trends.
- **GitHub:** schedule runs from an Actions workflow and commit the results alongside your analysis code.
- **Google Drive:** drop each run's CSV into a shared folder for the wider team.

### 🌟 Beyond business use cases

- **Research:** economists and retail researchers building datasets on Indian e-commerce pricing and discounting.
- **Personal:** shoppers tracking a specific product until it hits a target price.
- **Non-profit:** consumer advocacy groups measuring how discount claims compare against listed maximum retail prices.
- **Experimentation:** developers prototyping recommendation, price prediction or review quality models against real marketplace data.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude or any assistant to plan your run:

> I am using the ParseForge Flipkart Scraper on Apify. It takes Flipkart search terms or search and category URLs and returns 30 fields per product, including selling price, maximum retail price, discount in percent and rupees, the star-by-star rating histogram, key specs, bank and exchange offers, the F-Assured badge and the sponsored flag. Ratings and key specs are published by Flipkart on some card layouts and not others: electronics, books and grocery carry ratings, while footwear, apparel and watches do not, and the cardLayout column on every row says which case you are in. It offers eight server-side filters: price band, minimum rating, minimum discount, brand, F-Assured only, GST invoice only, new arrivals only and include out of stock. Flipkart serves at most 41 pages per query, so large categories have to be split with those filters. It does not read product detail pages, so no seller names or full spec tables. Help me design an input for \[describe your goal].

### ❓ Frequently Asked Questions

**🔑 Do I need a Flipkart login or API key?**
No. The Actor reads public search and category pages. There is no login, no cookie and no affiliate API token involved.

**📄 How many products can I get from one search?**
Up to 41 pages. Page size is set by Flipkart and depends on the vertical: 24 for laptops and mobiles, 40 for fashion, books and grocery. That works out at roughly 984 to 1,640 products per query. Split the query with the price, brand or rating filters to go deeper.

**🤔 Why does Flipkart report 2,336 matches when I only get 984?**
The number in the log is Flipkart's own facet count for the whole result set. Flipkart simply stops serving pages after 41. Reporting both numbers is deliberate, so you always know what fraction of the category you have.

**⭐ What exactly is in `ratingBreakup`?**
The number of customers who gave one, two, three, four and five stars. The five buckets sum exactly to `ratingCount`, which was checked on every record during development.

**🃏 Why is `rating` "Not Disclosed" on some products?**
Because Flipkart does not publish a rating on the card layout that category uses. Footwear, apparel and watches are served on lean cards with no rating in the payload at all, while electronics, books and grocery carry the full histogram. The `cardLayout` column on every row tells you which layout you got, so the gap is always explainable. The Actor reports the sentinel rather than inventing a zero.

**🏪 Can I get the seller name or the full specification table?**
No. Those live only on the product detail page, which Flipkart renders as nested widget trees with no stable schema. This Actor deliberately stays on the listing surface, which is fast, complete and reliable.

**🔎 What do I put in the Brands filter?**
The brand exactly as Flipkart spells it in its own Brand filter, for example `HP`, `ASUS`, `Lenovo`, `DELL`, `Apple`. The valid list differs per category, which is why it is a free text list rather than a fixed menu.

**💵 Why is `rating` sometimes 0?**
Because the product genuinely has no ratings yet. Flipkart reports zero and the Actor reports zero rather than inventing a value. `ratingCount` will be 0 on the same row.

**🌍 Do I need a proxy?**
No. Flipkart serves this data to ordinary datacenter traffic and the Actor runs without a proxy by default, verified on the Apify platform. Enable Apify Proxy if you are running at high volume.

**🛒 Does it work for every category?**
Yes. It was tested across laptops, mobiles, footwear, books and grocery. The field set is identical everywhere, though category-dependent fields such as `warranty` are populated only where Flipkart publishes them.

**🚫 What happens if a page fails to load?**
The Actor writes a row containing only an `error` message naming the page and the source. Error rows are never billed.

**📦 What export formats are available?**
CSV, JSON, Excel and XML from the Storage tab, or straight from the Apify API.

### 🔌 Integrate with any app

Every run's dataset is available through the Apify API, so you can pull results into any language or platform that speaks HTTP. Apify also ships official clients for JavaScript and Python, plus native integrations for Make, Zapier, Airbyte, Slack, GitHub and Google Drive.

### 🔗 Recommended Actors

- [IndiaMART Scraper](https://apify.com/parseforge/indiamart-scraper?fpr=vmoqkp) - the B2B half of Indian e-commerce, with supplier and quantity pricing.
- [Amazon Bestsellers Scraper](https://apify.com/parseforge/amazon-bestsellers-scraper?fpr=vmoqkp) - benchmark Flipkart pricing against Amazon's ranked categories.
- [eBay Scraper](https://apify.com/parseforge/ebay-scraper?fpr=vmoqkp) - listings, prices and conditions from the global marketplace.
- [AliExpress Scraper](https://apify.com/parseforge/aliexpress-scraper?fpr=vmoqkp) - source-side pricing for the products that end up on Indian marketplaces.
- [Newegg Scraper](https://apify.com/parseforge/newegg-scraper?fpr=vmoqkp) - electronics pricing for cross-market comparison.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool, not affiliated with or endorsed by Flipkart. It collects only publicly available data.

# Actor input Schema

## `searchTerms` (type: `array`):

What to search for on Flipkart. One product listing page is walked per term, up to 41 pages each. Example: laptop, running shoes, basmati rice.

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

Flipkart search or category URLs to scrape directly, for example https://www.flipkart.com/mobiles/pr?sid=tyy,4io. Filters below are appended to each URL. Use this when you have already built the exact listing you want in the browser.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

How Flipkart orders the results before they are collected. Sorting by price is the practical way to slice a large category into chunks that fit inside Flipkart's 41-page ceiling.

## `minPrice` (type: `integer`):

Only return products priced at or above this amount, in Indian rupees.

## `maxPrice` (type: `integer`):

Only return products priced at or below this amount, in Indian rupees.

## `minRating` (type: `string`):

Keep only products whose average customer rating is at least this many stars.

## `minDiscount` (type: `string`):

Keep only products discounted by at least this much off the listed maximum retail price.

## `brands` (type: `array`):

Restrict results to these brands, spelled exactly as Flipkart spells them in its Brand filter, for example HP, ASUS, Lenovo, DELL, Apple. Leave empty for every brand.

## `fAssuredOnly` (type: `boolean`):

Keep only products carrying Flipkart's F-Assured quality and delivery badge.

## `newArrivalsOnly` (type: `boolean`):

Keep only products Flipkart currently flags as new arrivals.

## `gstInvoiceOnly` (type: `boolean`):

Keep only products that can be invoiced with GST, which is what business buyers need to claim input tax credit.

## `includeOutOfStock` (type: `boolean`):

Also return products Flipkart currently lists as unavailable. Off by default, so you only get what can actually be bought.

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

Flipkart is reachable without a proxy, so this is off by default. Turn on Apify Proxy for high-volume runs or if your runs start getting throttled.

## Actor input object example

```json
{
  "searchTerms": [
    "laptop",
    "running shoes"
  ],
  "startUrls": [],
  "maxItems": 10,
  "sortBy": "relevance",
  "brands": [
    "HP",
    "ASUS"
  ],
  "fAssuredOnly": false,
  "newArrivalsOnly": false,
  "gstInvoiceOnly": false,
  "includeOutOfStock": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every field, rendered as a formatted product table

## `fullData` (type: `string`):

Complete dataset with all 30 fields as raw JSON

# 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 = {
    "searchTerms": [
        "laptop"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchTerms": ["laptop"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchTerms": [
    "laptop"
  ],
  "maxItems": 10
}' |
apify call parseforge/flipkart-scraper --silent --output-dataset

```

## MCP server setup

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