Flipkart Scraper - Prices, MRP, Computed Discount % and the Assured Badge, with MCP Delivery to Notion & Slack

Search Flipkart the way a shopper does, and get the results as data. One search query in — title, selling price, struck-through MRP, discount, rating, rating and review counts, seller, Flipkart Assured badge, image and product URL out, one flat row per product, up to 2,000 of them. No Flipkart account, no login, no API credentials. Optional delivery into Notion, Slack, Linear, Jira, GitHub or Airtable over MCP.

🔐 Trust & operations at a glance

Credentials	None required. No Flipkart login, no seller account, no API key. Delivery runs through the Apify MCP Proxy, so the Actor never sees your connector tokens.
Data scope	Public search results only — exactly what an anonymous visitor sees on flipkart.com. No account, order or seller-dashboard data.
Personal data	Essentially none. Listings are commercial content; no reviewer names and no review text are collected, only the rating and review counts.
⚠️ Proxy is not optional	Flipkart blocks datacenter traffic and serves by exit-IP country. The default is Apify Residential with an Indian exit IP — and residential groups need a paid Apify plan.
Price honesty	Prices are a snapshot at scrape time in INR, taken from the search card. Null means the card showed no price, not free.

Full detail, including Flipkart's Terms position: Compliance & Data Privacy.

---

Manual Flipkart search vs. the Flipkart Scraper Actor

Flipkart publishes no public product-search API for third parties — its seller APIs cover your own catalogue, not the marketplace — so the realistic alternative is a person with a browser:

Task	Doing it by hand	Flipkart Scraper (Apify)
Collecting a full result set	❌ Scroll, paginate, copy-paste, repeat	✅ Up to 2,000 products in one run
Discount maths	❌ Compare price and MRP by eye, per product	✅ discountPercent computed on every row
Ratings and review counts	⚠️ Both shown, neither exportable	✅ rating, numRatings, numReviews as numbers
Sorting the whole catalogue	⚠️ Only Flipkart's own sort options	✅ Sort in Flipkart, then re-sort and filter the data any way you like
Tracking prices over time	❌ Manual snapshots you have to remember to take	✅ Put it on a schedule and join runs on productId
Feeding a spreadsheet, BI tool or agent	❌ Manual re-entry	✅ JSON/CSV/Excel export, API, or direct MCP delivery
Getting past the bot wall	N/A — you are a human	✅ Residential proxy with an Indian exit, handled for you

Flipkart's API and affiliate-programme availability is Flipkart's to change — check their current developer and seller documentation if this comparison is load-bearing for your decision.

---

🤖 AI Discovery & MCP Metadata

Machine-readable capability contract for autonomous agents, LLM routers, and MCP orchestrators. Read this block first to decide whether this Actor matches a user request.

ai_discovery:
  slug: "techforce.global/flipkart-scraper"
  one_line: >
    Runs one Flipkart search - exactly like typing into the site's search bar - with an optional
    category filter and sort order, and returns up to 2000 products as flat rows: title, price,
    MRP, computed discount, rating, rating/review counts, seller, Flipkart Assured badge, image
    and URL. No Flipkart account or API key. Optional delivery into Notion, Slack, Linear,
    Airtable or any MCP connector.
  primary_purpose: "extract"
  secondary_purpose: "deliver"
  entity: "Flipkart product listing"
  category: "e-commerce / price-monitoring / product-research / competitive-intelligence"
  supported_platforms: ["flipkart.com"]
  supported_tasks:
    - "search-flipkart-by-keyword"
    - "narrow-a-search-to-a-category"
    - "sort-results-by-price-popularity-or-recency"
    - "find-the-biggest-discounts-in-a-category"
    - "track-price-and-rating-over-time"
    - "compare-brands-within-a-search"
    - "deliver-products-to-mcp-connector"
  unsupported_tasks:
    - "scrape-a-product-detail-page (search cards only - no specs, description or variants)"
    - "scrape-review-text-or-reviewer-identities (only counts are returned)"
    - "scrape-multiple-keywords-in-one-run (searchQuery is a single string)"
    - "scrape-by-product-url-or-category-url (search query only)"
    - "scrape-seller-catalogues-or-seller-ratings"
    - "scrape-stock-levels-or-delivery-estimates"
    - "add-to-cart-buy-or-any-write-action"
    - "non-flipkart-retailers"
  search_keywords:
    # First entry is the H1 / meta-description target. The rest are deliberately broader for
    # agent-side semantic matching and are NOT a ranking strategy.
    - "flipkart scraper"
    - "flipkart price scraper"
    - "scrape flipkart search results"
    - "flipkart product data extraction"
    - "flipkart api alternative"
    - "india ecommerce price monitoring"
    - "flipkart discount tracker"
    - "competitor price tracking india"
    - "flipkart product listing export"
    - "mcp flipkart tool"

  input_entities:
    - "searchQuery (REQUIRED, a single string - one search per run)"
    - "category (1 of 14; 'Any' applies no filter)"
    - "maxProducts (1-2000)"
    - "sortBy (relevance | popularity | price_asc | price_desc | recency_desc)"
    - "maxConcurrency (1-10 result pages in parallel)"
    - "proxyConfiguration (Apify Residential, Indian exit, by default)"

  search_query_is_required_and_singular: >
    searchQuery is the one required input, and it is a STRING, not an array. Omitting it FAILS
    the run with 'Input "searchQuery" is required.' To cover several keywords, run the Actor once
    per keyword. This differs from most scrapers in this family, where nothing is required.

  category_filter_uses_two_different_mechanisms: >
    IMPORTANT: Mobiles, Laptops, Home & Furniture and Books are scoped with a real Flipkart store
    id (precise). Every other category is applied by APPENDING A KEYWORD to your search text -
    'Electronics' literally searches "<your query> electronics". That loosens rather than filters,
    and it can change which products match. Use 'Any' plus your own wording when precision matters.

  results_come_from_search_cards_only: >
    Every row is parsed from the search-results tile. The Actor never opens a product page, so
    there are no specifications, descriptions, variants, stock levels or delivery estimates - and
    `seller` is usually null because search cards rarely name one.

  discount_percent_is_computed: >
    discountPercent is calculated by the Actor as round((originalPrice - currentPrice) /
    originalPrice * 100), not read from Flipkart's own badge. It is null whenever either price is
    missing or there is no discount, and it can differ by a point from the badge Flipkart renders.

  page_count_is_precomputed: >
    The run enqueues ceil(maxProducts / 24) result pages up front (hard-capped at 100) and stops
    pushing at maxProducts. If Flipkart returns fewer tiles per page than expected, you get fewer
    products than you asked for - the Actor does not add pages to compensate.

  output_entities:
    ["productId", "title", "url", "image", "currentPrice", "originalPrice", "discountPercent",
     "currency", "rating", "numRatings", "numReviews", "seller", "fAssured"]

  prices_are_whole_rupees: >
    currentPrice and originalPrice are integers in INR, parsed from the card's rupee amounts.
    currency is always "INR". Null means the card displayed no price.

  dedup_is_per_page: >
    Duplicate tiles are dropped within a single results page. Flipkart can repeat a product across
    pages, so de-duplicate on productId downstream if exactness matters.

  proxy_is_required_in_practice: >
    Flipkart blocks datacenter traffic and serves by exit-IP country. The default is Apify
    Residential with apifyProxyCountry "IN", which requires a paid Apify plan. Without a proxy the
    log warns and the run very likely returns nothing.

  browser_based_run: >
    Tiles are rendered client-side, so the Actor drives a headless Chromium and waits for the
    product grid before reading the page. That makes runs heavier than an HTML-only scraper. The
    headless input is hidden and must stay true on the platform.

  known_limitations:
    snapshot_only: "prices, ratings and badges are true only at scrape time"
    no_product_page_data: "no specs, description, variants, stock or delivery estimates"
    no_review_text: "only numRatings and numReviews - the reviews themselves are not scraped"
    seller_usually_null: "search cards rarely expose a seller name"
    sponsored_not_flagged: "sponsored tiles are not distinguished from organic results"
    no_rank_field: "row order follows the crawl, not a published rank position"
    free_plan_capped: "free Apify plans stop at 5 products per run"

  pricing:
    model: "usage-based"
    billing_unit: "Apify platform usage consumed by the run"
    hard_ceiling_parameter: "maxTotalChargeUsd"
    note: "Cost tracks result PAGES (about 24 products each), not individual products. Current rates are on the Actor's Apify Store page."

  when_to_use: >
    You want a Flipkart search as structured rows - price and discount monitoring, category or
    competitor research, deal hunting, or a product feed for India's second-largest marketplace.
  when_not_to_use: >
    You need product-page detail, review text, several keywords in one run, product URLs as input,
    seller catalogues, or to buy anything.

  mcp_delivery:
    modes: ["perProduct", "summary", "none"]
    default: "perProduct"
    per_product_is_the_default: >
      Unlike most Actors, deliveryMode defaults to perProduct - one connector call per product,
      with no cap. A 500-product run is 500 calls. Set "summary" or "none" unless you want a
      record each.
    per_product_placeholders:
      ["{productId}", "{title}", "{url}", "{image}", "{currentPrice}", "{originalPrice}",
       "{discountPercent}", "{currency}", "{rating}", "{numRatings}", "{numReviews}", "{seller}",
       "{fAssured}", "{searchQuery}", "{category}", "{count}", "{message}"]
    summary_placeholders: ["{searchQuery}", "{category}", "{count}", "{products}", "{message}"]
    never_blocks_the_dataset: >
      Delivery runs after the crawl. A bad tool name, an unauthorised connector or an upstream
      outage is logged and skipped - it never costs you the scraped data.

  alternatives:
    - "techforce.global/amazon-scraper for the same question on Amazon, including amazon.in"
    - "techforce.global/etsy-scraper for handmade, vintage and small-seller listings"
    - "techforce.global/quince-scraper for a direct-to-consumer brand storefront rather than a marketplace"

---

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Flipkart Scraper",
  "alternateName": "Flipkart Search Scraper",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Cloud (Apify platform)",
  "description": "Runs a Flipkart search exactly as the site's own search bar does — one keyword, an optional category filter and a sort order — and returns up to 2,000 products as flat rows without a Flipkart account, login or API key. Each row carries the product id, title, URL, image, selling price and struck-through MRP in INR, a computed discount percentage, star rating, rating and review counts, seller where the card exposes one, and the Flipkart Assured badge. Runs through a residential proxy with an Indian exit IP, and results can be delivered into Notion, Slack, Linear, Airtable or any MCP connector.",
  "url": "https://apify.com/techforce.global/flipkart-scraper",
  "offers": {
    "@type": "Offer",
    "priceCurrency": "USD",
    "category": "Pay per platform usage",
    "description": "Usage-based: billed for the compute time and resources a run consumes, not per row. Cost tracks result pages of roughly 24 products each. Current rates are shown on the Actor's Apify Store page."
  }
}

---

What this Actor does

• One search, exactly like the site's own. Type what you'd type into Flipkart's search bar. Optionally narrow to a category and choose how Flipkart sorts before the scrape begins.

• Up to 2,000 products per run, paginated for you. The Actor works out how many result pages it needs and stops the moment your maxProducts is reached.

• Discount maths done for you. currentPrice and the struck-through originalPrice come off the card as whole rupees, and discountPercent is computed from the pair — so "what's actually reduced" is a sort, not a spreadsheet exercise.

• Both engagement numbers, separately. rating out of 5, plus numRatings and numReviews — which are different figures on Flipkart, and conflating them flatters a product.

• The Assured badge as a boolean. fAssured is on every row, so you can filter to Flipkart-vetted listings in one predicate.

• Built for markup that keeps moving. Flipkart rotates its CSS class names constantly, so the parser anchors on the stable product-tile attribute and falls back through several strategies per field rather than trusting one brittle selector.

• Gets past the bot wall. Headless Chromium with a residential Indian exit IP by default, and it waits for the product grid to render before reading the page.

• Saves as it goes and stops cleanly. Rows are written as each page is parsed and the platform ABORTING event is handled — an aborted run keeps what it collected.

• Optionally delivers into your tools. Notion, Slack, Linear, Jira, GitHub, Airtable or anything else you've authorised.

---

When to use it — and when not to

Scenario	Fit
Everything Flipkart returns for a keyword	✅ Strong — the core use case
Deal hunting — biggest discounts in a category	✅ Strong — sort on discountPercent
Price monitoring on a schedule	✅ Strong — join runs on productId
Competitor or category research	✅ Strong — category + sortBy
Cheapest-first or newest-first sweeps	✅ Strong — price_asc, recency_desc
Filtering to Flipkart Assured listings	✅ Strong — fAssured
Rating quality vs. rating volume	✅ Strong — rating with numRatings
A product feed with images and links	✅ Strong
Results in Notion / Slack / Airtable	✅ Strong — native MCP delivery
Precise category scoping	⚠️ Only 4 categories use a real store id; the rest append a keyword to your query
Exactly maxProducts rows every time	⚠️ Pages are pre-computed; a thin page yields fewer
Telling sponsored tiles from organic	⚠️ Not flagged
Seller names	⚠️ Rarely on search cards — usually null
Product specifications or descriptions	❌ Search cards only — no product-page visit
Review text or reviewer identities	❌ Counts only
Several keywords in one run	❌ searchQuery is a single string — one run per keyword
Product or category URLs as input	❌ Search query only
Stock levels or delivery estimates	❌ Not collected
Buying, carting or any write action	❌ Read-only
Non-Flipkart retailers	❌ Flipkart only

---

⚡ Execution Rules (Avoid Common Agent Failures)

1. searchQuery is required, and it is a single string. Omit it and the run FAILS with Input "searchQuery" is required. — this Actor does not silently succeed on empty input the way some scrapers do. To cover several keywords, run it once per keyword.

2. The category filter is not uniformly precise. Mobiles, Laptops, Home & Furniture and Books scope the search with a real Flipkart store id. Every other category appends a keyword to your search text — picking Electronics literally searches "<your query> electronics". That loosens the query and can change which products match. When precision matters, choose Any and word the query yourself.

3. Result pages are pre-computed, not adaptive. The run enqueues ceil(maxProducts / 24) pages up front (hard-capped at 100). If Flipkart serves thinner pages than that estimate, you get fewer products than you asked for — the Actor won't add pages to make up the shortfall.

4. Every row comes from a search card. No product page is ever opened, so there are no specs, descriptions, variants, stock levels or delivery estimates — and seller is usually null.

5. discountPercent is computed, not copied. It's round((originalPrice − currentPrice) / originalPrice × 100), so it's null whenever either price is missing, and it can differ by a point from the badge Flipkart renders.

6. Prices are whole rupees, and currency is always INR. currentPrice is the payable price; originalPrice is the struck-through MRP and is null when the item isn't discounted.

7. Null price is not zero. A card that shows no price yields null — exclude those rows rather than treating them as free.

8. Keep the residential proxy with the Indian exit. The default is {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN"}. Flipkart blocks datacenter traffic and serves by exit country; without it the log warns No proxy configured. Flipkart will very likely block these requests. Residential needs a paid plan.

9. Blocks look like an empty run, not a failure. If the grid never renders, the log warns No product tiles found on page N / Parsed 0 products from page N and the run still ends SUCCEEDED. Check the log, not the run status.

10. De-duplication is per page. Flipkart can repeat a product across pages; dedupe on productId downstream if exactness matters.

11. Row order is crawl order, not rank. Pages are fetched in parallel, and sponsored tiles are not flagged. There is no rank field — don't infer one from row order.

12. Keep maxConcurrency low. Default 2, range 1–10. Higher is faster right up until Flipkart starts refusing; 1–3 is the sensible band.

13. Leave headless alone. It's a hidden input that must stay true on the platform — Apify's containers have no display and a headful run fails.

14. deliveryMode defaults to perProduct — one connector call per product, with no cap. A 500-product run is 500 calls. Set summary or none unless you want a record each.

15. Free Apify plans stop at 5 products per run — and the page count shrinks to match. That's a smoke test, not a data pull.

dependencies:
  - rule: "searchQuery is required and must be a non-empty string"
    on_violation: "the run FAILS with 'Input \"searchQuery\" is required.'"
  - rule: "category values other than Mobiles / Laptops / Home & Furniture / Books modify the query text"
    note: "choose Any for a literal search"
  - rule: "maxProducts drives how many pages are enqueued (24 per page, cap 100 pages)"
    note: "thin pages mean fewer rows; the Actor does not compensate"
  - rule: "delivery requires mcpConnector AND mcpTool"
    on_violation: "delivery is skipped with a warning; every dataset row is still written"
  - rule: "mcpArguments must reference {message} for the rendered template to appear anywhere"
    on_violation: "message body is empty; the tool is still called"
  - rule: "mcpConnector only resolves when the Actor runs on the Apify platform"
    on_violation: "local runs log 'APIFY_MCP_PROXY_URL is not set' and skip delivery"
authentication:
  actor_input: none
  platform: "Apify API token required for API / SDK / MCP invocation; paid plan required for residential proxy groups"
  target_site: "no Flipkart account, login or API key required (public listings only)"

---

📥 Input Contract

.actor/input_schema.json is authoritative — if this page disagrees with the schema files, the schema files win.

Parameter	Type	Required	Default	Notes
searchQuery	string	✅ Yes	Console prefill only	What you'd type into Flipkart's search bar. One query per run
category	string (enum)	⬜ No	Any	14 values — see the precision note below
maxProducts	integer	⬜ No	50	1–2000. Drives how many result pages are enqueued
sortBy	string (enum)	⬜ No	relevance	relevance · popularity · price_asc · price_desc · recency_desc
maxConcurrency	integer	⬜ No	2	1–10 result pages in parallel. Keep it low
proxyConfiguration	object	⬜ No	Residential, IN exit	Leave enabled.
headless	boolean	⬜ No (hidden)	true	Must stay true on the platform

Categories and how precisely they filter

Category	How it's applied	Precision
Mobiles, Laptops, Home & Furniture, Books	Flipkart store id (sid)	✅ True category scoping
Electronics, TVs & Appliances, Men's Fashion, Women's Fashion, Beauty & Grooming, Sports & Fitness, Toys & Baby, Grocery, Automotive	A keyword appended to your query	⚠️ Narrows loosely, and changes the search text
Any (default)	No filter at all	✅ Your query, untouched — the most predictable path

Example: searchQuery: "wireless earbuds" with category: "Electronics" actually searches wireless earbuds electronics. Useful as a nudge, misleading if you expected a hard filter.

Sort modes

Value	Flipkart's ordering
relevance (default)	Flipkart's own default relevance — no sort parameter is sent
popularity	Most popular first
price_asc	Price, low to high
price_desc	Price, high to low
recency_desc	Newest first

Delivery (optional)

Parameter	Type	Default	Description
mcpConnector	string	""	A connector you've authorised on your Apify account — Notion, Slack, Linear, Jira, GitHub, Airtable, or any MCP-compatible connector. Leave empty for dataset-only runs.
deliveryMode	string (enum)	perProduct	perProduct (one call per product, uncapped) · summary (one call with the whole list) · none.
mcpTool	string	""	Tool to call — create_page, send_message, create_issue, appendRow. Required when a connector is set; run once and the log lists the connector's tools.
mcpArguments	object	{}	Arguments for the tool. String leaves support {placeholder} tokens.
mcpMessageTemplate	string	""	Template rendered and exposed to mcpArguments as {message}.

Placeholders by mode:

Mode	Placeholders
perProduct	Every product field — {productId} {title} {url} {image} {currentPrice} {originalPrice} {discountPercent} {currency} {rating} {numRatings} {numReviews} {seller} {fAssured} — plus the run context {searchQuery} {category} {count} and {message}
summary	{searchQuery} {category} {count} {products} (a markdown list of every product) {message}

Null values render as an empty string rather than the word "None".

---

📤 Output Contract & Data Structure

One dataset row per product, written as each results page is parsed. Every row carries the same 13 keys; nullable fields come back null, never "N/A".

Field	Type	Nullable	Meaning
productId	string	yes	Flipkart's tile identifier. The stable key for joining runs and de-duplicating
title	string	yes	Product title as listed
url	string	yes	Canonical product page URL
image	string	yes	Thumbnail from Flipkart's image CDN
currentPrice	number	yes	Selling price in whole rupees. Null when the card shows no price
originalPrice	number	yes	Struck-through MRP. Null when the listing isn't discounted
discountPercent	number	yes	Computed as round((originalPrice − currentPrice) / originalPrice × 100). Null when either price is missing
currency	string	yes	Always INR
rating	number	yes	Average stars out of 5. Null when the product has no ratings
numRatings	integer	yes	Count of star ratings
numReviews	integer	yes	Count of written reviews — normally lower than numRatings
seller	string	yes	Usually null — search cards rarely name a seller
fAssured	boolean	no	Whether the tile carries Flipkart's Assured badge

Everything here comes from the search card. No product page is opened, which is why there are no specs, descriptions, variants or stock levels, and why seller is mostly empty.

Example output object

{
  "productId": "MOBGXXXXXXXXXXXX",
  "title": "Acme Buds Pro (Midnight Black, True Wireless)",
  "url": "https://www.flipkart.com/acme-buds-pro-midnight-black/p/itmXXXXXXXXXXXXX",
  "image": "https://rukminim2.flixcart.com/image/312/312/xif0q/headphone/…jpeg",
  "currentPrice": 1999,
  "originalPrice": 4999,
  "discountPercent": 60,
  "currency": "INR",
  "rating": 4.2,
  "numRatings": 18432,
  "numReviews": 1205,
  "seller": null,
  "fAssured": true
}

Values illustrate shape and formatting — the product and numbers are invented. Note

seller: null

, which is the normal case, and numReviews being far lower than numRatings.

What a successful run looks like

• Status: SUCCEEDED
• Dataset: one row per product, up to maxProducts, in crawl order
• Log: Starting Flipkart search: query=… category=… sort=… maxProducts=…, then Enqueuing N search-result page(s)., a Page N: pushed X product(s) line per page, and Done. Scraped N product(s) into the dataset.
• Zero results is also a success. A block, a query with no matches, or a layout the parser didn't recognise all return an empty dataset with SUCCEEDED. Check the log for No product tiles found or Parsed 0 products.
• Fewer rows than maxProducts is normal when Flipkart's pages are thinner than the estimate, or the search simply has fewer matches.

Dataset views

View	Shows
Products	Image, title, price, MRP, discount, rating, rating/review counts, Assured badge, link
Deals & Discounts	Title, discount, price and MRP, currency, rating, Assured badge, link
Sellers & IDs	Product id, title, seller, Assured badge, price, currency, link

---

▶️ Invocation & Integration

Authenticate every call with Authorization: Bearer <APIFY_TOKEN>.

Apify Console

Open the Actor page → Input tab → type your search query → optionally pick a category and sort order → set maxProducts → leave the residential proxy on → Start.

Model Context Protocol (MCP)

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=techforce.global/flipkart-scraper"

Then ask your agent for "the best-discounted wireless earbuds on Flipkart right now".

Python (apify-client)

import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run = client.actor("techforce.global/flipkart-scraper").call(run_input={
    "searchQuery": "wireless earbuds",
    "category": "Any",          # 'Any' keeps your query literal
    "maxProducts": 100,
    "sortBy": "price_asc",
    "maxConcurrency": 2,
    "deliveryMode": "none",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
if not rows:
    raise SystemExit("Nothing scraped — check the log (blocked? no matches?).")

# price and discount are nullable — exclude, don't coerce to 0.
deals = [r for r in rows if r.get("discountPercent") is not None]
print(f"{len(deals)}/{len(rows)} rows are discounted")

for r in sorted(deals, key=lambda r: r["discountPercent"], reverse=True)[:10]:
    stars = f'{r["rating"]}★' if r.get("rating") is not None else '  — '
    assured = "✓" if r.get("fAssured") else " "
    print(f'{r["discountPercent"]:>3}% off  ₹{r["currentPrice"]:>7,}  '
          f'(MRP ₹{r["originalPrice"]:>7,})  {stars:>6} x{r.get("numRatings") or 0:<7} '
          f'{assured}  {(r.get("title") or "")[:45]}')

JavaScript / TypeScript (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('techforce.global/flipkart-scraper').call({
  searchQuery: 'nike running shoes',
  category: "Men's Fashion",   // note: this appends "men's" to the query text
  maxProducts: 200,
  sortBy: 'popularity',
  deliveryMode: 'none',
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'IN',
  },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Flipkart can repeat a product across pages — dedupe on productId.
const unique = [...new Map(items.map((p) => [p.productId, p])).values()];
console.log(`${unique.length} unique of ${items.length} rows`);

// Rating without volume is noise: 5.0 from 3 ratings is not 4.4 from 18,000.
const trusted = unique.filter((p) => (p.rating ?? 0) >= 4 && (p.numRatings ?? 0) >= 500);
for (const p of trusted.slice(0, 10)) {
  console.log(`${p.rating}★ (${p.numRatings})  ₹${p.currentPrice ?? '—'}  ${p.title}`);
}

cURL — synchronous (waits, returns the dataset)

curl -X POST \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{
        "searchQuery": "wireless earbuds",
        "maxProducts": 24,
        "sortBy": "popularity",
        "deliveryMode": "none",
        "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
      }' \
  'https://api.apify.com/v2/acts/techforce.global~flipkart-scraper/run-sync-get-dataset-items'

cURL — asynchronous with a spend cap (recommended for large runs)

# 1. Start with a hard spend limit
curl -X POST -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{ "searchQuery": "laptop", "category": "Laptops", "maxProducts": 2000,
        "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" } }' \
  'https://api.apify.com/v2/acts/techforce.global~flipkart-scraper/runs?maxTotalChargeUsd=10'

# 2. Poll, then 3. fetch the dataset when SUCCEEDED
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' 'https://api.apify.com/v2/actor-runs/<runId>'
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&format=json'

Deal hunting — biggest discounts first

{
  "searchQuery": "bluetooth speaker",
  "category": "Any",
  "maxProducts": 500,
  "sortBy": "price_asc",
  "deliveryMode": "none",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
}

Flipkart has no "sort by discount", so pull a wide set cheaply and sort on discountPercent yourself — filtering to fAssured: true and numRatings >= 500 weeds out the inflated-MRP listings that dominate a naive discount sort.

Precise category scoping

{
  "searchQuery": "gaming",
  "category": "Laptops",
  "maxProducts": 200,
  "sortBy": "popularity",
  "deliveryMode": "none",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
}

Laptops is one of the four categories backed by a real Flipkart store id, so this is a genuine category filter rather than an extra search word.

Price tracking on a schedule

{
  "searchQuery": "samsung galaxy s24",
  "category": "Mobiles",
  "maxProducts": 50,
  "sortBy": "relevance",
  "deliveryMode": "none",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
}

Put a fixed input on a schedule and join runs on productId to build the price history a single run can't give you.

With MCP delivery — a deals digest into Slack

{
  "searchQuery": "wireless earbuds",
  "maxProducts": 30,
  "sortBy": "popularity",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" },
  "mcpConnector": "<your-authorized-slack-connector>",
  "mcpTool": "send_message",
  "deliveryMode": "summary",
  "mcpMessageTemplate": "Top {count} results for {searchQuery}:\n\n{products}",
  "mcpArguments": { "channel": "#deals", "text": "{message}" }
}

Set summary deliberately — perProduct is the default and would post one Slack message per product.

---

⚠️ Autonomous Agent Error Handling & Resolution Matrix

Read this first: only a missing searchQuery fails the run. Blocks, empty searches and unrecognised layouts all end SUCCEEDED with a thin or empty dataset while the log carries the reason — check the row count and the log, not just the run status.

The CONDITION labels are documentation handles for observable states; this Actor writes no error code into the dataset.

Condition	What you observe	Cause	Deterministic agent action
MISSING_SEARCH_QUERY	Run FAILS: Input "searchQuery" is required.	searchQuery absent or blank	Modify Input: supply a non-empty query string.
ARRAY_PASSED_AS_QUERY	Validation error on type	searchQuery is a string, not an array	Modify Input: one query; run once per keyword.
NO_PROXY_CONFIGURED	Log: No proxy configured. Flipkart will very likely block these requests.	Proxy omitted or unusable	Modify Input: residential proxy with apifyProxyCountry: "IN".
BLOCKED_OR_EMPTY_GRID	Log: No product tiles found on page N and/or Parsed 0 products from page N; SUCCEEDED, empty dataset	Bot wall, non-Indian exit IP, or a genuinely empty search	Retry with residential + IN exit, lower maxConcurrency to 1–2, and confirm the query returns results in a browser.
FEWER_ROWS_THAN_MAXPRODUCTS	Dataset smaller than requested	Pages are pre-computed at ~24 products each and aren't topped up	Expected. Raise maxProducts to over-provision, or accept the ceiling.
CATEGORY_DID_NOT_FILTER	Results look off-topic or unexpectedly narrow	That category appends a keyword to the query instead of scoping it	Modify Input: use Any and word the query yourself, or pick a store-id category.
NULL_PRICE	currentPrice null	The card displayed no price	Expected. Null ≠ zero — exclude from averages.
NULL_DISCOUNT	discountPercent null	No MRP shown, or no discount	Expected. Filter on non-null before ranking deals.
DISCOUNT_OFF_BY_ONE	Your figure differs from Flipkart's badge	It's computed from the two prices, not copied from the badge	Fix expectation, or recompute from currentPrice/originalPrice.
SELLER_IS_NULL	seller empty on most rows	Search cards rarely name a seller	Expected. Seller data lives on the product page, which this Actor doesn't open.
DUPLICATE_PRODUCTS	Same productId twice	De-duplication is per page; Flipkart repeats across pages	Fix consumer: dedupe on productId.
NO_RANK_FIELD	You wanted a rank column	Pages run in parallel; row order is crawl order and sponsored tiles aren't flagged	Fix expectation. Sort by a field you trust instead.
RATING_LOOKS_INFLATED	5.0 products topping your sort	rating without numRatings is noise	Fix consumer: require a minimum numRatings.
RUN_SLOW_OR_THROTTLED	Long run, rising warnings	maxConcurrency too high for Flipkart's tolerance	Modify Input: drop to 1–2.
HEADFUL_RUN_FAILS	Browser fails to start on the platform	headless was set to false	Modify Input: leave headless at true.
FREE_PLAN_CAPPED	5 products; log: Free plan detected - capping results to 5 products this run	Free Apify plan	Upgrade the plan.
CONNECTOR_CALL_STORM	Hundreds of connector calls	deliveryMode defaults to perProduct, uncapped	Modify Input: switch to summary or none.
CONNECTOR_TOOL_NOT_FOUND	Log: Tool 'x' is not available on this connector. Available tools: …	Wrong mcpTool name (empty is logged separately)	Modify Input: copy an exact name from that log line. Dataset unaffected.
CONNECTOR_UNREACHABLE	Log: Could not reach the connector: … or APIFY_MCP_PROXY_URL is not set	Connector not authorised, or running locally	Authorise it, or apify push and run on the platform. Data already saved.
AUTH_INVALID	HTTP 401	Missing or malformed APIFY_TOKEN	Abort & prompt user for a valid token.
RATE_LIMITED_APIFY	HTTP 429	Apify API rate / concurrency limits — not Flipkart	Retry: exponential backoff (2s, 4s, 8s).
SYNC_TIMEOUT	HTTP 408 on the sync endpoint	Run exceeded the synchronous ceiling	Reconfigure: async POST /runs + polling.

Provenance: every log line, status and dataset condition above is taken from this Actor's own source and verified against it. The three HTTP rows describe the Apify API transport layer, not this Actor — confirm them against the Apify API reference before wiring them into automated retry logic.

---

🗣️ Natural Language → Actor Mapping

A user says…	Intent	Constructed Actor input
"Find wireless earbuds on Flipkart"	Core search	{"searchQuery":"wireless earbuds","maxProducts":50}
"Cheapest laptops on Flipkart"	Price sweep	{"searchQuery":"laptop","category":"Laptops","sortBy":"price_asc"}
"What's most popular for X?"	Popularity	{"searchQuery":"X","sortBy":"popularity"}
"Newest arrivals for X"	Recency	{"searchQuery":"X","sortBy":"recency_desc"}
"Biggest discounts on speakers"	Deal hunting	Wide pull, then sort on discountPercent (Flipkart has no discount sort)
"Only Flipkart Assured products"	Quality filter	Scrape, then filter fAssured: true
"Well-rated products only"	Quality filter	Filter rating >= 4 and numRatings >= 500
"Track this phone's price daily"	Monitoring	Fixed input on a schedule; join runs on productId
"Get me 2,000 results"	Bulk pull	{"searchQuery":"X","maxProducts":2000} plus maxTotalChargeUsd
"Search these five keywords"	Multi-keyword	Five runs — searchQuery takes one string
"Scrape this Flipkart product URL"	URL input	❌ Not supported — search by the product's name instead
"What are the specs?"	Product detail	❌ Search cards only — no product page is opened
"Send today's deals to Slack"	Scrape + deliver	Above, plus mcpConnector, mcpTool, deliveryMode: "summary"
"It returned nothing"	Empty result	Check the proxy is residential with an Indian exit, and that the query has results
"Compare with Amazon prices"	Cross-retailer	➡️ Pair with Amazon Product Scraper
"Buy it for me"	Write action	❌ Read-only

Should NOT route here: product-page detail — specs, descriptions, variants, stock · review text or reviewer identities · several keywords in one run · product or category URLs as input · seller catalogues or seller ratings · purchasing or any write action · non-Flipkart retailers — use Amazon Product Scraper, Etsy Scraper or Quince Scraper for those catalogues.

---

🧭 Agent Execution & Routing Logic

Does the user want FLIPKART SEARCH results as data?
├── NO → wrong Actor.
│        Amazon (incl. amazon.in)  → Amazon Product Scraper
│        Etsy handmade / vintage   → Etsy Scraper
│        Quince (DTC storefront)   → Quince Scraper
│        a product page's specs    → not available here
│
└── YES
    │
    ├── searchQuery — REQUIRED, a SINGLE string. Missing = the run FAILS.
    │     several keywords? → ONE RUN PER KEYWORD
    │
    ├── ALWAYS keep the residential proxy with apifyProxyCountry "IN"
    │
    ├── Category?
    │     ├── Mobiles / Laptops / Home & Furniture / Books → true store-id scoping
    │     ├── any other category → APPENDS A KEYWORD to your query (loosens it)
    │     └── unsure → "Any" and word the query yourself
    │
    ├── How should Flipkart sort before scraping?
    │     ├── cheapest first → price_asc      ├── newest → recency_desc
    │     ├── popular        → popularity     └── default → relevance
    │     └── biggest discount? NOT a Flipkart sort — pull wide, sort discountPercent yourself
    │
    ├── How many? maxProducts (1-2000)
    │     ├── a probe    → 24 (one page)
    │     ├── analysis   → 100-500
    │     └── bulk       → up to 2000 + maxTotalChargeUsd
    │     └── pages are pre-computed at ~24/page → thin pages mean fewer rows
    │
    ├── What is the actual question?
    │     ├── cheapest        → sort currentPrice, EXCLUDING nulls
    │     ├── best deal       → discountPercent + a numRatings floor (MRPs get inflated)
    │     ├── best rated      → rating AND numRatings together
    │     ├── trusted only    → fAssured true
    │     └── price over time → SCHEDULE it; join runs on productId
    │
    └── Should results land in another app?
          ├── yes → mcpConnector + mcpTool + {message} in mcpArguments
          │           digest → summary   ·   record each → perProduct (DEFAULT, UNCAPPED)
          └── no  → deliveryMode "none", or leave mcpConnector empty

[Execute Actor]
    ├──► SUCCEEDED with rows → dedupe on productId, then sort/filter
    ├──► SUCCEEDED, 0 rows   → READ THE LOG: blocked / no tiles / no matches
    ├──► exactly 5 rows      → free plan cap, not a data pull
    └──► FAILED              → searchQuery was missing; fix the input

---

💰 Cost Control & Pricing Transparency

Billing model: usage-based. This Actor bills for platform usage — the compute time and resources a run consumes — not per row. Current rates are on the Actor's Apify Store page; the Console shows the live total mid-run.

The shape to keep in mind: cost tracks result pages, not products. One page carries roughly 24 products, so 24 products and 100 products differ by about four page loads — not by 76 requests. Each page is a headless browser navigation, which is what makes those pages the expensive unit.

Choice	Effect on cost
maxProducts	The main lever, via the page count: ceil(maxProducts / 24) pages, capped at 100.
maxConcurrency	Faster wall-clock when Flipkart tolerates it; throttling makes it slower, not cheaper.
category	No cost effect — it only changes the URL.
sortBy	No cost effect.
Being blocked	Pages load, parse nothing, and retry. A datacenter proxy is the most expensive setting on this page.

Worked examples — relative run shape

Scenario	Pages	Products	Notes
Probe — maxProducts: 24	1	≤ 24	Baseline. Confirms proxy and query in one page load.
Standard research — 100	~5	≤ 100	The common shape.
Category sweep — 500	~21	≤ 500	Still modest; browser pages dominate the time.
Bulk pull — 2,000	~84	≤ 2,000	Set maxTotalChargeUsd. Close to the 100-page ceiling.
Five keywords × 100	~25 total	≤ 500	Five separate runs — searchQuery is one string.
Blocked run	pages load	0 useful	Worst value on this page.

Keeping runs predictable:

1. First run: maxProducts: 24. One page proves the proxy, the query and the category behaviour in the cheapest possible way.
2. Over-provision slightly when you need a specific count — thin pages mean fewer rows.
3. Keep maxConcurrency at 1–2. Throttling costs more than patience does.
4. Always set maxTotalChargeUsd for runs in the high hundreds or at 2,000.
5. Schedule small and often rather than one huge sweep — cheaper, and it builds price history.
6. Free Apify plans get 5 products per run — a connectivity check, not a data pull.

---

🛠️ Troubleshooting

Most problems are the proxy, the category filter, or the pre-computed page count — not parser bugs.

#	Symptom you see	Most likely cause	Fix
1	Run FAILED immediately	searchQuery missing or blank — it's the one required input	Supply a non-empty query string.
2	SUCCEEDED but the dataset is empty	Flipkart served no tiles — bot wall, wrong exit country, or a query with no matches	Check the log for No product tiles found / Parsed 0 products. Use residential + IN, drop maxConcurrency to 1, and confirm the query works in a browser.
3	Results look off-topic	A keyword-based category appended a word to your query	Use Any, or one of the four store-id categories (Mobiles, Laptops, Home & Furniture, Books).
4	Fewer products than maxProducts	Pages are pre-computed at ~24 each and not topped up; or the search has fewer matches	Over-provision maxProducts, or accept the ceiling.
5	currentPrice is null on some rows	Those cards displayed no price	Expected — exclude them rather than treating them as 0.
6	discountPercent is null	No struck-through MRP on the card, or no discount	Expected. Filter to non-null before ranking deals.
7	Discount differs from Flipkart's badge by a point	It's computed from the two prices, not copied	Expected — recompute yourself if you need the badge's exact rounding.
8	Absurd discounts topping your sort	Inflated MRPs are common on marketplace listings	Add a numRatings floor and fAssured: true before ranking.
9	seller is null nearly everywhere	Search cards rarely expose a seller	Expected — seller lives on the product page, which this Actor doesn't open.
10	No specs or description in the output	Search cards only, by design	Out of scope for this Actor.
11	The same product appears twice	De-duplication is per page; Flipkart repeats across pages	Dedupe on productId.
12	Rows aren't in the order Flipkart showed	Pages are fetched in parallel; there is no rank field	Sort client-side on a field you trust.
13	5.0-star products with 3 ratings ranking first	Rating without volume	Require numRatings >= 500 (or whatever suits the category).
14	Run is slow or warnings pile up	maxConcurrency too high	Drop to 1–2.
15	Browser fails to start on the platform	headless was set to false	Leave it true; the containers have no display.
16	Only 5 products came back	Free plan cap	Upgrade; the log says Free plan detected - capping results to 5 products this run.
17	Hundreds of connector calls fired	deliveryMode defaults to perProduct and is uncapped	Switch to summary or none.
18	Slack / Notion received nothing	Delivery needs both mcpConnector and mcpTool	Set both. Every dataset row is still saved.
19	Log: APIFY_MCP_PROXY_URL is not set	Ran locally; connectors only resolve on the platform	apify push and run on the platform.
20	HTTP 401 / 403 from the Apify API	Missing, expired or malformed APIFY_TOKEN	Regenerate in Console → Settings → API & Integrations.
21	HTTP 429 / 408 from the Apify API	Apify rate limits / the sync endpoint's time ceiling	Back off (2s → 4s → 8s), or switch to async POST /runs + polling.

Diagnostic checklist before opening an issue

1. Confirm searchQuery is set — a missing one fails the run outright.
2. Confirm the proxy is residential with apifyProxyCountry: "IN".
3. Baseline run: your query, category: "Any", maxProducts: 24, maxConcurrency: 1, deliveryMode: "none".
4. Open the same search on flipkart.com — if it returns nothing there, no scraper can help.
5. Read the log — it names the query, category, sort and page count actually used, then reports per-page counts.
6. Try category: "Any" if results look wrong; that removes the keyword-appending behaviour.

If the issue survives all six, open an Issues ticket (or email support) with the run ID, the input you used, and what you expected.

---

❓ FAQ

Do I need a Flipkart account or API key?

No. The Actor reads publicly visible search results. You need an Apify account and API token; you need no Flipkart credentials of any kind.

Is this an official Flipkart API?

No. This is an independent Actor and is not affiliated with, endorsed by, or sponsored by Flipkart Internet Private Limited. Flipkart publishes no public product-search API for third parties, which is why this Actor exists.

Do I need a paid Apify plan?

In practice, yes. Flipkart blocks datacenter traffic and serves by exit-IP country, so the default residential proxy with an Indian exit — which requires a paid plan — is what makes runs work.

Can I plug it into Claude, Cursor, or a LangChain agent?

Yes — it is a native MCP tool: claude mcp add --transport http apify "https://mcp.apify.com?tools=techforce.global/flipkart-scraper"

Can I search several keywords in one run?

No. searchQuery is a single string, and it's the one required input — omitting it fails the run. Run the Actor once per keyword and combine the datasets afterwards.

Can I pass a product URL or a category URL instead?

No. The only entry point is a search query, exactly as you'd type it into Flipkart's search bar. To target a specific product, search for its name and match on title or productId.

Does the category filter really filter?

Only for four of them. Mobiles, Laptops, Home & Furniture and Books scope the search with a real Flipkart store id. Every other category appends a keyword to your query — Electronics searches "<your query> electronics" — which loosens rather than filters. Use Any when you want your query taken literally.

Why did I get fewer products than I asked for?

The run works out how many result pages it needs (about 24 products each) and enqueues them up front. If Flipkart serves thinner pages, or the search simply has fewer matches, you get fewer rows — the Actor doesn't add pages to compensate. Over-provision maxProducts if you need a specific count.

Why is currentPrice or discountPercent null?

currentPrice is null when the card showed no price. discountPercent is null when there's no struck-through MRP or no discount — it's computed as round((originalPrice − currentPrice) / originalPrice × 100), so it needs both prices. Null is not zero.

Why doesn't my discount match Flipkart's badge?

Because it's calculated from the two prices on the card rather than copied from the badge, so rounding can differ by a point. If the badge's exact figure matters, recompute from currentPrice and originalPrice with your own rule.

Why is seller almost always null?

Search cards rarely name a seller — that information lives on the product page, and this Actor never opens one. Everything you get is parsed from the results tile.

Can I get specifications, descriptions or variants?

No. Search cards only. If you need product-page detail, that's a different scrape.

Can I get review text?

No — only numRatings and numReviews, which are different figures on Flipkart (written reviews are normally far fewer than star ratings). No reviewer names or review bodies are collected.

How do I find genuine deals rather than inflated MRPs?

Sort on discountPercent, but gate it: require a sensible numRatings floor and consider filtering to fAssured: true. A 90%-off listing with 4 ratings is usually an inflated MRP, not a bargain.

Can the same product appear twice?

Yes. De-duplication happens within a results page, and Flipkart sometimes repeats a product across pages. Dedupe on productId downstream.

Is there a rank or position field?

No. Pages are fetched in parallel, so row order is crawl order, and sponsored tiles aren't flagged. Don't infer ranking from the dataset order.

Which delivery mode should I use, and does it work locally?

summary for one digest of the run; perProduct — the default — sends one connector call per product with no cap, so a 500-product run is 500 calls; none for dataset-only runs. Delivery only works on the Apify platform; locally you'll see APIFY_MCP_PROXY_URL is not set and the dataset saves as normal.

What does it cost, and what do I get on the free plan?

Usage-based: you pay for the platform usage a run consumes, not per row. Cost tracks result pages (~24 products each), so a 100-product run is about five page loads. Free Apify plans return 5 products per run. Pass maxTotalChargeUsd for a hard per-run ceiling.

---

🔍 Companion machine-readable files

File	What it defines
.actor/input_schema.json	Every input, its type, default, bounds and the category/sort enums
.actor/dataset_schema.json	All 13 output fields with nullability, and the three Console views
.actor/output_schema.json	Where the run's output is exposed
.actor/actor.json	Actor identity and storage wiring

If this page and the schema files disagree, the schema files win. They are what the platform validates against at run time; this page is documentation and can lag a release.

---

🔗 Related Actors by Techforce Global

Actor	Best for	Why pair it with this one
Amazon Product Scraper	Amazon listings across 7 marketplaces, including amazon.in	India's other major marketplace — the direct price comparison for the same product set
Etsy Scraper	Listings from Etsy's handmade and vintage marketplace	A different supply side to the same categories: small sellers, handmade and vintage pricing
Quince Scraper	Catalogue and pricing from Quince	A direct-to-consumer brand storefront, where marketplace dynamics don't apply

Pipeline patterns: India price comparison — the same search through this Actor and Amazon (amazon.in), matched on brand and model, to see which marketplace is actually cheaper · deal monitoring — a scheduled search, filtered to discountPercent above your threshold with a numRatings floor, digested into Slack via MCP · category intelligence — a wide popularity sweep, tracking which brands hold the first pages over time · listing QA — your own products on a schedule, watching currentPrice, rating and the fAssured badge for regressions.

Browse all Actors by Techforce Global at scraper.techforce.global.

---

🔐 Compliance & Data Privacy

Trademark & affiliation. This is an independent Actor. It is not affiliated with, endorsed by, or sponsored by Flipkart Internet Private Limited. Flipkart™ and Flipkart Assured are trademarks of their respective owners.

• Public search results only. Everything returned is visible to any signed-out visitor. No account login, no order or cart data, no seller dashboards, no credentials of any kind.

• Almost no personal data — by design. Product listings are commercial content. This Actor collects no review text, no reviewer names and no reviewer profiles, only the rating and review counts. seller, where present, is a business name rather than an individual. That keeps a straightforward position under India's DPDP Act and under GDPR/CCPA for most uses.

• Prices are observations, not facts about the market. Flipkart's prices, badges and availability shift constantly and vary by campaign. What you capture is what that page showed at that moment, through an Indian exit IP. Publishing "the price of X" from a single run produces a number that looks authoritative and isn't.

• Discounts deserve scepticism, not just arithmetic. discountPercent is computed from the MRP the seller chose to display. Inflated list prices are widespread on marketplaces, so presenting a high discountPercent as a verified saving can mislead — pair it with rating volume before you publish or act on it.

• Listing content belongs to its owners. Titles and images are the brand's or seller's material, and image points at Flipkart's CDN rather than to files you own. Internal analysis, monitoring and research sit on far safer ground than republishing scraped listings as your own catalogue.

• Flipkart's Terms of Use restrict automated access and data extraction. This Actor does not remove that risk — it is a risk you accept by running it. Keep volumes proportionate to the question you're answering; repeated large-scale crawling is what draws enforcement.

• Competition-law caution for price data. Monitoring competitor prices is ordinary business intelligence; using them to coordinate or align pricing with competitors is not. If your use touches automated repricing, take advice.

• Attribution over mirroring. Every row carries url and productId. Link back to the listing rather than presenting Flipkart's catalogue as your own.

---

🆘 Support & Custom Pipeline Engineering

Need automated multi-city scheduled feeds, webhook enrichment, or enterprise data warehouse syncs?

• Email: bhavin.shah@techforceglobal.com
• Custom Enterprise Integrations: Book a 15-Minute Technical Consultation
• Maintained by: Techforce Global — Specialists in High-Performance Web Scrapers and Agentic Workflows.

---

---

🏷️ Structured data for search & AI discovery

SoftwareApplication describes the Actor; FAQPage wraps the FAQ above so those answers are eligible for rich results, matching it question-for-question.

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Flipkart Scraper",
  "alternateName": "Flipkart Search Scraper",
  "applicationCategory": "BusinessApplication",
  "applicationSubCategory": "Web Scraping / E-commerce & Price Intelligence",
  "operatingSystem": "Cloud (Apify platform)",
  "description": "Runs a Flipkart search exactly as the site's own search bar does — one keyword, an optional category filter and a sort order — and returns up to 2,000 products as flat rows without a Flipkart account, login or API key. Each row carries the product id, title, URL, image, selling price and struck-through MRP in INR, a computed discount percentage, star rating, rating and review counts, seller where the card exposes one, and the Flipkart Assured badge. Runs through a residential proxy with an Indian exit IP, and results can be delivered into Notion, Slack, Linear, Airtable or any MCP connector.",
  "url": "https://apify.com/techforce.global/flipkart-scraper",
  "author": { "@type": "Organization", "name": "Techforce Global", "url": "https://www.techforceglobal.com" },
  "provider": { "@type": "Organization", "name": "Apify", "url": "https://apify.com" },
  "offers": {
    "@type": "Offer",
    "priceCurrency": "USD",
    "category": "Pay per platform usage",
    "description": "Usage-based: billed for the compute time and resources a run consumes, not per row. Cost tracks result pages of roughly 24 products each. Current rates are shown on the Actor's Apify Store page.",
    "url": "https://apify.com/techforce.global/flipkart-scraper"
  },
  "featureList": [
    "No Flipkart account, login or API key required",
    "One search query, exactly as the site's own search bar interprets it",
    "Up to 2,000 products per run with automatic pagination",
    "Selling price and struck-through MRP in whole rupees, plus a computed discount percentage",
    "Star rating with rating count and written-review count as separate figures",
    "Flipkart Assured badge as a boolean on every row",
    "14 category options, four of them backed by a real Flipkart store id",
    "Five sort modes: relevance, popularity, price low-to-high, price high-to-low, newest",
    "Attribute-anchored parser resilient to Flipkart's rotating CSS class names",
    "Residential proxy with an Indian exit IP by default",
    "Rows saved as they are scraped, so aborted runs keep their partial data",
    "Optional MCP delivery to Notion, Slack, Linear, Airtable and more",
    "Three Console dataset views covering products, deals and sellers"
  ],
  "isAccessibleForFree": false,
  "softwareRequirements": "Apify account and API token; a paid plan for residential proxies",
  "keywords": "Flipkart scraper, Flipkart price scraper, scrape Flipkart search results, Flipkart product data, India ecommerce price monitoring, discount tracker, competitor price tracking, product listing export, MCP connector"
}

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do I need a Flipkart account or API key?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. The Actor reads publicly visible search results. You need an Apify account and API token; you need no Flipkart credentials of any kind." }
    },
    {
      "@type": "Question",
      "name": "Is this an official Flipkart API?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. This is an independent Actor and is not affiliated with, endorsed by, or sponsored by Flipkart Internet Private Limited. Flipkart publishes no public product-search API for third parties, which is why this Actor exists." }
    },
    {
      "@type": "Question",
      "name": "Do I need a paid Apify plan?",
      "acceptedAnswer": { "@type": "Answer", "text": "In practice, yes. Flipkart blocks datacenter traffic and serves by exit-IP country, so the default residential proxy with an Indian exit — which requires a paid plan — is what makes runs work." }
    },
    {
      "@type": "Question",
      "name": "Can I plug it into Claude, Cursor, or a LangChain agent?",
      "acceptedAnswer": { "@type": "Answer", "text": "Yes — it is a native MCP tool: claude mcp add --transport http apify \"https://mcp.apify.com?tools=techforce.global/flipkart-scraper\"" }
    },
    {
      "@type": "Question",
      "name": "Can I search several keywords in one run?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. searchQuery is a single string, and it's the one required input — omitting it fails the run. Run the Actor once per keyword and combine the datasets afterwards." }
    },
    {
      "@type": "Question",
      "name": "Can I pass a product URL or a category URL instead?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. The only entry point is a search query, exactly as you'd type it into Flipkart's search bar. To target a specific product, search for its name and match on title or productId." }
    },
    {
      "@type": "Question",
      "name": "Does the category filter really filter?",
      "acceptedAnswer": { "@type": "Answer", "text": "Only for four of them. Mobiles, Laptops, Home & Furniture and Books scope the search with a real Flipkart store id. Every other category appends a keyword to your query — Electronics searches \"<your query> electronics\" — which loosens rather than filters. Use Any when you want your query taken literally." }
    },
    {
      "@type": "Question",
      "name": "Why did I get fewer products than I asked for?",
      "acceptedAnswer": { "@type": "Answer", "text": "The run works out how many result pages it needs (about 24 products each) and enqueues them up front. If Flipkart serves thinner pages, or the search simply has fewer matches, you get fewer rows — the Actor doesn't add pages to compensate. Over-provision maxProducts if you need a specific count." }
    },
    {
      "@type": "Question",
      "name": "Why is currentPrice or discountPercent null?",
      "acceptedAnswer": { "@type": "Answer", "text": "currentPrice is null when the card showed no price. discountPercent is null when there's no struck-through MRP or no discount — it's computed as round((originalPrice − currentPrice) / originalPrice × 100), so it needs both prices. Null is not zero." }
    },
    {
      "@type": "Question",
      "name": "Why doesn't my discount match Flipkart's badge?",
      "acceptedAnswer": { "@type": "Answer", "text": "Because it's calculated from the two prices on the card rather than copied from the badge, so rounding can differ by a point. If the badge's exact figure matters, recompute from currentPrice and originalPrice with your own rule." }
    },
    {
      "@type": "Question",
      "name": "Why is seller almost always null?",
      "acceptedAnswer": { "@type": "Answer", "text": "Search cards rarely name a seller — that information lives on the product page, and this Actor never opens one. Everything you get is parsed from the results tile." }
    },
    {
      "@type": "Question",
      "name": "Can I get specifications, descriptions or variants?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. Search cards only. If you need product-page detail, that's a different scrape." }
    },
    {
      "@type": "Question",
      "name": "Can I get review text?",
      "acceptedAnswer": { "@type": "Answer", "text": "No — only numRatings and numReviews, which are different figures on Flipkart (written reviews are normally far fewer than star ratings). No reviewer names or review bodies are collected." }
    },
    {
      "@type": "Question",
      "name": "How do I find genuine deals rather than inflated MRPs?",
      "acceptedAnswer": { "@type": "Answer", "text": "Sort on discountPercent, but gate it: require a sensible numRatings floor and consider filtering to fAssured true. A 90%-off listing with 4 ratings is usually an inflated MRP, not a bargain." }
    },
    {
      "@type": "Question",
      "name": "Can the same product appear twice?",
      "acceptedAnswer": { "@type": "Answer", "text": "Yes. De-duplication happens within a results page, and Flipkart sometimes repeats a product across pages. Dedupe on productId downstream." }
    },
    {
      "@type": "Question",
      "name": "Is there a rank or position field?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. Pages are fetched in parallel, so row order is crawl order, and sponsored tiles aren't flagged. Don't infer ranking from the dataset order." }
    },
    {
      "@type": "Question",
      "name": "Which delivery mode should I use, and does it work locally?",
      "acceptedAnswer": { "@type": "Answer", "text": "summary for one digest of the run; perProduct — the default — sends one connector call per product with no cap, so a 500-product run is 500 calls; none for dataset-only runs. Delivery only works on the Apify platform; locally you'll see APIFY_MCP_PROXY_URL is not set and the dataset saves as normal." }
    },
    {
      "@type": "Question",
      "name": "What does it cost, and what do I get on the free plan?",
      "acceptedAnswer": { "@type": "Answer", "text": "Usage-based: you pay for the platform usage a run consumes, not per row. Cost tracks result pages (~24 products each), so a 100-product run is about five page loads. Free Apify plans return 5 products per run. Pass maxTotalChargeUsd for a hard per-run ceiling." }
    }
  ]
}