Monitor Snapdeal vs Flipkart India Pricing for the Same SKUs

Thirdwatch's Snapdeal Scraper and Flipkart Scraper let growth and ops teams run side-by-side price diffs across India's value and premium marketplaces. This guide walks the full pattern: parallel keyword sweeps, fuzzy SKU matching, and cross-marketplace delta alerting.

Why monitor Snapdeal vs Flipkart for the same SKUs

Snapdeal and Flipkart sit on opposite ends of the Indian e-commerce price spectrum. Flipkart is the premium-leaning marketplace — branded SKUs, fashion forward, electronics-heavy, with 40%+ India market share by GMV per Walmart's 2024 annual report. Snapdeal is the value-segment marketplace — unbranded apparel, generic kitchenware, Tier 2/3 strongholds, with a Bain India E-commerce 2024 report estimating the value segment at over 60% of new shopper growth. For any category that spans both — bedsheets, kitchenware, mobile accessories, basic apparel — the same product type sells at materially different prices on each platform.

The job-to-be-done is structured. A growth team at a private-label brand wants to know how their Flipkart price compares to comparable Snapdeal listings before adjusting their own. A brand-protection team monitors Snapdeal for unauthorised resellers carrying their SKUs at sub-MSRP value prices, leaking margin from their Flipkart channel. An arbitrage operator looks for SKUs where Snapdeal listings are below Flipkart's, sourcing from one and listing on the other. A consulting analyst building an India e-commerce price index needs both marketplaces represented to capture the full distribution. All reduce to parallel keyword sweeps with fuzzy SKU matching downstream.

How does this compare to alternatives?

Generic Indian retail-monitoring SaaS routinely skips Snapdeal because its value-segment catalog is harder to map. The Snapdeal Scraper and Flipkart Scraper give you both in one consistent interface.

How to monitor Snapdeal vs Flipkart in 4 steps

Step 1: How do I authenticate against Apify?

Sign in at apify.com (free tier, no credit card), open Settings → Integrations, and copy your personal API token. Both actor calls below use the same token:

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: How do I pull both marketplaces in one job?

Run the two actors in parallel with the same keyword list. Persist each result set as a separate snapshot.

import os, requests, datetime, json, pathlib, concurrent.futures

TOKEN = os.environ["APIFY_TOKEN"]
KEYWORDS = [
    "cotton bedsheet double bed",
    "kitchen storage container set",
    "mobile back cover redmi note 13",
    "men formal shirt full sleeve",
    "wall clock decorative",
]

def run(actor, payload):
    resp = requests.post(
        f"https://api.apify.com/v2/acts/{actor}/run-sync-get-dataset-items",
        params={"token": TOKEN},
        json=payload,
        timeout=900,
    )
    return resp.json()

with concurrent.futures.ThreadPoolExecutor(max_workers=2) as ex:
    fut_sd = ex.submit(run, "thirdwatch~snapdeal-scraper",
                       {"queries": KEYWORDS, "maxResults": 50, "sortBy": "popularity"})
    fut_fk = ex.submit(run, "thirdwatch~flipkart-products-scraper",
                       {"queries": KEYWORDS, "maxResults": 50})
    sd, fk = fut_sd.result(), fut_fk.result()

today = datetime.date.today().isoformat()
pathlib.Path("snapshots").mkdir(exist_ok=True)
pathlib.Path(f"snapshots/snapdeal-{today}.json").write_text(json.dumps(sd))
pathlib.Path(f"snapshots/flipkart-{today}.json").write_text(json.dumps(fk))
print(f"Snapdeal: {len(sd)}, Flipkart: {len(fk)}")

5 keywords × ~50 results × 2 marketplaces = ~500 records per day. Both pulls run in parallel and finish in roughly the same wall-clock time as a single one.

Step 3: How do I match the same SKU across both marketplaces?

URLs are not portable across marketplaces, so use fuzzy product-name matching with rapidfuzz. Normalise titles aggressively — lowercase, strip punctuation, collapse whitespace — before scoring.

import pandas as pd, re
from rapidfuzz import process, fuzz

def parse_inr(s):
    if s is None: return None
    digits = re.sub(r"[^\d]", "", str(s))
    return int(digits) if digits else None

def normalize(s):
    s = (s or "").lower()
    s = re.sub(r"[^a-z0-9 ]", " ", s)
    return re.sub(r"\s+", " ", s).strip()

sd_df = pd.DataFrame(sd)
fk_df = pd.DataFrame(fk)
sd_df["price_num"] = sd_df.price
fk_df["price_num"] = fk_df.price.apply(parse_inr)
sd_df["name_norm"] = sd_df.product_name.apply(normalize)
fk_df["name_norm"] = fk_df.title.apply(normalize)

matches = []
fk_index = fk_df.name_norm.tolist()
for _, sd_row in sd_df.iterrows():
    best = process.extractOne(sd_row.name_norm, fk_index, scorer=fuzz.token_set_ratio)
    if best and best[1] >= 80:
        fk_row = fk_df.iloc[best[2]]
        matches.append({
            "sd_title": sd_row.product_name, "fk_title": fk_row.title,
            "sd_price": sd_row.price_num, "fk_price": fk_row.price_num,
            "match_score": best[1],
        })

matched = pd.DataFrame(matches).dropna(subset=["sd_price", "fk_price"])
print(f"{len(matched)} fuzzy matches at 80+ token-set ratio")

A token-set ratio of 80+ is the canonical threshold for "almost certainly the same product type" — high enough to filter false positives, low enough to handle the marketing-copy variability between marketplaces.

Step 4: How do I compute the cross-marketplace price delta and alert on arbitrage?

For each matched pair, compute the relative gap and alert when Snapdeal is materially cheaper than Flipkart (or vice versa).

import requests as r

matched["delta_pct"] = (matched.sd_price - matched.fk_price) / matched.fk_price
matched["abs_delta"] = matched.fk_price - matched.sd_price

# Snapdeal materially cheaper than Flipkart (arbitrage opportunity)
sd_cheaper = matched[matched.delta_pct <= -0.25].sort_values("delta_pct")

for _, row in sd_cheaper.head(10).iterrows():
    r.post("https://hooks.slack.com/services/.../...",
           json={"text": (f"Snapdeal cheaper by {abs(row.delta_pct)*100:.0f}%: "
                          f"*{row.sd_title[:60]}* "
                          f"₹{int(row.sd_price):,} vs Flipkart ₹{int(row.fk_price):,}")},
           timeout=10)

# Flipkart cheaper than Snapdeal (unusual, worth investigating)
fk_cheaper = matched[matched.delta_pct >= 0.25]
print(f"{len(sd_cheaper)} SKUs where Snapdeal is 25%+ cheaper")
print(f"{len(fk_cheaper)} SKUs where Flipkart is 25%+ cheaper (unusual)")

A 25%+ gap is the canonical arbitrage threshold — wide enough to absorb shipping, return-rate friction, and seller-reliability discount, narrow enough to surface in volume. For categories where Flipkart is unexpectedly cheaper, that's usually a Flipkart Big Billion Days promo undercutting Snapdeal's steady-state pricing, which is itself a useful signal for promotion-cycle timing.

Sample output

A matched-pair record after the diff looks like this:

[
  {
    "sd_title": "Cotton Double Bedsheet with 2 Pillow Covers",
    "fk_title": "Cotton Double Bed Sheet With 2 Pillow Covers",
    "sd_price": 549,
    "sd_original_price": 2999,
    "fk_price": 899,
    "fk_original_price": 1999,
    "delta_pct": -0.39,
    "match_score": 94,
    "verdict": "snapdeal_cheaper"
  },
  {
    "sd_title": "Redmi Note 13 Pro Mobile Back Cover",
    "fk_title": "Redmi Note 13 Pro Back Cover Case",
    "sd_price": 199,
    "sd_original_price": 999,
    "fk_price": 249,
    "fk_original_price": 599,
    "delta_pct": -0.20,
    "match_score": 88,
    "verdict": "snapdeal_cheaper"
  }
]

The delta_pct is the load-bearing comparison axis — it normalises across price magnitudes so a INR 50 gap on a INR 200 product weighs the same as a INR 250 gap on a INR 1,000 product. The match_score lets you tune precision-recall in your pipeline: bump to 90+ for tighter matches, drop to 70 for broader category-level signals.

Common pitfalls

Three things go wrong in cross-marketplace pipelines. Non-comparable INR formats — Snapdeal prices arrive as integers; Flipkart prices arrive as strings with Indian comma format (₹1,29,999). Normalise both to integer paise or rupees before comparing. Match-score over-tuning — at 95+ ratio you only catch literally identical titles, which under-counts real overlap; at 60 ratio you start matching across product categories. The 80-85 band is the sweet spot for marketplace-marketplace comparison. Shipping and fee leakage — headline price gaps frequently collapse once Snapdeal's sub-INR 500 shipping charge or Flipkart's plus-membership delivery upgrade is factored in. For pure arbitrage analysis, model the all-in cost, not just the displayed price.

Thirdwatch's actors use production-grade anti-bot infrastructure with India residential routing for both marketplaces. The pure-HTTP architecture means a 500-record cross-marketplace sweep completes in a few minutes. Pair the duo with our Amazon Scraper for tri-marketplace coverage and our Meesho Scraper for the social-commerce value adjacent. A fourth subtle issue: brand variance — Flipkart sellers frequently include brand names in titles, Snapdeal value-segment sellers often omit them. For brand-anchored matching, build a brand alias dictionary or fall back to category-attribute matching.

Related use cases

• Scrape Snapdeal products for India budget e-commerce
• Track Snapdeal pricing for value retail research
• Find Snapdeal bestsellers by category
• Track Flipkart prices vs Amazon India
• Scrape Flipkart products for India e-commerce
• The complete guide to scraping e-commerce
• All Thirdwatch use-case guides