blinkit-scraper 0.1.0__py3-none-any.whl

blinkit_scraper/__init__.py

@@ -0,0 +1,33 @@
+"""Scrape Blinkit category listings and product pages (price, MRP, stock per dark store) with Python."""
+
+from .client import CITIES, BlinkitScraper, ScrapeError
+from .parser import (
+    LISTING_FIELDS,
+    PRODUCT_FIELDS,
+    extract_state,
+    parse_card,
+    parse_cards,
+    parse_category,
+    parse_count,
+    parse_listing_api,
+    parse_product,
+    product_url,
+)
+
+__all__ = [
+    "CITIES",
+    "LISTING_FIELDS",
+    "PRODUCT_FIELDS",
+    "BlinkitScraper",
+    "ScrapeError",
+    "extract_state",
+    "parse_card",
+    "parse_cards",
+    "parse_category",
+    "parse_count",
+    "parse_listing_api",
+    "parse_product",
+    "product_url",
+]
+
+__version__ = "0.1.0"

blinkit_scraper/cli.py

@@ -0,0 +1,117 @@
+"""Command line entry point: ``blinkit-scraper category URL`` / ``blinkit-scraper product URL ...``."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .client import CITIES, TOKEN_ENV, BlinkitScraper, ScrapeError
+from .parser import LISTING_FIELDS, PRODUCT_FIELDS
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="blinkit-scraper",
+        description="Scrape Blinkit categories and product pages (price, MRP, stock per dark store) into JSON or CSV.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    cat = sub.add_parser("category", help="Products of a category page (30 on page 1, 15 per further page)")
+    cat.add_argument("url", help="A Blinkit category URL, e.g. https://blinkit.com/cn/chips-crisps/cid/1237/940")
+    cat.add_argument("--pages", type=int, default=1, help="Pages to read (default 1)")
+
+    prod = sub.add_parser("product", help="Product pages: price, stock, FSSAI licence, shelf life, attributes")
+    prod.add_argument("urls", nargs="*", help="Blinkit product URLs or product ids")
+    prod.add_argument("-i", "--input", help="Text file with one URL per line, or a CSV with a 'url' column")
+    prod.add_argument("--limit", type=int, default=0, help="Stop after this many products (0 = all)")
+
+    for p in (cat, prod):
+        p.add_argument("-t", "--token", help=f"Scrape.do API token (default: ${TOKEN_ENV})")
+        p.add_argument("--city", choices=sorted(CITIES), help="Delivery location preset (default: Gurugram)")
+        p.add_argument("--lat", type=float, help="Delivery latitude (with --lon)")
+        p.add_argument("--lon", type=float, help="Delivery longitude (with --lat)")
+        p.add_argument("-f", "--format", choices=("json", "csv"), default="json")
+        p.add_argument("-o", "--output", help="Write to this file instead of stdout")
+    return parser
+
+
+def _read_urls(args: argparse.Namespace) -> List[str]:
+    urls = list(args.urls)
+    if args.input:
+        with open(args.input, encoding="utf-8", newline="") as handle:
+            if args.input.endswith(".csv"):
+                urls.extend(row["url"] for row in csv.DictReader(handle) if row.get("url"))
+            else:
+                urls.extend(line.strip() for line in handle if line.strip() and not line.startswith("#"))
+    return urls[: args.limit] if args.limit else urls
+
+
+def _write(rows: List[dict], fields: List[str], fmt: str, stream) -> None:
+    if fmt == "csv":
+        writer = csv.DictWriter(stream, fieldnames=fields, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(rows)
+    else:
+        json.dump(rows, stream, indent=2, ensure_ascii=False)
+        stream.write("\n")
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    if (args.lat is None) != (args.lon is None):
+        print("Pass both --lat and --lon.", file=sys.stderr)
+        return 2
+    try:
+        scraper = BlinkitScraper(token=args.token, lat=args.lat, lon=args.lon, city=args.city)
+    except ValueError as exc:
+        print(exc, file=sys.stderr)
+        return 2
+
+    failures = 0
+    if args.command == "category":
+        fields = LISTING_FIELDS
+        try:
+            info = scraper.get_category(args.url, max_pages=max(1, args.pages), with_info=True)
+        except (ScrapeError, ValueError) as exc:
+            print(f"fail  {args.url}: {exc}", file=sys.stderr)
+            return 1
+        rows = info["products"]
+        print(f"{len(rows)} of {info['total']} products, store {info['merchant_id']} ({info['locality']}), "
+              f"{scraper.credits_used} credits", file=sys.stderr)
+    else:
+        fields = PRODUCT_FIELDS
+        urls = _read_urls(args)
+        if not urls:
+            print("No URLs given. Pass product URLs or --input FILE.", file=sys.stderr)
+            return 2
+        rows = []
+        for url in urls:
+            try:
+                product = scraper.get_product(url)
+            except (ScrapeError, ValueError) as exc:
+                failures += 1
+                print(f"fail  {url}: {exc}", file=sys.stderr)
+                continue
+            if not product:
+                failures += 1
+                print(f"fail  {url}: no product data", file=sys.stderr)
+                continue
+            rows.append(product)
+            print(f"ok    {url}", file=sys.stderr)
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8", newline="" if args.format == "csv" else None) as handle:
+            _write(rows, fields, args.format, handle)
+        print(f"Saved {len(rows)} rows to {args.output}", file=sys.stderr)
+    else:
+        _write(rows, fields, args.format, sys.stdout)
+    return 1 if failures and not rows else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

blinkit_scraper/client.py

@@ -0,0 +1,183 @@
+"""Fetch Blinkit pages through the Scrape.do API.
+
+Blinkit sits behind Cloudflare and answers scripts with HTTP 403. Through
+Scrape.do every request uses residential proxies in India (``super=true`` and
+``geoCode=in``); the listing API only answers on those. Each request costs
+10 Scrape.do credits.
+
+Prices, assortment and stock belong to one dark store, chosen from a delivery
+location. Pages take it from the ``gr_1_lat`` / ``gr_1_lon`` cookies, the
+listing API from ``lat`` / ``lon`` headers. Without a location Blinkit uses
+Gurugram.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from typing import Any, Callable, Dict, Optional
+
+import requests
+
+from .parser import BLINKIT, extract_state, category_ids, parse_category, parse_listing_api, parse_product, product_id_from_url
+
+API_URL = "https://api.scrape.do/"
+TOKEN_ENV = "SCRAPEDO_TOKEN"
+DEFAULT_LAT, DEFAULT_LON = 28.413333, 77.072833  # Gurugram, Blinkit's own default
+
+CITIES = {
+    "gurugram": (28.413333, 77.072833),
+    "delhi": (28.6315, 77.2167),
+    "mumbai": (19.0760, 72.8777),
+    "bengaluru": (12.9716, 77.5946),
+    "hyderabad": (17.3850, 78.4867),
+    "pune": (18.5204, 73.8567),
+    "kolkata": (22.5726, 88.3639),
+    "chennai": (13.0827, 80.2707),
+}
+
+
+class ScrapeError(RuntimeError):
+    """A request that did not return usable data. ``from_target`` is True when the status came from Blinkit."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, from_target: bool = False) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.from_target = from_target
+
+
+def _is_json(text: str) -> bool:
+    try:
+        return isinstance(json.loads(text), dict)
+    except ValueError:
+        return False
+
+
+class BlinkitScraper:
+    """Blinkit category listings and product pages, for one delivery location.
+
+    >>> scraper = BlinkitScraper(token="...", city="mumbai")
+    >>> rows = scraper.get_category("https://blinkit.com/cn/chips-crisps/cid/1237/940", max_pages=3)
+    """
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        lat: Optional[float] = None,
+        lon: Optional[float] = None,
+        city: Optional[str] = None,
+        timeout: float = 90,
+        retries: int = 2,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        self.token = (token or os.getenv(TOKEN_ENV) or "").strip()
+        if not self.token:
+            raise ValueError(f"A Scrape.do API token is required (pass token= or set {TOKEN_ENV}).")
+        if city:
+            key = city.strip().lower()
+            if key not in CITIES:
+                raise ValueError(f"Unknown city {city!r}. Known: {', '.join(sorted(CITIES))}. Or pass lat and lon.")
+            lat, lon = CITIES[key]
+        self.lat = float(lat) if lat is not None else DEFAULT_LAT
+        self.lon = float(lon) if lon is not None else DEFAULT_LON
+        self.timeout = timeout
+        self.retries = max(0, retries)
+        self.session = session or requests.Session()
+        self.credits_used = 0
+
+    # ------------------------------------------------------------ transport
+
+    def request(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[str] = None,
+        valid: Optional[Callable[[str], bool]] = None,
+    ) -> str:
+        params: Dict[str, str] = {"token": self.token, "url": url, "super": "true", "geoCode": "in"}
+        send = None
+        if headers:
+            params["extraHeaders"] = "true"
+            send = {f"sd-{k}": v for k, v in headers.items()}
+        if cookies:
+            params["setCookies"] = cookies
+        last: Optional[ScrapeError] = None
+        for attempt in range(self.retries + 1):
+            if attempt:
+                time.sleep(1.5 * attempt)
+            try:
+                response = self.session.request(
+                    method, API_URL, params=params, headers=send, data="{}" if method == "POST" else None, timeout=self.timeout
+                )
+            except requests.RequestException as exc:
+                last = ScrapeError(f"Request failed: {str(exc).replace(self.token, '***')}")
+                continue
+            from_target = "scrape.do-initial-status-code" in {k.lower() for k in response.headers}
+            try:
+                self.credits_used += int(response.headers.get("scrape.do-request-cost") or 0)
+            except ValueError:
+                pass
+            if response.status_code == 401 and not from_target:
+                raise ScrapeError("Scrape.do rejected the token (HTTP 401).", 401, False)
+            if response.status_code == 200 and response.text and (valid is None or valid(response.text)):
+                return response.text
+            last = ScrapeError(
+                f"HTTP {response.status_code} for {url}" if response.status_code != 200 else f"Page without Blinkit data: {url}",
+                response.status_code, from_target,
+            )
+            if response.status_code not in (200, 429, 500, 502, 503, 504):
+                break
+        raise last or ScrapeError(f"Request failed: {url}")
+
+    def _cookies(self) -> str:
+        return f"gr_1_lat={self.lat}; gr_1_lon={self.lon}"
+
+    def fetch_page(self, url: str) -> str:
+        """A Blinkit page for this location (category or product)."""
+        return self.request(url, cookies=self._cookies(), valid=lambda body: bool(extract_state(body)))
+
+    def fetch_listing_api(self, next_url: str) -> Dict[str, Any]:
+        """One page of /v1/layout/listing_widgets (15 products) for this location."""
+        headers = {
+            "lat": str(self.lat), "lon": str(self.lon), "app_client": "consumer_web",
+            "Content-Type": "application/json", "Accept": "application/json",
+        }
+        url = next_url if next_url.startswith("http") else BLINKIT + next_url
+        return json.loads(self.request(url, method="POST", headers=headers, valid=_is_json))
+
+    # ------------------------------------------------------------- scraping
+
+    def get_category(self, url: str, max_pages: int = 1, with_info: bool = False) -> Any:
+        """Products of a category page. Page 1 is the HTML (30 products); every further page is one
+        listing-API call (15 products). Out-of-stock products are kept with ``in_stock=False``."""
+        if not category_ids(url):
+            raise ValueError("Expected a Blinkit category URL like https://blinkit.com/cn/chips-crisps/cid/1237/940")
+        first = parse_category(self.fetch_page(url))
+        rows: Dict[int, Dict[str, Any]] = {row["product_id"]: row for row in first["products"]}
+        next_url, pages = first["next_url"], 1
+        while next_url and pages < max(1, max_pages):
+            batch = parse_listing_api(self.fetch_listing_api(next_url))
+            pages += 1
+            for row in batch["products"]:
+                rows.setdefault(row["product_id"], row)
+            if not batch["products"]:
+                break
+            next_url = batch["next_url"]
+        products = list(rows.values())
+        if not with_info:
+            return products
+        return {
+            "products": products, "total": first["total"], "pages_read": pages, "has_more": bool(next_url),
+            "locality": first["locality"], "lat": self.lat, "lon": self.lon,
+            "merchant_id": next((r["merchant_id"] for r in products if r.get("merchant_id")), None),
+        }
+
+    def get_product(self, url_or_id: Any) -> Optional[Dict[str, Any]]:
+        """Product page: price, MRP, stock and the attribute sheet (FSSAI licence, shelf life...)."""
+        text = str(url_or_id).strip()
+        product_id = int(text) if text.isdigit() else product_id_from_url(text)
+        if not product_id:
+            raise ValueError("Expected a Blinkit product URL (.../prn/<name>/prid/<id>) or a product id.")
+        return parse_product(self.fetch_page(f"{BLINKIT}/prn/product/prid/{product_id}"))

blinkit_scraper/parser.py

@@ -0,0 +1,254 @@
+"""Parse Blinkit pages.
+
+Every Blinkit page is rendered on the server with its data in one inline script,
+``window.grofers.PRELOADED_STATE = {...}``. Category pages keep the first 30
+product cards in ``ui.plpContainer.feedData.snippets`` plus a ``next_url`` for
+the listing API; product pages keep the catalog sheet (price, MRP, stock,
+attributes such as FSSAI licence and shelf life) in
+``ui.pdp.bffPdp.bffData.tracking.le_meta.custom_data.seo``.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import parse_qs, urlparse
+
+BLINKIT = "https://blinkit.com"
+CARD_TYPE = "product_card_snippet_type_2"
+_STATE_RE = re.compile(r"window\.grofers\.PRELOADED_STATE\s*=\s*")
+_DECODER = json.JSONDecoder()
+
+LISTING_FIELDS = [
+    "product_id", "name", "brand", "pack_size", "price_inr", "mrp_inr", "discount_pct",
+    "in_stock", "inventory", "rating", "rating_count", "variants", "merchant_id", "image", "url",
+]
+PRODUCT_FIELDS = [
+    "product_id", "name", "brand", "pack_size", "price_inr", "mrp_inr", "discount_pct", "in_stock",
+    "inventory", "shelf_life", "fssai_license", "country_of_origin", "category_ids", "merchant_id", "url",
+]
+
+# ------------------------------------------------------------------ helpers
+
+
+def extract_state(html: str) -> Dict[str, Any]:
+    """The PRELOADED_STATE object Blinkit renders into every page, or {}."""
+    match = _STATE_RE.search(html or "")
+    if not match:
+        return {}
+    try:
+        data, _ = _DECODER.raw_decode(html, match.end())
+    except json.JSONDecodeError:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _text(node: Any) -> Optional[str]:
+    if isinstance(node, dict):
+        value = node.get("text")
+        return value.strip() if isinstance(value, str) else None
+    return node.strip() if isinstance(node, str) else None
+
+
+def _num(value: Any) -> Optional[float]:
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return value
+    match = re.search(r"\d[\d,]*(?:\.\d+)?", str(value))
+    if not match:
+        return None
+    number = float(match.group(0).replace(",", ""))
+    return int(number) if number.is_integer() else number
+
+
+def _int(value: Any) -> Optional[int]:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _pct(price: Any, mrp: Any) -> int:
+    if isinstance(price, (int, float)) and isinstance(mrp, (int, float)) and mrp > 0 and price <= mrp:
+        return int((mrp - price) * 100 // mrp)  # Blinkit rounds discounts down
+    return 0
+
+
+_MULTIPLIERS = {"k": 1_000, "lac": 100_000, "lakh": 100_000, "l": 100_000, "cr": 10_000_000, "crore": 10_000_000}
+
+
+def parse_count(text: Any) -> Optional[int]:
+    """'7 lac' -> 700000, '1.2k' -> 1200, '(980)' -> 980."""
+    if isinstance(text, (int, float)) and not isinstance(text, bool):
+        return int(text)
+    match = re.search(r"(\d[\d,]*(?:\.\d+)?)\s*([a-zA-Z]*)", str(text or ""))
+    if not match:
+        return None
+    number = float(match.group(1).replace(",", ""))
+    return int(round(number * _MULTIPLIERS.get(match.group(2).lower(), 1)))
+
+
+def slugify(name: Any) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", str(name or "").lower()).strip("-")
+    return slug or "product"
+
+
+def product_url(product_id: Any, name: Any = None) -> str:
+    return f"{BLINKIT}/prn/{slugify(name)}/prid/{product_id}" if product_id else ""
+
+
+def product_id_from_url(url: str) -> Optional[int]:
+    match = re.search(r"/prid/(\d+)", url or "")
+    return int(match.group(1)) if match else None
+
+
+def category_ids(url: str) -> Optional[tuple]:
+    """(l0, l1) from a /cn/<slug>/cid/<l0>/<l1> URL."""
+    match = re.search(r"/cid/(\d+)(?:/(\d+))?", url or "")
+    if not match:
+        return None
+    return int(match.group(1)), (int(match.group(2)) if match.group(2) else None)
+
+
+# ------------------------------------------------------------- product cards
+
+
+def parse_card(data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """One listing card -> flat row. Returns None for non-product snippets."""
+    if not isinstance(data, dict):
+        return None
+    cart = ((data.get("atc_action") or {}).get("add_to_cart") or {}).get("cart_item") or {}
+    product_id = _int(data.get("product_id") or (data.get("identity") or {}).get("id") or cart.get("product_id"))
+    if not product_id:
+        return None
+    name = _text(data.get("display_name")) or _text(data.get("name")) or cart.get("product_name")
+    price = cart.get("price") if isinstance(cart.get("price"), (int, float)) else _num(_text(data.get("normal_price")))
+    mrp = cart.get("mrp") if isinstance(cart.get("mrp"), (int, float)) else _num(_text(data.get("mrp")))
+    if mrp is None:
+        mrp = price
+    inventory = data.get("inventory", cart.get("inventory"))
+    inventory = inventory if isinstance(inventory, int) else 0
+    sold_out = bool(data.get("is_sold_out")) or data.get("product_state") == "out_of_stock" or inventory <= 0
+    bar = (data.get("rating") or {}).get("bar") or {}
+    rating = bar.get("value")
+    return {
+        "product_id": product_id,
+        "name": name,
+        "brand": _text(data.get("brand_name")) or cart.get("brand"),
+        "pack_size": _text(data.get("variant")) or cart.get("unit"),
+        "price_inr": price,
+        "mrp_inr": mrp,
+        "discount_pct": _pct(price, mrp),
+        "in_stock": not sold_out,
+        "inventory": max(inventory, 0),
+        "rating": round(rating, 2) if isinstance(rating, (int, float)) else None,
+        "rating_count": parse_count(_text(bar.get("title"))) if bar else None,
+        "variants": len(data.get("variant_list") or []) or 1,
+        "merchant_id": _int(data.get("merchant_id") or cart.get("merchant_id")),
+        "image": (data.get("image") or {}).get("url") or cart.get("image_url"),
+        "url": product_url(product_id, name),
+    }
+
+
+def parse_cards(snippets: List[Any]) -> List[Dict[str, Any]]:
+    rows = []
+    for snippet in snippets or []:
+        if isinstance(snippet, dict) and snippet.get("widget_type") == CARD_TYPE:
+            row = parse_card(snippet.get("data"))
+            if row:
+                rows.append(row)
+    return rows
+
+
+def _total(next_url: Optional[str]) -> Optional[int]:
+    if not next_url:
+        return None
+    values = parse_qs(urlparse(next_url).query).get("total_pagination_items")
+    return _int(values[0]) if values else None
+
+
+def parse_category(html: str) -> Dict[str, Any]:
+    """Category page -> {'products', 'next_url', 'total', 'locality', 'lat', 'lon'}."""
+    state = extract_state(html)
+    feed = (((state.get("ui") or {}).get("plpContainer") or {}).get("feedData")) or {}
+    next_url = (feed.get("pagination") or {}).get("next_url")
+    coords = (((state.get("data") or {}).get("location") or {}).get("coords")) or {}
+    return {
+        "products": parse_cards(feed.get("snippets") or []),
+        "next_url": next_url,
+        "total": _total(next_url),
+        "locality": coords.get("locality"),
+        "lat": coords.get("lat"),
+        "lon": coords.get("lon"),
+    }
+
+
+def parse_listing_api(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Response of /v1/layout/listing_widgets -> {'products', 'next_url'}."""
+    response = (payload or {}).get("response") or {}
+    next_url = (response.get("pagination") or {}).get("next_url")
+    return {"products": parse_cards(response.get("snippets") or []), "next_url": next_url, "total": _total(next_url)}
+
+
+# -------------------------------------------------------------- product page
+
+_ATTRIBUTE_KEYS = {
+    "shelf_life": ("Shelf Life",),
+    "fssai_license": ("FSSAI License", "FSSAI License Number"),
+    "country_of_origin": ("Country of Origin",),
+    "unit": ("Unit", "Net Weight"),
+    "ingredients": ("Ingredients",),
+    "manufacturer": ("Manufacturer Details", "Manufacturer's Name and Address", "Manufacturer Name"),
+    "return_policy": ("Return Policy",),
+}
+
+
+def parse_product(html: str) -> Optional[Dict[str, Any]]:
+    """Product page -> summary dict with price, stock and the attribute sheet."""
+    state = extract_state(html)
+    bff = ((((state.get("ui") or {}).get("pdp") or {}).get("bffPdp") or {}).get("bffData")) or {}
+    seo = ((((bff.get("tracking") or {}).get("le_meta") or {}).get("custom_data")) or {}).get("seo") or {}
+    product_id = _int(seo.get("id"))
+    if not product_id:
+        return None
+    attributes: Dict[str, str] = {}
+    for item in seo.get("attributes") or []:
+        name, value = item.get("name"), item.get("value")
+        if name and value not in (None, "") and name not in attributes:
+            attributes[name] = str(value).strip()
+    picked = {key: next((attributes[n] for n in names if n in attributes), None) for key, names in _ATTRIBUTE_KEYS.items()}
+    merchant_id = None
+    for snippet in bff.get("snippets") or []:
+        if snippet.get("widget_type") == "product_atc_strip":
+            blob = json.dumps(snippet.get("data") or {})
+            found = re.search(r'"merchant_id":\s*(\d+)', blob)
+            merchant_id = int(found.group(1)) if found else None
+            break
+    price, mrp = seo.get("price"), seo.get("mrp")
+    inventory = seo.get("inventory") if isinstance(seo.get("inventory"), int) else 0
+    available = bool(price) and inventory > 0
+    cats = seo.get("categories") or {}
+    return {
+        "product_id": product_id,
+        "name": seo.get("product_name"),
+        "brand": seo.get("brand"),
+        "pack_size": picked["unit"],
+        "price_inr": price if price else None,
+        "mrp_inr": mrp if mrp else None,
+        "discount_pct": _pct(price, mrp) if price else 0,
+        "in_stock": available,
+        "inventory": max(inventory, 0),
+        "shelf_life": picked["shelf_life"],
+        "fssai_license": picked["fssai_license"],
+        "country_of_origin": picked["country_of_origin"],
+        "ingredients": picked["ingredients"],
+        "manufacturer": picked["manufacturer"],
+        "return_policy": picked["return_policy"],
+        "category_ids": "/".join(str((cats.get(k) or {}).get("ID")) for k in ("L0Cat", "L1Cat", "L2Cat") if (cats.get(k) or {}).get("ID")),
+        "merchant_id": merchant_id,
+        "images": [u for u in seo.get("images") or [] if isinstance(u, str)],
+        "attributes": attributes,
+        "url": product_url(product_id, seo.get("product_name")),
+    }

blinkit_scraper-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: blinkit-scraper
+Version: 0.1.0
+Summary: Scrape Blinkit categories and product pages (price, MRP, stock per dark store, FSSAI licence, shelf life) with Python.
+Author: Buğrahan Saka
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bugrahansss/blinkit-scraper
+Project-URL: Source, https://github.com/bugrahansss/blinkit-scraper
+Project-URL: Issues, https://github.com/bugrahansss/blinkit-scraper/issues
+Project-URL: Scrape.do, https://scrape.do/?utm_source=pypi&utm_medium=package&utm_campaign=blinkit-scraper
+Keywords: blinkit,web scraping,quick commerce,grocery,scraper,cloudflare,india
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# blinkit-scraper
+
+[![PyPI](https://img.shields.io/pypi/v/blinkit-scraper)](https://pypi.org/project/blinkit-scraper/)
+[![Python](https://img.shields.io/pypi/pyversions/blinkit-scraper)](https://pypi.org/project/blinkit-scraper/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A Python scraper for [Blinkit](https://blinkit.com), India's 10-minute grocery app. Two jobs:
+
+- **Category listings:** any category page (`/cn/chips-crisps/cid/1237/940`) → name, brand, pack size, price, MRP, discount, **units in stock**, rating, rating count, variants and URL, **for the dark store that serves your location**. Real pagination: 30 products on the first page, 15 per page after that, out-of-stock products kept.
+- **Product pages:** price, MRP and stock plus the catalog sheet: **FSSAI licence, shelf life, country of origin, ingredients, manufacturer, return policy** and every other attribute Blinkit lists.
+
+Output as Python dicts, JSON or CSV. One dependency (`requests`), no browser.
+
+```bash
+pip install blinkit-scraper
+```
+
+## Why a plain request fails
+
+Blinkit sits behind Cloudflare. A script gets an error page, not products:
+
+| Request | Result |
+| --- | --- |
+| `requests`, default or Chrome user agent | HTTP 403, "blinkit \| Error Page" |
+| Through Scrape.do (`super=true&geoCode=in`) | 200 in ~3 s, full page with the data, 5 of 5 tries |
+
+Pages are fetched through the [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=blinkit-scraper) API with residential proxies in India. Blinkit requests cost 10 credits each; the free plan includes 1,000 credits a month.
+
+## Quick start
+
+```python
+from blinkit_scraper import BlinkitScraper
+
+scraper = BlinkitScraper(token="YOUR_SCRAPEDO_TOKEN", city="mumbai")  # or lat=..., lon=...
+
+# 3 pages = 30 + 15 + 15 = 60 products, 3 requests
+rows = scraper.get_category("https://blinkit.com/cn/chips-crisps/cid/1237/940", max_pages=3)
+for row in rows[:3]:
+    print(row["name"], row["pack_size"], row["price_inr"], row["mrp_inr"], row["inventory"], row["in_stock"])
+
+product = scraper.get_product(rows[0]["url"])
+print(product["fssai_license"], product["shelf_life"], product["country_of_origin"])
+```
+
+### Command line
+
+```bash
+export SCRAPEDO_TOKEN=your_token
+
+# 3 pages of a category for a Mumbai address, CSV
+blinkit-scraper category "https://blinkit.com/cn/chips-crisps/cid/1237/940" --pages 3 --city mumbai -f csv -o blinkit-chips.csv
+
+# product sheets for the first 10 products of that file
+blinkit-scraper product -i blinkit-chips.csv --limit 10 --city mumbai -f csv -o blinkit-products.csv
+
+# any address: pass its coordinates
+blinkit-scraper category "https://blinkit.com/cn/chips-crisps/cid/1237/940" --lat 12.9352 --lon 77.6245
+```
+
+City presets: `bengaluru`, `chennai`, `delhi`, `gurugram` (Blinkit's default), `hyderabad`, `kolkata`, `mumbai`, `pune`.
+
+### Output
+
+Listing row (from the fictional test page in [`tests/fixtures`](tests/fixtures/category_page.html)):
+
+```json
+{"product_id": 1001, "name": "Example Salted Chips", "brand": "Northwind Snacks", "pack_size": "60 g",
+ "price_inr": 43, "mrp_inr": 70, "discount_pct": 38, "in_stock": true, "inventory": 5,
+ "rating": 4.31, "rating_count": 120000, "variants": 2, "merchant_id": 90001,
+ "image": "https://cdn.example.com/p/1001.png", "url": "https://blinkit.com/prn/example-salted-chips/prid/1001"}
+```
+
+Product columns: `product_id, name, brand, pack_size, price_inr, mrp_inr, discount_pct, in_stock, inventory, shelf_life, fssai_license, country_of_origin, category_ids, merchant_id, url` (plus `ingredients`, `manufacturer`, `return_policy`, `images` and the full `attributes` dict in Python/JSON).
+
+## How it works
+
+**The data is one JSON object.** Blinkit renders every page on the server and puts the data in `window.grofers.PRELOADED_STATE = {...}`. Category pages keep the product cards in `ui.plpContainer.feedData.snippets`, product pages keep the catalog sheet in `ui.pdp.bffPdp.bffData.tracking.le_meta.custom_data.seo`. The scraper reads the object with `json.JSONDecoder.raw_decode`. No CSS selectors.
+
+**Each card carries the stock count.** `inventory` is the number of units the dark store has (Blinkit stops counting at 50). `rating_count` arrives as text in Indian units ("7 lac" = 700,000) and is converted.
+
+**Location picks the store.** Prices, assortment and stock belong to one dark store, chosen from the delivery address. Without one, Blinkit uses Gurugram. In our test the chips category listed 673 products in Gurugram (store 31719) and 524 in Mumbai (store 41649); a banana chips pack had 5 units in one and 1 in the other. Pages read the location from the `gr_1_lat` / `gr_1_lon` cookies, the listing API from `lat` / `lon` headers; the scraper sends both.
+
+**Pagination is a POST API.** The page holds 30 products and a `next_url` for `/v1/layout/listing_widgets`. That endpoint returns 15 products per call (a larger `limit` is ignored) and the next `next_url`. It only answers through residential proxies, so every request uses `super=true&geoCode=in`. Reading a whole category of 673 products takes 44 requests.
+
+## Limits
+
+- **Credits.** 10 Scrape.do credits per request: page 1 of a category, each further page of 15, each product page.
+- **Stock cap.** `inventory` tops out at 50.
+- **Search.** `/s/` search pages are disallowed in Blinkit's robots.txt and not supported; use category pages.
+- **Errors.** Non-200 responses raise `ScrapeError` with the status code; `from_target` tells a Blinkit status from a Scrape.do one (a wrong token is a Scrape.do 401). A 200 without Blinkit's data is retried. Server errors, 429s and empty pages are retried twice; client errors are not.
+
+## Responsible use
+
+The scraper reads category (`/cn/`) and product (`/prn/`) pages, which Blinkit's robots.txt allows, plus the listing API those pages call. It never touches search, cart, checkout or account paths. Product data is not personal data. Read Blinkit's terms for your use case and keep request rates modest. This is not legal advice.
+
+## Development
+
+```bash
+git clone https://github.com/bugrahansss/blinkit-scraper
+cd blinkit-scraper
+pip install -e .
+python -m unittest discover -s tests -v
+```
+
+The tests run offline against fictional fixture pages.
+
+## License
+
+MIT
+
+---
+
+Built and tested with [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=blinkit-scraper), November 2026.

blinkit_scraper-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+blinkit_scraper/__init__.py,sha256=cX44DXSnsrpZGZjuQqs4juid1pjkwT4Zojt4RS6UPec,675
+blinkit_scraper/cli.py,sha256=wmXV3GkyZ60ke9PabxAGlGEG37KUt70EdK6ustoD9mE,4994
+blinkit_scraper/client.py,sha256=9GzvdsH7PFsHmv53GwvPjFwvkq6ZanNOdhLsHpbQmSY,7979
+blinkit_scraper/parser.py,sha256=aVOOnSQOy6v-FSJ-wHEk5LP5XXRU4G_DlRfz1BMQ_QU,10415
+blinkit_scraper-0.1.0.dist-info/licenses/LICENSE,sha256=ROg_cpaduSqtDgeddNL4Csjnu7TkWQsINx0OuPmUTwM,1071
+blinkit_scraper-0.1.0.dist-info/METADATA,sha256=CDD2XEXIh6q_DXVt62ybHoTcwarW9bh_CeC2wni5sSA,7433
+blinkit_scraper-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+blinkit_scraper-0.1.0.dist-info/entry_points.txt,sha256=7b9J5JROGnFxy73MEhVmRmhVw7S7jWUK8ojVJXpRWYQ,61
+blinkit_scraper-0.1.0.dist-info/top_level.txt,sha256=fFILs2Ua7ZU_a5l_X-U2FozB9kZXKsrQvnL3R9XIagg,16
+blinkit_scraper-0.1.0.dist-info/RECORD,,

blinkit_scraper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

blinkit_scraper-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blinkit-scraper = blinkit_scraper.cli:main

blinkit_scraper-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Buğrahan Saka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blinkit_scraper-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+blinkit_scraper