How to Monitor Flipkart Prices in India

Pipeline stages from request to verified data

1. Discover SKUs

   Maintain a watchlist of pid/listing IDs from category crawls, brand catalogs, or merchant feeds — deduped and prioritized by revenue impact

2. Fetch from IN exit

   Each listing request routes through -country-in residential on port 2099 with en-IN Accept-Language so Flipkart returns the Indian marketplace view

3. Parse listing payload

   Extract selling price, MRP, availability, seller rating, and delivery SLA from embedded JSON or product API responses

4. Normalize INR

   Store amounts as integer paise or decimal INR with explicit currency field; strip ₹ symbols and thousands separators deterministically

5. Alert on change

   Diff against last snapshot; notify when selling price moves beyond threshold or stock flips — attach pid, old/new price, and timestamp

How to build each pipeline stage

1. 1

   Build a pid-keyed watchlist with priority tiers

   Ingest SKUs from search/category discovery or merchant CSVs. Normalize to Flipkart product IDs, strip tracking query params, and tag priority (hero SKUs hourly, long tail daily). Store last-seen URL only as metadata — pid is the join key.

   Field note: Flipkart runs A/B listing layouts; pid survives redesigns while CSS selectors do not.

2. 2

   Fetch listings through Indian residential proxies

   Route every HTTP call through -country-in on port 2099. Send en-IN Accept-Language and a current mobile or desktop Chrome User-Agent. Detect soft blocks: 200 responses with empty product objects or captcha interstitials.

   Python (requests)Copy

   import requests
   
   PROXY = "http://aethyn-XXXXX-country-in:PASSWORD@proxy.aethyn.io:2099"
   proxies = {"http": PROXY, "https": PROXY}
   HEADERS = {
       "User-Agent": "Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 Chrome/124.0 Mobile Safari/537.36",
       "Accept-Language": "en-IN,en;q=0.9,hi;q=0.8",
   }
   
   def fetch_listing(pid):
       url = f"https://www.flipkart.com/api/3/page/dynamic/product?pid={pid}"
       r = requests.get(url, headers=HEADERS, proxies=proxies, timeout=30)
       if r.status_code != 200:
           raise FetchError(r.status_code)
       return r.json()

   Field note: If you get 200 with an empty product node, verify the exit is actually IN — a mismatched country suffix is the most common cause of silent wrong-geo data.

3. 3

   Parse selling price, MRP, and availability separately

   Walk the JSON defensively with .get() chains. Persist sellingPrice, mrp, availabilityState, and sellerName as distinct columns. Treat missing MRP as null, not zero — zero implies free, which is rare and alarming.

   Python (parse)Copy

   def parse_price(payload):
       slots = payload.get("RESPONSE", {}).get("slots", [])
       for slot in slots:
           widget = slot.get("widget", {})
           data = widget.get("data", {})
           if "pricing" in data:
               p = data["pricing"]
               return {
                   "selling_inr": p.get("finalPrice", {}).get("value"),
                   "mrp_inr": p.get("mrp", {}).get("value"),
                   "in_stock": data.get("availability", {}).get("displayState") == "IN_STOCK",
               }
       return None

   Field note: Bank-offer discounts often appear as separate coupon widgets — decide upfront whether your alert logic tracks sticker price or net-after-coupon and stay consistent.

4. 4

   Normalize INR and store history

   Convert string amounts ('₹1,799') to integer paise (179900) for diffing without float error. Append (pid, selling_paise, mrp_paise, in_stock, captured_at) to time-series storage. Index pid + captured_at for trend queries.

   Field note: Store raw JSON snapshots for disputed alerts — when Flipkart changes widget shape, you can replay parse logic without re-fetching.

5. 5

   Alert with hysteresis to cut promo noise

   Fire alerts when selling price moves more than your threshold (e.g. 3%) or stock status flips. Require two consecutive observations for small moves to ignore single-request glitches during CDN cache churn.

What goes wrong when this scraper fails

Brands and resellers tracking Flipkart need hourly visibility into price moves, flash sales, and stockouts across thousands of listings. Crawling from non-Indian datacenter IPs yields HTTP errors, empty shells, or prices in the wrong fulfillment context. Even Indian VPS hosts get blocked quickly when velocity rises. The pipeline must be geo-correct at the fetch layer and semantically correct at the parse layer — confusing MRP with selling price creates false promo alerts that erode trust in the dashboard.

Challenges that make this hard to automate

• Geo-gating requires Indian residential exits, not just a VPN flag
• Multiple price fields (MRP, FSP, coupon) with different business meaning
• Listing URLs carry session noise — pid is the durable key
• Flash sales spike velocity and trigger temporary blocks
• Seller marketplace vs Flipkart Assured mix affects trust metrics

How Aethyn residential proxies help here

Flipkart monitoring is a geo-precision workload on a cost-sensitive catalog size. Premium tier with -country-in delivers the right exit geography without Elite pricing on every SKU.

• Premium pool on port 2099 with -country-in for India-local pricing
• Per-request rotation to survive sale-event velocity spikes
• Sticky sessions when a multi-step flow needs cookie continuity
• Per-byte billing so nightly full-catalog refreshes stay predictable
• Same endpoint pattern as other marketplaces — one integration, many countries

Common questions about this scraper problem

Best practices that keep scrapers reliable

• Key on pid; treat URLs as disposable metadata
• Always fetch through -country-in on port 2099
• Separate MRP, selling price, and coupon discounts in schema
• Normalize INR to integer paise for reliable diffs
• Tier crawl frequency by SKU revenue impact
• Keep raw JSON snapshots for parser regression testing

Common mistakes that burn proxy budget

• Pricing from US/EU exits and trusting INR amounts
• Alerting on MRP strikethrough instead of selling price
• Using CSS selectors as primary parse path
• No hysteresis — alert spam on single-glitch fetches
• Ignoring stock flips that precede price changes
• Flash-sale concurrency from few IPs — mass 403 during events