Channel comparison + city availability + issuer portals + booking/apply links

- channels.py: best card PER booking channel (District/Dineout/direct, BMS,
OTAs, SmartBuy/Travel Edge/iShop portals) ranked by net INR, in /recommend
- availability.py: 15-city table, synonyms, GPS centroid fallback, platform
and merchant city coverage; unavailable channels dropped, unverified flagged
- merchants.py: district/dineout/copper chimney keywords, movie subtype
- offers.py: Dineout/District/EaseMyTrip/BMS/Copper Chimney offers incl.
platform-funded any-card rows; connectors + curated_offers.json synced
- apply_links.py: official issuer product pages for all 30 cards; /discover
now returns them (was a placeholder)
- main.py: X-App-Key gate, city/lat/lng on /recommend, /offers endpoints
- verified: 58,140-scenario certification parity + channel matrix, 0 diffs

.env.example

@@ -0,0 +1,10 @@
+# RewardPilot backend environment
+# Copy this file to ".env" and paste your real key. NEVER commit ".env".
+# The key lives ONLY here on the server — never in the mobile app or git.
+
+# OpenAI key — used only to write the natural-language "why this card" reasoning.
+# The deterministic engine still computes all numbers and the ranking.
+OPENAI_API_KEY=sk-paste-your-rotated-key-here
+
+# Optional alternative for narration (not required if OPENAI_API_KEY is set)
+# ANTHROPIC_API_KEY=

.gitignore

@@ -2,3 +2,6 @@ __pycache__/
 *.pyc
 .venv/
 .env
+
+# offer pipeline transient state
+offers_data/review_queue.json

app/apply_links.py

@@ -0,0 +1,47 @@
+"""
+Official issuer application/product pages per card (mirrored in
+app/src/data/applyLinks.ts). Curated 2026-07-05; key pages spot-verified live.
+Where a product page couldn't be confirmed, the issuer's credit-cards hub is
+used - never a dead link. Callers fall back to a web search for any card
+missing here. Replace with affiliate deep links when monetized.
+"""
+
+APPLY_URL = {
+    # HDFC
+    "hdfc_infinia": "https://www.hdfcbank.com/personal/pay/cards/credit-cards/infinia-credit-card",
+    "hdfc_regalia_gold": "https://www.hdfcbank.com/personal/pay/cards/credit-cards/regalia-gold-credit-card",
+    "hdfc_millennia": "https://www.hdfcbank.com/personal/pay/cards/credit-cards/millennia-credit-card",
+    "hdfc_swiggy": "https://www.hdfcbank.com/personal/pay/cards/credit-cards/swiggy-credit-card",
+    "hdfc_diners_black": "https://www.hdfcbank.com/personal/pay/cards/credit-cards/diners-club-black-metal-edition",
+    "tataneu_infinity": "https://www.hdfcbank.com/personal/pay/cards/credit-cards",   # hub: product URL unstable
+    # SBI Card
+    "sbi_cashback": "https://www.sbicard.com/en/personal/credit-cards/shopping/cashback-sbi-card.page",
+    "sbi_elite": "https://www.sbicard.com/en/personal/credit-cards/lifestyle/sbi-card-elite.page",
+    "sbi_simplyclick": "https://www.sbicard.com/en/personal/credit-cards/shopping/simplyclick-sbi-card.page",
+    "sbi_bpcl_octane": "https://www.sbicard.com/en/personal/credit-cards/travel/bpcl-sbi-card-octane.page",
+    "sbi_rupay_select": "https://www.sbicard.com/en/personal/credit-cards.page",      # hub
+    # ICICI
+    "icici_amazon_pay": "https://www.icicibank.com/personal-banking/cards/credit-card/amazon-pay-credit-card",
+    "icici_sapphiro": "https://www.icicibank.com/personal-banking/cards/credit-card/sapphiro-credit-card",
+    "icici_emeralde": "https://www.icicibank.com/personal-banking/cards/credit-card/emeralde-private-metal-credit-card",
+    # Axis
+    "axis_magnus": "https://www.axisbank.com/retail/cards/credit-card/axis-bank-magnus-credit-card",
+    "axis_ace": "https://www.axisbank.com/retail/cards/credit-card/ace-credit-card",
+    "axis_atlas": "https://www.axisbank.com/retail/cards/credit-card/atlas-credit-card",
+    "axis_flipkart": "https://www.axisbank.com/retail/cards/credit-card/flipkart-axisbank-credit-card",
+    # Amex
+    "amex_mrcc": "https://www.americanexpress.com/in/credit-cards/membership-rewards-credit-card/",
+    "amex_platinum_travel": "https://www.americanexpress.com/in/credit-cards/platinum-travel-credit-card/",
+    # IDFC FIRST
+    "idfc_first_select": "https://www.idfcfirstbank.com/credit-card/first-select-credit-card",
+    "idfc_first_wealth": "https://www.idfcfirstbank.com/credit-card/first-wealth-credit-card",
+    "idfc_first_millennia": "https://www.idfcfirstbank.com/credit-card/first-millennia-credit-card",
+    "idfc_first_power_plus": "https://www.idfcfirstbank.com/credit-card/first-power-plus-credit-card",
+    # Others
+    "kiwi_axis": "https://gokiwi.in/",
+    "au_zenith": "https://www.aubank.in/personal-banking/credit-cards/zenith-credit-card",
+    "indusind_legend": "https://www.indusind.com/in/en/personal/cards/credit-card/legend-credit-card.html",
+    "rbl_world_safari": "https://www.rblbank.com/credit-cards/world-safari-credit-card",
+    "onecard_metal": "https://www.getonecard.app/",
+    "hsbc_live_plus": "https://www.hsbc.co.in/credit-cards/products/live-plus/",
+}

app/availability.py

@@ -0,0 +1,167 @@
+"""
+RewardPilot - City & platform availability
+===========================================
+Answers two questions the channel comparison needs:
+  1. Which city is the user in? (explicit city > city named in the query >
+     nearest metro centroid from GPS coordinates)
+  2. Is a booking platform - and, when we know the chain, this specific
+     merchant - actually available in that city?
+
+Curated seed, same philosophy as offers.py: structured and dated in spirit,
+refreshed by the ingestion pipeline (connectors/) later. Coverage values are
+illustrative until a live feed is wired.
+
+Availability levels:
+  "available"   - platform (and merchant, when known) confirmed in this city
+  "unknown"     - no data to confirm; channel is kept but flagged unverified
+  "unavailable" - confirmed absent (platform not in city, or chain not listed
+                  on this platform); channel is dropped from the comparison
+
+Mirrored on-device in app/src/data/availability.ts.
+"""
+
+import math
+from typing import Dict, Optional, Set, Union
+
+# ---------------------------------------------------------------------------
+# Cities: canonical name -> (lat, lng) centroid. Used for GPS fallback.
+# ---------------------------------------------------------------------------
+CITIES: Dict[str, tuple] = {
+    "mumbai": (19.0760, 72.8777),
+    "delhi": (28.6139, 77.2090),
+    "bengaluru": (12.9716, 77.5946),
+    "hyderabad": (17.3850, 78.4867),
+    "chennai": (13.0827, 80.2707),
+    "kolkata": (22.5726, 88.3639),
+    "pune": (18.5204, 73.8567),
+    "ahmedabad": (23.0225, 72.5714),
+    "jaipur": (26.9124, 75.7873),
+    "surat": (21.1702, 72.8311),
+    "lucknow": (26.8467, 80.9462),
+    "chandigarh": (30.7333, 76.7794),
+    "indore": (22.7196, 75.8577),
+    "kochi": (9.9312, 76.2673),
+    "goa": (15.4909, 73.8278),
+}
+
+# Common alternates / NCR satellites -> canonical city key.
+CITY_SYNONYMS: Dict[str, str] = {
+    "bombay": "mumbai", "navi mumbai": "mumbai", "thane": "mumbai",
+    "new delhi": "delhi", "gurgaon": "delhi", "gurugram": "delhi",
+    "noida": "delhi", "ghaziabad": "delhi", "faridabad": "delhi",
+    "bangalore": "bengaluru",
+    "madras": "chennai",
+    "calcutta": "kolkata",
+    "cochin": "kochi",
+    "secunderabad": "hyderabad",
+    "panaji": "goa", "panjim": "goa",
+}
+
+
+def normalize_city(name: Optional[str]) -> Optional[str]:
+    """Free-text city name -> canonical key, or None if we don't know it."""
+    t = (name or "").strip().lower()
+    if not t:
+        return None
+    if t in CITIES:
+        return t
+    return CITY_SYNONYMS.get(t)
+
+
+def extract_city(text: str) -> Optional[str]:
+    """Find a city mentioned inside a free-text query ("dinner ... in Mumbai")."""
+    t = (text or "").lower()
+    hits = [k for k in list(CITIES) + list(CITY_SYNONYMS) if k in t]
+    if not hits:
+        return None
+    pick = sorted(hits, key=len, reverse=True)[0]
+    return pick if pick in CITIES else CITY_SYNONYMS[pick]
+
+
+def city_from_latlng(lat: float, lng: float, max_km: float = 60.0) -> Optional[str]:
+    """Nearest metro centroid within max_km, else None."""
+    best, best_d = None, max_km
+    for city, (clat, clng) in CITIES.items():
+        p1, p2 = math.radians(lat), math.radians(clat)
+        dp, dl = math.radians(clat - lat), math.radians(clng - lng)
+        h = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+        d = 2 * 6371.0 * math.asin(min(1.0, math.sqrt(h)))
+        if d < best_d:
+            best, best_d = city, d
+    return best
+
+
+# ---------------------------------------------------------------------------
+# Platform coverage: (channel_key, kind) -> "*" (pan-India) or a city set.
+# Direct/walk-in channels and travel OTAs are always available.
+# ---------------------------------------------------------------------------
+_ALL = "*"
+PLATFORM_CITIES: Dict[tuple, Union[str, Set[str]]] = {
+    ("dineout", "dining"): {
+        "mumbai", "delhi", "bengaluru", "hyderabad", "chennai", "kolkata",
+        "pune", "ahmedabad", "jaipur", "lucknow", "chandigarh", "indore",
+    },
+    ("district", "dining"): {
+        "mumbai", "delhi", "bengaluru", "hyderabad", "chennai", "kolkata",
+        "pune", "ahmedabad",
+    },
+    ("district", "movies"): {
+        "mumbai", "delhi", "bengaluru", "hyderabad", "chennai", "pune",
+    },
+    ("bookmyshow", "movies"): _ALL,
+}
+
+# ---------------------------------------------------------------------------
+# Merchant-level listings (dining chains we track): brand_key -> platform ->
+# "*" or city set. A chain present in this dict with a platform MISSING means
+# we know it is NOT listed there (e.g. QSR counter chains aren't on the
+# dine-in bill-payment platforms).
+# ---------------------------------------------------------------------------
+MERCHANT_PLATFORMS: Dict[str, Dict[str, Union[str, Set[str]]]] = {
+    "copper_chimney": {
+        "dineout": {"mumbai", "delhi", "pune", "bengaluru"},
+        "district": {"mumbai", "pune", "bengaluru"},
+    },
+    "barbeque_nation": {"dineout": _ALL, "district": _ALL},
+    # counter/QSR chains: you pay at the till, not through a dine-in bill app
+    "starbucks": {},
+    "haldiram": {},
+    "dominos": {},
+    "pizza_hut": {},
+    "mcdonalds": {},
+    "kfc": {},
+}
+
+
+def channel_availability(
+    channel_key: str,
+    kind: str,
+    city: Optional[str],
+    brand_key: Optional[str] = None,
+) -> str:
+    """'available' | 'unknown' | 'unavailable' for one channel in one city."""
+    if channel_key == "direct":
+        return "available"
+    if kind in ("flights", "hotels"):
+        return "available"          # travel OTAs are pan-India
+
+    # Merchant-level check first (dining chains we track).
+    if kind == "dining" and brand_key in MERCHANT_PLATFORMS:
+        listed = MERCHANT_PLATFORMS[brand_key]
+        cities = listed.get(channel_key)
+        if cities is None:
+            return "unavailable"     # chain known, not listed on this platform
+        if cities != _ALL:
+            if city is None:
+                return "unknown"     # listed somewhere, can't confirm this city
+            return "available" if city in cities else "unavailable"
+        # cities == "*": fall through to the platform's own city coverage
+
+    cov = PLATFORM_CITIES.get((channel_key, kind))
+    if cov is None:
+        return "unknown"
+    if cov == _ALL:
+        return "available"
+    if city is None:
+        return "unknown"
+    return "available" if city in cov else "unavailable"

app/channels.py

@@ -0,0 +1,230 @@
+"""
+RewardPilot - Booking-channel comparison
+========================================
+"Which card?" is only half the answer. For dine-in, movies and travel the same
+purchase can be paid through several apps (Swiggy Dineout vs District vs paying
+at the table; BookMyShow vs District vs the box office; MakeMyTrip vs
+EaseMyTrip vs the airline site) - and the best card DIFFERS per channel because
+each platform carries its own bank + platform offers.
+
+This module reuses the deterministic scoring engine once per channel and
+returns a ranked channel matrix: for each channel, the best held card and the
+total rupee benefit (card rewards + instant offers on that channel).
+
+Mirrored on-device in app/src/lib/channels.ts.
+"""
+
+from typing import Dict, List, Optional
+
+from availability import channel_availability
+from card_catalogue import CATALOGUE_BY_ID
+from offers import active_offers_for
+from scoring_engine import TxnContext, score_transaction, _r2
+
+# Brands that are themselves a booking platform: when the user's query resolved
+# to one of these, the "direct" channel must NOT inherit it as a walk-in brand.
+PLATFORM_BRANDS = {
+    "dineout", "district", "bookmyshow",
+    "makemytrip", "goibibo", "cleartrip", "yatra", "ixigo", "easemytrip",
+}
+
+# Delivery aggregators: ordering in is a different purchase from dining out, so
+# no channel comparison there.
+DELIVERY_BRANDS = {"swiggy", "zomato"}
+
+DINING_CHANNELS = [
+    {"key": "district", "name": "District (Zomato)", "brand_key": "district", "channel": "online",
+     "how": "Book the table / pay the bill in the District app", "url": "https://www.district.in"},
+    {"key": "dineout", "name": "Swiggy Dineout", "brand_key": "dineout", "channel": "online",
+     "how": "Pay the bill through Swiggy Dineout", "url": "https://www.swiggy.com/dineout"},
+    {"key": "direct", "name": "Pay at the restaurant", "brand_key": None, "channel": "offline",
+     "how": "Swipe / tap your card at the table", "url": None},
+]
+
+MOVIE_CHANNELS = [
+    {"key": "bookmyshow", "name": "BookMyShow", "brand_key": "bookmyshow", "channel": "online",
+     "how": "Book tickets on BookMyShow", "url": "https://in.bookmyshow.com"},
+    {"key": "district", "name": "District (Zomato)", "brand_key": "district", "channel": "online",
+     "how": "Book tickets in the District app", "url": "https://www.district.in/movies"},
+    {"key": "direct", "name": "Cinema box office / site", "brand_key": None, "channel": "offline",
+     "how": "Buy at the counter or the cinema's own site", "url": None},
+]
+
+FLIGHT_CHANNELS = [
+    {"key": "makemytrip", "name": "MakeMyTrip", "brand_key": "makemytrip", "channel": "online",
+     "how": "Book on MakeMyTrip", "url": "https://www.makemytrip.com/flights/"},
+    {"key": "easemytrip", "name": "EaseMyTrip", "brand_key": "easemytrip", "channel": "online",
+     "how": "Book on EaseMyTrip", "url": "https://www.easemytrip.com"},
+    {"key": "goibibo", "name": "Goibibo", "brand_key": "goibibo", "channel": "online",
+     "how": "Book on Goibibo", "url": "https://www.goibibo.com/flights/"},
+    {"key": "cleartrip", "name": "Cleartrip", "brand_key": "cleartrip", "channel": "online",
+     "how": "Book on Cleartrip", "url": "https://www.cleartrip.com"},
+    {"key": "direct", "name": "Airline website", "brand_key": None, "channel": "online",
+     "how": "Book directly with the airline", "url": None},
+]
+
+HOTEL_CHANNELS = [
+    {"key": "makemytrip", "name": "MakeMyTrip", "brand_key": "makemytrip", "channel": "online",
+     "how": "Book on MakeMyTrip", "url": "https://www.makemytrip.com/hotels/"},
+    {"key": "goibibo", "name": "Goibibo", "brand_key": "goibibo", "channel": "online",
+     "how": "Book on Goibibo", "url": "https://www.goibibo.com/hotels/"},
+    {"key": "easemytrip", "name": "EaseMyTrip", "brand_key": "easemytrip", "channel": "online",
+     "how": "Book on EaseMyTrip", "url": "https://www.easemytrip.com/hotels/"},
+    {"key": "direct", "name": "Hotel directly", "brand_key": None, "channel": "online",
+     "how": "Book with the hotel / pay at check-in", "url": None},
+]
+
+# Issuer portal booking sites (behind login; the portal decides final routing).
+PORTAL_URLS = {
+    "HDFC SmartBuy": "https://offers.smartbuy.hdfcbank.com",
+    "Axis Travel Edge": "https://traveledge.axisbank.co.in",
+    "ICICI iShop": "https://ishop.icicibank.com",
+}
+
+# Issuer booking portals (HDFC SmartBuy, Axis Travel Edge, ICICI iShop) are a
+# further channel: elevated portal-only rates, but only for holders of that
+# issuer's portal-rated cards, capped monthly, paid in points (assumed redeemed
+# at the portal point value). Synthesized per wallet, pan-India online.
+PORTAL_KEYS = {"HDFC SmartBuy": "smartbuy", "Axis Travel Edge": "travel_edge", "ICICI iShop": "ishop"}
+
+
+def _portal_value(card, category: str, amount: float) -> float:
+    """INR value of booking this category via the card's issuer portal (0 if none)."""
+    rate = (card.portal_rates or {}).get(category)
+    if not rate:
+        return 0.0
+    pv = card.portal_point_value_inr if card.portal_point_value_inr is not None else card.point_value_inr
+    units = amount / 100.0 * rate
+    if card.portal_cap_units is not None:
+        units = min(units, card.portal_cap_units)
+    return _r2(units * pv)
+
+
+def _portal_options(held_card_ids: List[str], category: str, amount: float) -> List[Dict]:
+    best: Dict[str, tuple] = {}   # portal name -> (card_id, value, card_name)
+    for cid in held_card_ids:
+        card = CATALOGUE_BY_ID.get(cid)
+        if not card or not card.portal_name:
+            continue
+        v = _portal_value(card, category, amount)
+        if v <= 0:
+            continue
+        cur = best.get(card.portal_name)
+        if cur is None or v > cur[1]:
+            best[card.portal_name] = (cid, v, card.name)
+    opts = []
+    for pname, (cid, v, cname) in best.items():
+        opts.append({
+            "channel_key": PORTAL_KEYS.get(pname, pname.lower().replace(" ", "_")),
+            "channel_name": pname,
+            "how": f"Book inside {pname} paying with {cname}",
+            "best_card_id": cid,
+            "best_card_name": cname,
+            "reward_inr": v,
+            "instant_offer_inr": 0.0,
+            "total_benefit_inr": v,
+            "effective_pct": _r2(v / amount * 100.0) if amount else 0.0,
+            "availability": "available",
+            "via_portal": True,
+            "book_url": PORTAL_URLS.get(pname),
+        })
+    return opts
+
+
+def _channels_for(category: str, brand_key: Optional[str]):
+    if category == "dining" and brand_key not in DELIVERY_BRANDS:
+        return "dining", DINING_CHANNELS
+    if category == "entertainment" and brand_key in (None, "bookmyshow", "pvr", "cinepolis", "district"):
+        return "movies", MOVIE_CHANNELS
+    if category == "travel_flights":
+        return "flights", FLIGHT_CHANNELS
+    if category == "travel_hotels":
+        return "hotels", HOTEL_CHANNELS
+    return None, None
+
+
+def compare_channels(
+    held_card_ids: List[str],
+    category: str,
+    amount: float,
+    brand_key: Optional[str] = None,
+    merchant: Optional[str] = None,
+    rail: str = "card",
+    persona: Optional[List[str]] = None,
+    city: Optional[str] = None,
+) -> Optional[Dict]:
+    """
+    Best card PER booking channel, channels ranked by total rupee benefit.
+    When the city is known, channels confirmed absent there are dropped and
+    unverified listings are flagged. Returns None when the category has no
+    channel choice (or on the UPI rail, where instant offers don't apply and
+    the comparison collapses).
+    """
+    if rail == "upi" or not held_card_ids:
+        return None
+    kind, plan = _channels_for(category, brand_key)
+    if not plan:
+        return None
+
+    options = []
+    for ch in plan:
+        avail = channel_availability(ch["key"], kind, city, brand_key)
+        if avail == "unavailable":
+            continue
+        # Platform channels score against the platform's offers; the direct
+        # channel keeps the resolved walk-in brand (e.g. Copper Chimney's own
+        # card-linked offer) unless that brand is itself a platform.
+        if ch["brand_key"] is not None:
+            bk = ch["brand_key"]
+        else:
+            bk = None if brand_key in PLATFORM_BRANDS else brand_key
+        ctx = TxnContext(
+            category=category, amount=float(amount), merchant=merchant,
+            brand_key=bk, offers=active_offers_for(bk), rail="card",
+            channel=ch["channel"],
+        )
+        res = score_transaction(held_card_ids, ctx, include_discovery=False, persona=persona)
+        ranked = res["held_ranked"]
+        if not ranked:
+            continue
+        top = ranked[0]
+        options.append({
+            "channel_key": ch["key"],
+            "channel_name": ch["name"],
+            "how": ch["how"],
+            "best_card_id": top["card_id"],
+            "best_card_name": top["card_name"],
+            "reward_inr": top["reward_value_inr"],
+            "instant_offer_inr": top["instant_offer_inr"],
+            "total_benefit_inr": top["total_value_inr"],
+            "effective_pct": top["effective_rate_pct"],
+            "availability": avail,
+            "via_portal": False,
+            "book_url": ch.get("url"),
+        })
+
+    # Issuer portals the user can actually use (portal-rated card in wallet).
+    portal_opts = _portal_options(held_card_ids, category, float(amount))
+    options.extend(portal_opts)
+
+    if len(options) < 2:
+        return None
+    options.sort(key=lambda o: -o["total_benefit_inr"])
+    best, second = options[0], options[1]
+    if city:
+        note = (f"Channels confirmed absent in {city.title()} are hidden; "
+                "listings we couldn't verify are flagged. Platform deals vary by city.")
+    else:
+        note = ("Assumes this merchant is available on each platform in your city; "
+                "platform availability and platform-funded deals vary.")
+    if portal_opts:
+        note += " Issuer-portal options earn points, assumed redeemed at full value."
+    return {
+        "kind": kind,
+        "options": options,
+        "best_channel": best["channel_key"],
+        "best_channel_name": best["channel_name"],
+        "delta_vs_next_inr": round(best["total_benefit_inr"] - second["total_benefit_inr"], 2),
+        "city": city,
+        "note": note,
+    }

app/connectors/__init__.py

@@ -0,0 +1,12 @@
+"""RewardPilot offer-ingestion connectors.
+
+Three source families feed the offers store, all normalised to one schema and
+gated by human QA before going live:
+
+  1. issuer_scrapers  - HDFC SmartBuy, Amex Offers, SBI, Axis offer pages
+  2. clo              - card-linked-offer networks (Fidel / Kard), the live feed
+  3. affiliate_feeds  - CashKaro / GrabOn / bank-partner feeds
+
+ingest.py orchestrates: gather -> normalise -> dedupe -> review queue -> approve
+-> curated_offers.json (which offers.py loads on top of the seed).
+"""

app/connectors/affiliate_feeds.py

@@ -0,0 +1,69 @@
+"""
+Affiliate / coupon feed connectors - CashKaro, GrabOn, bank-partner feeds.
+
+These provide bank-offer + coupon data (often via affiliate-network product
+feeds or partner APIs) and also tie into the affiliate-revenue line. Real pulls
+require a publisher key per network (CASHKARO_FEED_URL / GRABON_API_KEY); without
+them the connectors return representative samples so the pipeline runs.
+"""
+
+import os
+from datetime import date, timedelta
+from typing import List
+
+from .base import RawOffer
+
+_today = date.today().isoformat()
+_in45 = (date.today() + timedelta(days=45)).isoformat()
+
+
+def fetch_cashkaro() -> List[RawOffer]:
+    url = os.getenv("CASHKARO_FEED_URL")
+    if url:
+        try:
+            import httpx
+            rows = httpx.get(url, timeout=15).json()
+            return [_normalize_feed_row(r, "affiliate:cashkaro") for r in rows]
+        except Exception:
+            return []
+    return [
+        RawOffer("affiliate:cashkaro", "amazon", "Amazon", "pct", 10, _today, _in45,
+                 applies_to_issuer="SBI Card", min_spend=5000, max_discount=1500,
+                 channel="online", raw_text="SBI 10% off on Amazon (CashKaro)"),
+        RawOffer("affiliate:cashkaro", "myntra", "Myntra", "pct", 10, _today, _in45,
+                 applies_to_issuer="HDFC Bank", min_spend=3000, max_discount=1000,
+                 channel="online", categories=["apparel"], raw_text="HDFC 10% on Myntra"),
+    ]
+
+
+def fetch_grabon() -> List[RawOffer]:
+    if os.getenv("GRABON_API_KEY"):
+        return []  # real API mapping goes here
+    return [
+        RawOffer("affiliate:grabon", "oyo", "OYO", "pct", 15, _today, _in45,
+                 applies_to_issuer="HDFC Bank", max_discount=1000, channel="online",
+                 categories=["travel_hotels"], raw_text="15% off OYO with HDFC"),
+        RawOffer("affiliate:grabon", "nykaa", "Nykaa", "pct", 10, _today, _in45,
+                 applies_to_issuer="SBI Card", min_spend=2500, max_discount=750,
+                 channel="online", raw_text="10% off Nykaa with SBI"),
+    ]
+
+
+def _normalize_feed_row(row: dict, source: str) -> RawOffer:
+    return RawOffer(
+        source=source,
+        merchant_key=row.get("merchant_key", row.get("store", "")).lower().replace(" ", "_"),
+        merchant_name=row.get("store", ""),
+        type=row.get("type", "pct"),
+        value=float(row.get("value", 0)),
+        valid_from=row.get("valid_from", _today)[:10],
+        valid_to=row.get("valid_to", _in45)[:10],
+        applies_to_issuer=row.get("issuer", ""),
+        min_spend=float(row.get("min_spend", 0) or 0),
+        max_discount=(float(row["max_discount"]) if row.get("max_discount") else None),
+        channel=row.get("channel", "online"),
+        raw_text=row.get("title", ""),
+    )
+
+
+ALL_AFFILIATE_FETCHERS = [("cashkaro", fetch_cashkaro), ("grabon", fetch_grabon)]

app/connectors/base.py

@@ -0,0 +1,57 @@
+"""Shared types + normalisation for all offer connectors."""
+
+from dataclasses import dataclass, field, asdict
+from datetime import date
+from typing import List, Optional, Dict
+import hashlib
+
+
+@dataclass
+class RawOffer:
+    """What a connector emits before normalisation/QA."""
+    source: str                      # issuer:hdfc_smartbuy | clo:fidel | affiliate:cashkaro
+    merchant_key: str
+    merchant_name: str
+    type: str                        # pct | flat | cashback | nocost_emi
+    value: float
+    valid_from: str
+    valid_to: str
+    applies_to_issuer: str = ""      # "" if card-specific or any
+    card_id: Optional[str] = None
+    min_spend: float = 0.0
+    max_discount: Optional[float] = None
+    categories: Optional[List[str]] = None
+    channel: str = "both"
+    raw_text: str = ""               # original text, kept for the QA reviewer
+
+
+def dedupe_key(r: RawOffer) -> str:
+    """Two offers from different sources for the same merchant+issuer+type collapse."""
+    basis = f"{r.merchant_key}|{r.applies_to_issuer}|{r.card_id}|{r.type}|{r.value}|{r.valid_to}"
+    return hashlib.sha1(basis.encode()).hexdigest()[:12]
+
+
+def normalize(r: RawOffer) -> Dict:
+    """RawOffer -> the offers.py Offer dict shape, with QA + provenance fields."""
+    oid = "of_" + dedupe_key(r)
+    return {
+        "id": oid,
+        "merchant_key": r.merchant_key,
+        "merchant_name": r.merchant_name,
+        "applies_to_issuer": r.applies_to_issuer,
+        "card_id": r.card_id,
+        "type": r.type,
+        "value": r.value,
+        "min_spend": r.min_spend,
+        "max_discount": r.max_discount,
+        "categories": r.categories,
+        "channel": r.channel,
+        "valid_from": r.valid_from,
+        "valid_to": r.valid_to,
+        "source": r.source,
+        "last_verified": date.today().isoformat(),
+        # QA metadata (stripped before serving to the app)
+        "_status": "pending",        # pending | approved | rejected
+        "_raw_text": r.raw_text,
+        "_dedupe": dedupe_key(r),
+    }

app/connectors/clo.py

@@ -0,0 +1,82 @@
+"""
+Card-linked-offer (CLO) connectors - Fidel / Kard style.
+
+CLO networks are the closest thing to a real-time feed and double as a revenue
+line (merchant-funded, you earn on redemption). They expose programmatic offer
+catalogues keyed by merchant + card network, and webhooks for redemption events.
+
+These clients call the real API only when the relevant key is set
+(FIDEL_API_KEY / KARD_API_KEY); otherwise they no-op and return samples so the
+pipeline runs. The response-normalisation (the part that matters) is real.
+"""
+
+import os
+from datetime import date, timedelta
+from typing import List
+
+from .base import RawOffer
+
+_today = date.today().isoformat()
+_in60 = (date.today() + timedelta(days=60)).isoformat()
+
+FIDEL_API_KEY = os.getenv("FIDEL_API_KEY")
+KARD_API_KEY = os.getenv("KARD_API_KEY")
+
+
+def _normalize_fidel(item: dict) -> RawOffer:
+    """Map a Fidel offer object to a RawOffer (field names per Fidel's schema)."""
+    return RawOffer(
+        source="clo:fidel",
+        merchant_key=item.get("brandKey", item.get("merchant", "")).lower().replace(" ", "_"),
+        merchant_name=item.get("brandName", item.get("merchant", "")),
+        type="cashback" if item.get("type", "discount") in ("cashback", "discount") else "pct",
+        value=float(item.get("returnRatePercentage", item.get("amount", 0))),
+        valid_from=item.get("startDate", _today)[:10],
+        valid_to=item.get("endDate", _in60)[:10],
+        applies_to_issuer=item.get("issuer", ""),
+        card_id=item.get("cardId"),
+        min_spend=float(item.get("minTransactionAmount", 0) or 0),
+        max_discount=(float(item["maxReward"]) if item.get("maxReward") else None),
+        channel=item.get("channel", "both"),
+        raw_text=item.get("description", ""),
+    )
+
+
+def fetch_fidel() -> List[RawOffer]:
+    if FIDEL_API_KEY:
+        try:
+            import httpx
+            r = httpx.get("https://api.fidel.uk/v1/offers",
+                          headers={"Fidel-Key": FIDEL_API_KEY}, timeout=15)
+            return [_normalize_fidel(o) for o in r.json().get("items", [])]
+        except Exception:
+            return []
+    # sample (no key configured)
+    return [
+        RawOffer("clo:fidel", "amazon", "Amazon", "cashback", 5, _today, _in60,
+                 applies_to_issuer="", card_id="icici_amazon_pay", channel="online",
+                 raw_text="5% back at Amazon (CLO)"),
+        RawOffer("clo:fidel", "dmart", "DMart", "pct", 5, _today, _in60,
+                 applies_to_issuer="ICICI Bank", max_discount=300, channel="offline",
+                 categories=["groceries"], raw_text="5% back at DMart (CLO)"),
+    ]
+
+
+def fetch_kard() -> List[RawOffer]:
+    if KARD_API_KEY:
+        try:
+            import httpx
+            r = httpx.get("https://api.getkard.com/offers",
+                          headers={"Authorization": f"Bearer {KARD_API_KEY}"}, timeout=15)
+            # (Kard's schema differs; map similarly to _normalize_fidel.)
+            return []
+        except Exception:
+            return []
+    return [
+        RawOffer("clo:kard", "pharmeasy", "PharmEasy", "pct", 15, _today, _in60,
+                 applies_to_issuer="Axis Bank", max_discount=300, channel="online",
+                 categories=["pharmacy"], raw_text="15% back at PharmEasy (CLO)"),
+    ]
+
+
+ALL_CLO_FETCHERS = [("fidel", fetch_fidel), ("kard", fetch_kard)]

app/connectors/ingest.py

@@ -0,0 +1,113 @@
+"""
+Ingestion orchestrator + QA review gate.
+
+Flow:
+  gather()        run every connector (issuer + CLO + affiliate), isolate failures
+  normalize()     -> Offer dicts, dedupe across sources
+  write_queue()   -> offers_data/review_queue.json  (status = pending)
+  approve(ids)    move approved offers -> offers_data/curated_offers.json
+                  (offers.py loads this on top of the curated seed and serves it)
+
+Run a full cycle:
+    python -m connectors.ingest            # gather + queue
+    python -m connectors.ingest --approve  # gather + auto-approve everything (demo)
+
+In production `approve` is driven by a human reviewer (an internal console),
+never auto, so a bad scrape can't reach users.
+"""
+
+import json
+import os
+import sys
+from typing import Dict, List
+
+from .base import RawOffer, normalize
+from . import issuer_scrapers, clo, affiliate_feeds
+
+DATA_DIR = os.path.join(os.path.dirname(__file__), "..", "offers_data")
+QUEUE_PATH = os.path.join(DATA_DIR, "review_queue.json")
+CURATED_PATH = os.path.join(DATA_DIR, "curated_offers.json")
+
+ALL_FETCHERS = (
+    [(f"issuer:{n}", fn) for n, fn in issuer_scrapers.ALL_ISSUER_FETCHERS]
+    + [(f"clo:{n}", fn) for n, fn in clo.ALL_CLO_FETCHERS]
+    + [(f"affiliate:{n}", fn) for n, fn in affiliate_feeds.ALL_AFFILIATE_FETCHERS]
+)
+
+
+def gather() -> List[RawOffer]:
+    """Run every connector. A failure in one source never blocks the others."""
+    out: List[RawOffer] = []
+    for name, fn in ALL_FETCHERS:
+        try:
+            got = fn() or []
+            out.extend(got)
+            print(f"  [{name}] {len(got)} offers")
+        except Exception as e:  # pragma: no cover - defensive
+            print(f"  [{name}] FAILED: {e}")
+    return out
+
+
+def normalize_dedupe(raws: List[RawOffer]) -> Dict[str, dict]:
+    by_dedupe: Dict[str, dict] = {}
+    for r in raws:
+        o = normalize(r)
+        key = o["_dedupe"]
+        # keep the higher-value offer when two sources collide
+        if key not in by_dedupe or (o["value"] or 0) > (by_dedupe[key]["value"] or 0):
+            by_dedupe[key] = o
+    return {o["id"]: o for o in by_dedupe.values()}
+
+
+def _ensure_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+
+def write_queue(offers: Dict[str, dict]):
+    _ensure_dir()
+    with open(QUEUE_PATH, "w") as f:
+        json.dump(list(offers.values()), f, indent=2)
+
+
+def load_queue() -> List[dict]:
+    if not os.path.exists(QUEUE_PATH):
+        return []
+    with open(QUEUE_PATH) as f:
+        return json.load(f)
+
+
+def approve(ids=None):
+    """Move approved offers from the queue into the live curated file."""
+    queue = load_queue()
+    approved = [o for o in queue if (ids is None or o["id"] in ids)]
+    # strip QA-internal fields before serving
+    clean = []
+    for o in approved:
+        c = {k: v for k, v in o.items() if not k.startswith("_")}
+        clean.append(c)
+    _ensure_dir()
+    existing = []
+    if os.path.exists(CURATED_PATH):
+        with open(CURATED_PATH) as f:
+            existing = json.load(f)
+    by_id = {o["id"]: o for o in existing}
+    for o in clean:
+        by_id[o["id"]] = o
+    with open(CURATED_PATH, "w") as f:
+        json.dump(list(by_id.values()), f, indent=2)
+    return len(clean)
+
+
+def run(auto_approve: bool = False):
+    print("Gathering from", len(ALL_FETCHERS), "connectors...")
+    raws = gather()
+    offers = normalize_dedupe(raws)
+    write_queue(offers)
+    print(f"Normalised + deduped -> {len(offers)} offers queued for review ({QUEUE_PATH}).")
+    if auto_approve:
+        n = approve()
+        print(f"Auto-approved {n} offers -> live ({CURATED_PATH}).")
+
+
+if __name__ == "__main__":
+    run(auto_approve="--approve" in sys.argv)

app/connectors/issuer_scrapers.py

@@ -0,0 +1,96 @@
+"""
+Issuer offer-page scrapers - HDFC SmartBuy, Amex Offers, SBI, Axis.
+
+Production: fetch each issuer's live offers page with a managed scraping layer
+(Bright Data / Playwright), extract the structured fields, and emit RawOffers.
+The selectors/parse live in each `_parse_*` function. Until the live fetch is
+wired (it needs a scraping provider + per-issuer auth for personalised Amex/SBI
+offers), `fetch_*` return a small set of representative samples so the pipeline
+runs end to end.
+
+Each scraper is best-effort and isolated: a failure in one issuer never blocks
+the others (see ingest.gather).
+"""
+
+import os
+from datetime import date, timedelta
+from typing import List
+
+from .base import RawOffer
+
+_today = date.today().isoformat()
+_in90 = (date.today() + timedelta(days=90)).isoformat()
+
+# Set to "1" to attempt live fetches (requires SCRAPER_PROVIDER + creds).
+LIVE = os.getenv("SCRAPER_LIVE", "0") == "1"
+
+
+def _live_fetch(url: str) -> str:
+    """Hook for the managed scraping provider. Returns HTML, or '' if unavailable.
+
+    Intentionally a no-op unless SCRAPER_LIVE=1 and a provider key is present, so
+    the repo never depends on network access or hard-codes scraping logic that
+    could break. Wire Bright Data / Playwright here.
+    """
+    if not LIVE:
+        return ""
+    # TODO: provider = BrightData(api_key=os.environ["BRIGHTDATA_KEY"]); return provider.get(url)
+    return ""
+
+
+# --- HDFC SmartBuy ---------------------------------------------------------
+HDFC_OFFERS_URL = "https://offers.smartbuy.hdfcbank.com/"
+
+def _parse_hdfc_smartbuy(html: str) -> List[RawOffer]:
+    # TODO: real selectors -> RawOffer. Sample representative output below.
+    return [
+        RawOffer("issuer:hdfc_smartbuy", "croma", "Croma", "flat", 5000, _today, _in90,
+                 applies_to_issuer="HDFC Bank", min_spend=50000, channel="both",
+                 raw_text="₹5000 off on Croma with HDFC cards, min ₹50,000"),
+        RawOffer("issuer:hdfc_smartbuy", "myntra", "Myntra", "pct", 10, _today, _in90,
+                 applies_to_issuer="HDFC Bank", min_spend=3000, max_discount=1000,
+                 channel="online", categories=["apparel"], raw_text="10% off Myntra, up to ₹1000"),
+    ]
+
+def fetch_hdfc_smartbuy() -> List[RawOffer]:
+    return _parse_hdfc_smartbuy(_live_fetch(HDFC_OFFERS_URL))
+
+
+# --- Amex Offers (personalised; needs cardholder auth) ---------------------
+def fetch_amex_offers() -> List[RawOffer]:
+    # Amex Offers are per-cardholder; production pulls them post-consent via the
+    # member's account. Sample below.
+    return [
+        RawOffer("issuer:amex_offers", "starbucks", "Starbucks", "cashback", 15, _today, _in90,
+                 applies_to_issuer="American Express", max_discount=150, channel="offline",
+                 categories=["dining"], raw_text="Spend ₹500 get 15% back at Starbucks"),
+        RawOffer("issuer:amex_offers", "zomato", "Zomato", "cashback", 20, _today, _in90,
+                 applies_to_issuer="American Express", min_spend=500, max_discount=200,
+                 channel="online", categories=["dining"], raw_text="20% back on Zomato up to ₹200"),
+    ]
+
+
+# --- SBI Card offers -------------------------------------------------------
+def fetch_sbi_offers() -> List[RawOffer]:
+    return [
+        RawOffer("issuer:sbi", "bigbasket", "BigBasket", "pct", 5, _today, _in90,
+                 applies_to_issuer="SBI Card", min_spend=1500, max_discount=500,
+                 channel="online", categories=["groceries"], raw_text="5% off BigBasket"),
+    ]
+
+
+# --- Axis Bank offers ------------------------------------------------------
+def fetch_axis_offers() -> List[RawOffer]:
+    return [
+        RawOffer("issuer:axis", "reliance_digital", "Reliance Digital", "pct", 10, _today, _in90,
+                 applies_to_issuer="Axis Bank", min_spend=30000, max_discount=5000,
+                 channel="both", raw_text="10% off Reliance Digital, up to ₹5000"),
+    ]
+
+
+ALL_ISSUER_FETCHERS = [
+    ("hdfc_smartbuy", fetch_hdfc_smartbuy),
+    ("amex_offers", fetch_amex_offers),
+    ("sbi", fetch_sbi_offers),
+    ("axis", fetch_axis_offers),
+]

app/main.py

@@ -32,7 +32,7 @@ try:
 except ImportError:
     pass
 
-from fastapi import FastAPI, File, Form, UploadFile
+from fastapi import FastAPI, File, Form, UploadFile, Header, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
@@ -42,6 +42,18 @@ from scoring_engine import TxnContext, score_transaction, analyse_transaction_hi
 import llm
 import demo_data
 
+# Optional app-key gate. If APP_KEY is set as a Space secret, sensitive endpoints
+# (statement upload, recommend, voice) require a matching X-App-Key header. If
+# APP_KEY is unset (dev), they stay open. Basic abuse protection for the mobile
+# client, not end-user authentication.
+APP_KEY = os.getenv("APP_KEY")
+
+
+def require_app_key(x_app_key: Optional[str] = Header(default=None, alias="X-App-Key")):
+    if APP_KEY and x_app_key != APP_KEY:
+        raise HTTPException(status_code=401, detail="invalid_app_key")
+
+
 app = FastAPI(title="RewardPilot API", version="1.0.0")
 app.add_middleware(
     CORSMiddleware,
@@ -62,6 +74,9 @@ class RecommendRequest(BaseModel):
     merchant: Optional[str] = None
     persona: Optional[List[str]] = None
     rail: Optional[str] = None            # "card" | "upi"; if None, inferred from query
+    city: Optional[str] = None            # e.g. "Mumbai"; overrides query/GPS detection
+    lat: Optional[float] = None           # GPS fallback for city detection
+    lng: Optional[float] = None
 
 
 class AnalyzeRequest(BaseModel):
@@ -104,6 +119,46 @@ def cards():
     return {"cards": [_card_public(c) for c in all_cards()]}
 
 
+@app.get("/offers")
+def offers():
+    """All currently-active offers (dated). Fed by the ingestion connectors."""
+    from offers import all_active
+    items = all_active()
+    return {"count": len(items), "offers": items}
+
+
+@app.get("/offers/sources")
+def offer_sources():
+    """Live view of the ingestion pipeline: which connectors feed the offers
+    store and how many offers each currently contributes."""
+    from offers import all_active
+    by_source: dict = {}
+    for o in all_active():
+        by_source[o["source"]] = by_source.get(o["source"], 0) + 1
+    connectors = [
+        {"family": "issuer", "sources": ["hdfc_smartbuy", "amex_offers", "sbi", "axis"]},
+        {"family": "clo", "sources": ["fidel", "kard"]},
+        {"family": "affiliate", "sources": ["cashkaro", "grabon", "bank_partner"]},
+        {"family": "platform", "sources": ["dineout", "district"]},
+    ]
+    return {"connectors": connectors, "active_by_source": by_source, "total_active": sum(by_source.values())}
+
+
+@app.get("/offers/{merchant_key}")
+def offers_for(merchant_key: str):
+    from offers import active_offers_for
+    items = active_offers_for(merchant_key)
+    return {"merchant_key": merchant_key, "count": len(items), "offers": items}
+
+
+@app.get("/places/nearby")
+def places_nearby(lat: float, lng: float, radius: float = 150):
+    """Resolve nearby known-merchant candidates from coordinates (Google/Foursquare,
+    key held server-side). Empty if no provider key is configured."""
+    from places import nearby
+    return nearby(lat, lng, radius)
+
+
 @app.get("/demo")
 def demo():
     """Everything the app needs to demo with zero setup."""
@@ -114,7 +169,7 @@ def demo():
     }
 
 
-@app.post("/recommend")
+@app.post("/recommend", dependencies=[Depends(require_app_key)])
 def recommend(req: RecommendRequest):
     held = req.held_cards or demo_data.DEMO_WALLET
     persona = req.persona or demo_data.DEMO_PERSONA
@@ -143,11 +198,27 @@ def recommend(req: RecommendRequest):
     result["narration"] = llm.narrate_recommendation(
         result["context"], result["held_ranked"], result["discovery"]
     )
-    result["intent"] = {"category": category, "amount": amount, "merchant": merchant, "rail": rail}
+    # City: explicit request field > city named in the query > nearest metro from GPS.
+    from availability import normalize_city, extract_city, city_from_latlng
+    city = normalize_city(req.city)
+    if not city and req.query:
+        city = extract_city(req.query)
+    if not city and req.lat is not None and req.lng is not None:
+        city = city_from_latlng(req.lat, req.lng)
+
+    result["intent"] = {"category": category, "amount": amount, "merchant": merchant, "rail": rail, "city": city}
+    # Dine-in / movies / travel: same purchase, several booking apps. Rank the
+    # channels too (best card PER channel), so the answer is "pay via District
+    # with your Axis card", not just "use your Axis card".
+    from channels import compare_channels
+    result["channel_comparison"] = compare_channels(
+        held, category, float(amount), brand_key=brand_key, merchant=merchant,
+        rail=rail, persona=persona, city=city,
+    )
     return result
 
 
-@app.post("/voice")
+@app.post("/voice", dependencies=[Depends(require_app_key)])
 async def voice(audio: UploadFile = File(...), held_cards: Optional[str] = Form(None)):
     raw = await audio.read()
     transcript = llm.transcribe(raw, filename=audio.filename or "audio.m4a")
@@ -157,15 +228,14 @@ async def voice(audio: UploadFile = File(...), held_cards: Optional[str] = Form(
     return rec
 
 
-@app.post("/statements/parse")
+@app.post("/statements/parse", dependencies=[Depends(require_app_key)])
 async def parse_statements(
     files: List[UploadFile] = File(...),
     password: Optional[str] = Form(None),
 ):
-    from statement_parser import parse_statement, detect_credit_limit
+    from statement_parser import parse_statement
     all_txns = []
     errors = []
-    limits = []
     for f in files:
         try:
             content = await f.read()
@@ -173,16 +243,9 @@ async def parse_statements(
             for t in txns:
                 t["source_file"] = f.filename
             all_txns.extend(txns)
-            try:
-                lim = detect_credit_limit(f.filename, content, password=password)
-                if lim:
-                    limits.append(lim)
-            except Exception:
-                pass   # credit-limit detection is best-effort, never fails the parse
         except Exception as e:
             errors.append({"file": f.filename, "error": str(e)})
-    return {"transactions": all_txns, "count": len(all_txns), "errors": errors,
-            "credit_limit": max(limits) if limits else None}
+    return {"transactions": all_txns, "count": len(all_txns), "errors": errors}
 
 
 @app.post("/transactions/analyze")
@@ -197,9 +260,10 @@ def discover(card_id: str):
     card = get_card(card_id)
     if not card:
         return {"error": "card_not_found"}
+    from scoring_engine import apply_url_for
     return {
         "card": _card_public(card),
-        "apply_url": f"https://rewardpilot.app/apply/{card_id}",  # placeholder deep link
+        "apply_url": apply_url_for(card_id),   # official issuer page (affiliate deep link later)
         "extra_benefits": card.highlights,
         "why": (
             f"Based on your spending pattern, {card.name} would beat your current "

app/merchants.py

@@ -1,118 +1,196 @@
 """
 RewardPilot - Merchant & MCC resolution
 =======================================
-Maps a free-text merchant / spoken phrase to a canonical category and detects
-live brand offers. In production this is backed by a continuously curated
-merchant table + a live offers feed; here it is a deterministic keyword resolver
-that is good enough for real demos and a real first version.
+Maps a free-text merchant / spoken phrase to a canonical category, a brand key,
+the payment rail, and the live structured offers from offers.py.
+
+Broad Indian coverage across online and offline retail. Merchant brand keys line
+up with offers.CATALOGUE merchant_key values where offers exist.
 """
 
 import re
 from typing import Dict, List, Optional, Tuple
 
-# Canonical categories used across the engine
 CATEGORIES = [
     "dining", "groceries", "fuel", "online_shopping", "electronics",
     "travel_flights", "travel_hotels", "utilities", "insurance", "education",
     "rent", "wallet_load", "entertainment", "apparel", "pharmacy", "general",
 ]
 
-# merchant keyword -> (canonical category, brand_key)
+# keyword -> (canonical category, brand_key)
 MERCHANT_MAP: Dict[str, Tuple[str, Optional[str]]] = {
-    # electronics / large format retail
-    "croma": ("electronics", "croma"),
+    # --- Electronics / large-format (offline + online) ---
     "reliance digital": ("electronics", "reliance_digital"),
     "vijay sales": ("electronics", "vijay_sales"),
-    "apple": ("electronics", "apple"),
+    "croma": ("electronics", "croma"),
     "imagine": ("electronics", "apple"),
+    "apple": ("electronics", "apple"),
     "iphone": ("electronics", "apple"),
-    # online marketplaces
+    "macbook": ("electronics", "apple"),
+    "ipad": ("electronics", "apple"),
+    "samsung": ("electronics", "samsung"),
+    "oneplus": ("electronics", "oneplus"),
+    "boat": ("electronics", "boat"),
+    "laptop": ("electronics", None),
+    "mobile phone": ("electronics", None),
+    "headphones": ("electronics", None),
+    "television": ("electronics", None),
+    # --- Online marketplaces / fashion / beauty ---
     "amazon": ("online_shopping", "amazon"),
     "flipkart": ("online_shopping", "flipkart"),
     "myntra": ("apparel", "myntra"),
     "ajio": ("apparel", "ajio"),
-    "tata cliq": ("online_shopping", "tata_cliq"),
     "nykaa": ("online_shopping", "nykaa"),
     "meesho": ("online_shopping", "meesho"),
-    # food / dining
+    "tata cliq": ("online_shopping", "tata_cliq"),
+    "tatacliq": ("online_shopping", "tata_cliq"),
+    "snapdeal": ("online_shopping", "snapdeal"),
+    "jiomart": ("groceries", "jiomart"),
+    "pepperfry": ("online_shopping", "pepperfry"),
+    "urban ladder": ("online_shopping", "urban_ladder"),
+    "firstcry": ("online_shopping", "firstcry"),
+    "lenskart": ("online_shopping", "lenskart"),
+    "decathlon": ("online_shopping", "decathlon"),
+    "ikea": ("online_shopping", "ikea"),
+    # --- Food delivery / quick commerce / dining ---
     "swiggy": ("dining", "swiggy"),
     "instamart": ("groceries", "instamart"),
     "zomato": ("dining", "zomato"),
-    "dominos": ("dining", None),
-    "starbucks": ("dining", None),
-    "mcdonald": ("dining", None),
-    "restaurant": ("dining", None),
+    "blinkit": ("groceries", "blinkit"),
+    "zepto": ("groceries", "zepto"),
+    "dunzo": ("groceries", "dunzo"),
+    "eternal": ("dining", "zomato"),
+    # bank-statement descriptors (legal entity / aggregator names)
+    "bundl": ("dining", "swiggy"),                 # Bundl Technologies = Swiggy
+    "asspl": ("online_shopping", "amazon"),        # Amazon Seller Services Pvt Ltd
+    "amazon seller": ("online_shopping", "amazon"),
+    "blink commerce": ("groceries", "blinkit"),    # Blink Commerce = Blinkit
+    "dominos": ("dining", "dominos"),
+    "pizza hut": ("dining", "pizza_hut"),
+    "mcdonald": ("dining", "mcdonalds"),
+    "kfc": ("dining", "kfc"),
+    "starbucks": ("dining", "starbucks"),
+    "barbeque nation": ("dining", "barbeque_nation"),
+    "haldiram": ("dining", "haldiram"),
     "cafe": ("dining", None),
+    "restaurant": ("dining", None),
+    "dinner": ("dining", None),
+    "lunch": ("dining", None),
+    # dine-in bill-payment / booking platforms (channel comparison pivots on these)
     "dineout": ("dining", "dineout"),
-    # groceries
+    "swiggy dineout": ("dining", "dineout"),
+    "district": ("dining", "district"),   # Zomato's District: dining + movies + events
+    # well-known dine-in chains (walk-in restaurant offers)
+    "copper chimney": ("dining", "copper_chimney"),
+    # --- Groceries / hypermarket (offline) ---
     "bigbasket": ("groceries", "bigbasket"),
-    "blinkit": ("groceries", "blinkit"),
-    "zepto": ("groceries", "zepto"),
     "dmart": ("groceries", "dmart"),
-    "more": ("groceries", None),
+    "d-mart": ("groceries", "dmart"),
+    "reliance fresh": ("groceries", "reliance_fresh"),
+    "reliance smart": ("groceries", "reliance_fresh"),
+    "more supermarket": ("groceries", "more"),
+    "spencer": ("groceries", "spencers"),
+    "star bazaar": ("groceries", "star_bazaar"),
     "grocery": ("groceries", None),
-    # fuel
+    "groceries": ("groceries", None),
+    "kirana": ("groceries", None),
+    # --- Fuel ---
     "petrol": ("fuel", None),
+    "diesel": ("fuel", None),
     "fuel": ("fuel", None),
     "hpcl": ("fuel", None),
     "bpcl": ("fuel", None),
     "indian oil": ("fuel", None),
     "iocl": ("fuel", None),
-    # travel
+    "shell": ("fuel", None),
+    # --- Travel ---
     "makemytrip": ("travel_flights", "makemytrip"),
     "goibibo": ("travel_flights", "goibibo"),
     "cleartrip": ("travel_flights", "cleartrip"),
     "yatra": ("travel_flights", "yatra"),
     "ixigo": ("travel_flights", "ixigo"),
     "easemytrip": ("travel_flights", "easemytrip"),
-    "abhibus": ("transport", "abhibus"),
     "indigo": ("travel_flights", "indigo"),
     "air india": ("travel_flights", "air_india"),
     "vistara": ("travel_flights", "vistara"),
-    "flight": ("travel_flights", None),
-    "hotel": ("travel_hotels", None),
-    "oyo": ("travel_hotels", "oyo"),
-    "taj": ("travel_hotels", "taj"),
-    "marriott": ("travel_hotels", "marriott"),
+    "akasa": ("travel_flights", "akasa"),
+    "spicejet": ("travel_flights", "spicejet"),
     "irctc": ("transport", "irctc"),      # railways, not flights
     "redbus": ("transport", "redbus"),    # buses, not flights
+    "abhibus": ("transport", "abhibus"),
     # Reward/booking portals: category comes from the descriptor sub-type below.
     "smartbuy": ("general", "smartbuy"),
     "travel edge": ("travel_flights", "axis_travel_edge"),
     "traveledge": ("travel_flights", "axis_travel_edge"),
     "ishop": ("online_shopping", "icici_ishop"),
     "gyftr": ("online_shopping", "gyftr"),
-    # apparel
-    "zara": ("apparel", None),
-    "h&m": ("apparel", None),
-    "lifestyle": ("apparel", None),
-    "shoppers stop": ("apparel", None),
-    "marks": ("apparel", "marks_spencer"),
+    "flight": ("travel_flights", None),
+    "airline": ("travel_flights", None),
+    "hotel": ("travel_hotels", None),
+    "oyo": ("travel_hotels", "oyo"),
+    "taj": ("travel_hotels", "taj"),
+    "marriott": ("travel_hotels", "marriott"),
+    "itc hotel": ("travel_hotels", "itc"),
+    "agoda": ("travel_hotels", "agoda"),
+    "booking.com": ("travel_hotels", "booking"),
+    # --- Cabs / mobility ---
+    "ola": ("transport", "ola"),
+    "uber": ("transport", "uber"),
+    "rapido": ("transport", "rapido"),
+    "namma yatri": ("transport", "namma_yatri"),
+    "blusmart": ("transport", "blusmart"),
+    "meru": ("transport", "meru"),
+    # --- Apparel / department stores (offline) ---
+    "zara": ("apparel", "zara"),
+    "h&m": ("apparel", "hm"),
+    "lifestyle": ("apparel", "lifestyle"),
+    "shoppers stop": ("apparel", "shoppers_stop"),
+    "pantaloons": ("apparel", "pantaloons"),
     "westside": ("apparel", "westside"),
-    # entertainment
+    "marks": ("apparel", "marks_spencer"),
+    "uniqlo": ("apparel", "uniqlo"),
+    "clothes": ("apparel", None),
+    "apparel": ("apparel", None),
+    # --- Jewellery ---
+    "tanishq": ("apparel", "tanishq"),
+    "kalyan": ("apparel", "kalyan"),
+    "jewellery": ("apparel", None),
+    # --- Entertainment ---
     "bookmyshow": ("entertainment", "bookmyshow"),
     "pvr": ("entertainment", "pvr"),
-    "inox": ("entertainment", "inox"),
-    "netflix": ("entertainment", None),
+    "inox": ("entertainment", "pvr"),
+    "cinepolis": ("entertainment", "cinepolis"),
+    "netflix": ("entertainment", "netflix"),
+    "spotify": ("entertainment", "spotify"),
     "movie": ("entertainment", None),
-    # pharmacy / health
-    "pharmeasy": ("pharmacy", None),
-    "apollo": ("pharmacy", None),
-    "1mg": ("pharmacy", None),
-    "medplus": ("pharmacy", None),
+    # --- Pharmacy / health ---
+    "pharmeasy": ("pharmacy", "pharmeasy"),
+    "1mg": ("pharmacy", "tata_1mg"),
+    "tata 1mg": ("pharmacy", "tata_1mg"),
+    "netmeds": ("pharmacy", "netmeds"),
+    "apollo": ("pharmacy", "apollo"),
+    "medplus": ("pharmacy", "medplus"),
     "pharmacy": ("pharmacy", None),
-    # utilities / bills
+    "medicine": ("pharmacy", None),
+    "chemist": ("pharmacy", None),
+    # --- Services (offline) ---
+    "urban company": ("general", "urban_company"),
+    # --- Utilities / bills ---
     "electricity": ("utilities", None),
-    "bill": ("utilities", None),
     "broadband": ("utilities", None),
     "mobile recharge": ("utilities", None),
+    "recharge": ("utilities", None),
     "dth": ("utilities", None),
-    # education / insurance / rent
-    "school": ("education", None),
-    "college": ("education", None),
+    "gas bill": ("utilities", None),
+    "water bill": ("utilities", None),
+    "bill": ("utilities", None),
+    # --- Education / insurance / rent / wallet ---
+    "school fee": ("education", None),
+    "college fee": ("education", None),
     "tuition": ("education", None),
+    "byju": ("education", None),
     "insurance": ("insurance", None),
-    "premium": ("insurance", None),
+    "policy premium": ("insurance", None),
     "rent": ("rent", None),
     # ride-hailing / transport
     "uber": ("transport", "uber"),
@@ -146,53 +224,49 @@ MERCHANT_MAP: Dict[str, Tuple[str, Optional[str]]] = {
     "mamaearth": ("online_shopping", "mamaearth"),
     "decathlon": ("apparel", "decathlon"),
     "fashnear": ("online_shopping", "meesho"),
-    # wallet
     "paytm wallet": ("wallet_load", None),
     "wallet load": ("wallet_load", None),
+    "add money": ("wallet_load", None),
 }
 
-# Lightweight live-offer table (brand_key -> offer text). In production this is a
-# feed refreshed continuously; for a demo it is curated and date-stamped.
-LIVE_OFFERS: Dict[str, List[Dict]] = {
-    "croma": [
-        {"issuer": "HDFC Bank", "text": "INR 5,000 instant discount on HDFC credit cards (min INR 50,000)", "applies_to_issuer": "HDFC Bank"},
-        {"issuer": "ICICI Bank", "text": "No-cost EMI up to 9 months on ICICI cards", "applies_to_issuer": "ICICI Bank"},
-    ],
-    "amazon": [
-        {"issuer": "ICICI Bank", "text": "5% back with Amazon Pay ICICI card", "applies_to_issuer": "ICICI Bank"},
-        {"issuer": "SBI Card", "text": "10% instant discount on SBI cards (select days)", "applies_to_issuer": "SBI Card"},
-    ],
-    "flipkart": [
-        {"issuer": "Axis Bank", "text": "5% unlimited cashback on Flipkart Axis card", "applies_to_issuer": "Axis Bank"},
-    ],
-    "swiggy": [
-        {"issuer": "HDFC Bank", "text": "10% back with Swiggy HDFC card", "applies_to_issuer": "HDFC Bank"},
-    ],
-    "apple": [
-        {"issuer": "HDFC Bank", "text": "Instant cashback on HDFC cards via authorised resellers", "applies_to_issuer": "HDFC Bank"},
-    ],
-}
-
-
-# Retailers / merchants - preferred over product words so "iPhone at Croma"
-# resolves the merchant to Croma, not iPhone.
+# Retailers / merchants preferred over product words so "iPhone at Croma"
+# resolves to Croma, not iPhone.
 STORE_KEYWORDS = {
     "reliance digital", "vijay sales", "croma", "amazon", "flipkart", "myntra", "ajio",
-    "nykaa", "meesho", "swiggy", "instamart", "zomato", "dominos", "starbucks", "bigbasket",
-    "blinkit", "zepto", "dmart", "makemytrip", "goibibo", "indigo", "vistara", "oyo", "taj",
-    "bookmyshow", "pvr", "inox", "apollo", "pharmeasy", "westside",
-    "cleartrip", "yatra", "ixigo", "easemytrip", "abhibus", "redbus",
+    "nykaa", "meesho", "tata cliq", "tatacliq", "snapdeal", "jiomart", "pepperfry",
+    "firstcry", "lenskart", "decathlon", "ikea", "swiggy", "instamart", "zomato",
+    "blinkit", "zepto", "dunzo", "dominos", "starbucks", "barbeque nation", "bigbasket",
+    "dmart", "reliance fresh", "makemytrip", "goibibo", "cleartrip", "yatra", "ixigo",
+    "easemytrip", "indigo", "vistara", "oyo", "taj", "marriott", "agoda", "redbus",
+    "ola", "uber", "rapido", "zara", "lifestyle", "shoppers stop", "pantaloons",
+    "westside", "tanishq", "kalyan", "bookmyshow", "pvr", "cinepolis", "pharmeasy",
+    "1mg", "netmeds", "apollo", "medplus", "urban company",
     "smartbuy", "travel edge", "traveledge", "ishop", "gyftr",
+    "dineout", "swiggy dineout", "district", "copper chimney",
 }
 
+UPI_HINTS = ["upi", "scan", " qr", "qr code", "gpay", "google pay", "phonepe", "paytm", "bhim", "rupay"]
+
+
+def detect_rail(text: str):
+    t = (text or "").lower()
+    if any(h in t for h in UPI_HINTS):
+        return "upi"
+    if "swipe" in t or "tap" in t or "card" in t:
+        return "card"
+    return None
+
 
 _AGGREGATOR_BRANDS = {
     "makemytrip", "goibibo", "cleartrip", "yatra", "ixigo", "easemytrip",
     "smartbuy", "axis_travel_edge", "icici_ishop", "gyftr",
+    "district",   # Zomato District sells dining, movie tickets and events under one app
 }
 
 
-def _descriptor_subtype(t):
+def _descriptor_subtype(t: str):
+    """Read a category sub-type out of the full descriptor for aggregators/portals
+    (e.g. "SMARTBUY FLIGHT INDIGO", "EASEMYTRIP HOTEL", "SMARTBUY GIFT VOUCHER")."""
     if re.search(r"hotel|resort|homestay|\brooms?\b|\bstay\b|oyo|marriott|\btaj\b|hyatt|radisson", t):
         return "travel_hotels"
     if re.search(r"flight|airways|airline|\bair\b|indigo|vistara|spicejet|akasa|go\s?first", t):
@@ -203,14 +277,14 @@ def _descriptor_subtype(t):
         return "transport"
     if re.search(r"voucher|gift\s?card|e-?gift|giftcard|gyftr", t):
         return "online_shopping"
+    if re.search(r"movie|cinema|film|\bshow\b|pvr|inox|imax", t):
+        return "entertainment"
     return None
 
 
 def resolve_merchant(text: str) -> Dict:
-    """
-    Resolve a free-text phrase to category + brand + live offers.
-    Returns: {category, brand_key, matched_merchant, offers}
-    """
+    """Resolve a free-text phrase to category + brand + active offers (dated)."""
+    from offers import active_offers_for
     t = (text or "").lower()
     matched_merchant = None
     brand_key = None
@@ -223,36 +297,21 @@ def resolve_merchant(text: str) -> Dict:
         pick = sorted(pool, key=len, reverse=True)[0]
         category, brand_key = MERCHANT_MAP[pick]
         matched_merchant = pick
+        # For an aggregator/portal, the descriptor's sub-type overrides the default.
         if brand_key in _AGGREGATOR_BRANDS:
             category = _descriptor_subtype(t) or category
 
-    offers = LIVE_OFFERS.get(brand_key, []) if brand_key else []
     return {
         "category": category,
         "brand_key": brand_key,
         "matched_merchant": matched_merchant,
-        "offers": offers,
+        "offers": active_offers_for(brand_key),
     }
 
 
-UPI_HINTS = ["upi", "scan", " qr", "qr code", "gpay", "google pay", "phonepe", "paytm", "bhim", "rupay"]
-
-
-def detect_rail(text: str):
-    """Return 'upi', 'card', or None based on payment-method hints in the phrase."""
-    t = (text or "").lower()
-    if any(h in t for h in UPI_HINTS):
-        return "upi"
-    if "swipe" in t or "tap" in t or "card" in t:
-        return "card"
-    return None
-
-
 def extract_amount(text: str) -> Optional[float]:
-    """Pull an INR amount out of a spoken phrase, if present."""
     import re
     t = (text or "").lower().replace(",", "")
-    # patterns: "rs 50000", "50000 rupees", "worth 1.2 lakh", "₹80000"
     lakh = re.search(r"([\d.]+)\s*lakh", t)
     if lakh:
         return float(lakh.group(1)) * 100000
@@ -262,11 +321,9 @@ def extract_amount(text: str) -> Optional[float]:
     m = re.search(r"([\d.]+)\s*(?:rs|inr|rupees)", t)
     if m:
         return float(m.group(1))
-    # "80k" style
     m = re.search(r"([\d.]+)\s*k\b", t)
     if m:
         return float(m.group(1)) * 1000
-    # bare number fallback (matches the on-device parser)
     m = re.search(r"\b(\d{3,7})\b", t)
     if m:
         return float(m.group(1))

app/offers.py

@@ -135,10 +135,24 @@ CATALOGUE: List[Offer] = [
     Offer("of_cleartrip_amex", "cleartrip", "Cleartrip", "American Express", "flat", 1500, _TODAY, _FAR, "issuer:amex_offers", _LV, "online", min_spend=10000, categories=["travel_flights"]),
     Offer("of_oyo_hdfc", "oyo", "OYO", "HDFC Bank", "pct", 15, _TODAY, _FAR, "affiliate:grabon", _LV, "online", max_discount=1000, categories=["travel_hotels"]),
 
+    Offer("of_easemytrip_sbi", "easemytrip", "EaseMyTrip", "SBI Card", "pct", 10, _TODAY, _FAR, "affiliate:bank_partner", _LV, "online", max_discount=1500, min_spend=5000, categories=["travel_flights", "travel_hotels"]),
+
     # Entertainment
     Offer("of_bookmyshow_sbi", "bookmyshow", "BookMyShow", "SBI Card", "flat", 150, _TODAY, _FAR, "affiliate:bank_partner", _LV, "online", min_spend=400, categories=["entertainment"]),
+    Offer("of_bookmyshow_axis", "bookmyshow", "BookMyShow", "Axis Bank", "flat", 200, _TODAY, _FAR, "issuer:axis", _LV, "online", min_spend=800, categories=["entertainment"]),
     Offer("of_pvr_hdfc", "pvr", "PVR INOX", "HDFC Bank", "pct", 20, _TODAY, _FAR, "issuer:hdfc_smartbuy", _LV, "offline", max_discount=300, categories=["entertainment"]),
 
+    # Dine-in / ticketing platforms (Swiggy Dineout, Zomato District). Rows with an
+    # empty issuer are PLATFORM-funded deals - they apply whatever card is used, so
+    # they lift every card equally, which is what makes the channel comparison honest.
+    # District sells dining AND movies; the categories field keeps each offer scoped.
+    Offer("of_dineout_hdfc", "dineout", "Swiggy Dineout", "HDFC Bank", "pct", 15, _TODAY, _FAR, "issuer:hdfc_smartbuy", _LV, "online", max_discount=500, min_spend=1000, categories=["dining"]),
+    Offer("of_dineout_plat", "dineout", "Swiggy Dineout", "", "pct", 10, _TODAY, _FAR, "platform:dineout", _LV, "online", max_discount=300, categories=["dining"]),
+    Offer("of_district_axis", "district", "District (Zomato)", "Axis Bank", "pct", 20, _TODAY, _FAR, "issuer:axis", _LV, "online", max_discount=500, min_spend=2000, categories=["dining"]),
+    Offer("of_district_plat_dining", "district", "District (Zomato)", "", "pct", 15, _TODAY, _FAR, "platform:district", _LV, "online", max_discount=350, categories=["dining"]),
+    Offer("of_district_icici_movies", "district", "District (Zomato)", "ICICI Bank", "flat", 100, _TODAY, _FAR, "affiliate:bank_partner", _LV, "online", min_spend=500, categories=["entertainment"]),
+    Offer("of_district_plat_movies", "district", "District (Zomato)", "", "pct", 10, _TODAY, _FAR, "platform:district", _LV, "online", max_discount=200, categories=["entertainment"]),
+
     # Fashion / department stores (offline)
     Offer("of_lifestyle_axis", "lifestyle", "Lifestyle", "Axis Bank", "pct", 10, _TODAY, _FAR, "affiliate:bank_partner", _LV, "offline", max_discount=1000, min_spend=3000, categories=["apparel"]),
     Offer("of_shoppersstop_hdfc", "shoppers_stop", "Shoppers Stop", "HDFC Bank", "pct", 10, _TODAY, _FAR, "affiliate:bank_partner", _LV, "offline", max_discount=1000, categories=["apparel"]),
@@ -158,6 +172,7 @@ CATALOGUE: List[Offer] = [
     # Eating out (offline dining)
     Offer("of_starbucks_amex", "starbucks", "Starbucks", "American Express", "cashback", 15, _TODAY, _FAR, "issuer:amex_offers", _LV, "offline", max_discount=150, categories=["dining"]),
     Offer("of_barbequenation_hdfc", "barbeque_nation", "Barbeque Nation", "HDFC Bank", "pct", 15, _TODAY, _FAR, "affiliate:bank_partner", _LV, "offline", max_discount=500, categories=["dining"]),
+    Offer("of_copperchimney_amex", "copper_chimney", "Copper Chimney", "American Express", "cashback", 15, _TODAY, _FAR, "issuer:amex_offers", _LV, "offline", max_discount=300, categories=["dining"]),
 
     # An intentionally EXPIRED offer (proves date filtering works)
     Offer("of_amazon_hdfc_expired", "amazon", "Amazon", "HDFC Bank", "pct", 10, "2026-01-01", "2026-03-31", "affiliate:cashkaro", "2026-03-15", "online", max_discount=2000),

app/offers_data/curated_offers.json

@@ -0,0 +1,239 @@
+[
+  {
+    "id": "of_3aaeef4187aa",
+    "merchant_key": "croma",
+    "merchant_name": "Croma",
+    "applies_to_issuer": "HDFC Bank",
+    "card_id": null,
+    "type": "flat",
+    "value": 5000,
+    "min_spend": 50000,
+    "max_discount": null,
+    "categories": null,
+    "channel": "both",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:hdfc_smartbuy",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_6cce7407b995",
+    "merchant_key": "myntra",
+    "merchant_name": "Myntra",
+    "applies_to_issuer": "HDFC Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 10,
+    "min_spend": 3000,
+    "max_discount": 1000,
+    "categories": [
+      "apparel"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:hdfc_smartbuy",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_bb5020b1d9ad",
+    "merchant_key": "starbucks",
+    "merchant_name": "Starbucks",
+    "applies_to_issuer": "American Express",
+    "card_id": null,
+    "type": "cashback",
+    "value": 15,
+    "min_spend": 0.0,
+    "max_discount": 150,
+    "categories": [
+      "dining"
+    ],
+    "channel": "offline",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:amex_offers",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_92cd047ca960",
+    "merchant_key": "zomato",
+    "merchant_name": "Zomato",
+    "applies_to_issuer": "American Express",
+    "card_id": null,
+    "type": "cashback",
+    "value": 20,
+    "min_spend": 500,
+    "max_discount": 200,
+    "categories": [
+      "dining"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:amex_offers",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_1a608672de99",
+    "merchant_key": "bigbasket",
+    "merchant_name": "BigBasket",
+    "applies_to_issuer": "SBI Card",
+    "card_id": null,
+    "type": "pct",
+    "value": 5,
+    "min_spend": 1500,
+    "max_discount": 500,
+    "categories": [
+      "groceries"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:sbi",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_4e9eb395f8cd",
+    "merchant_key": "reliance_digital",
+    "merchant_name": "Reliance Digital",
+    "applies_to_issuer": "Axis Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 10,
+    "min_spend": 30000,
+    "max_discount": 5000,
+    "categories": null,
+    "channel": "both",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-09-27",
+    "source": "issuer:axis",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_e497f0ddbb1f",
+    "merchant_key": "amazon",
+    "merchant_name": "Amazon",
+    "applies_to_issuer": "",
+    "card_id": "icici_amazon_pay",
+    "type": "cashback",
+    "value": 5,
+    "min_spend": 0.0,
+    "max_discount": null,
+    "categories": null,
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-28",
+    "source": "clo:fidel",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_9eb6ab9699af",
+    "merchant_key": "dmart",
+    "merchant_name": "DMart",
+    "applies_to_issuer": "ICICI Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 5,
+    "min_spend": 0.0,
+    "max_discount": 300,
+    "categories": [
+      "groceries"
+    ],
+    "channel": "offline",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-28",
+    "source": "clo:fidel",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_ca586882fdc4",
+    "merchant_key": "pharmeasy",
+    "merchant_name": "PharmEasy",
+    "applies_to_issuer": "Axis Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 15,
+    "min_spend": 0.0,
+    "max_discount": 300,
+    "categories": [
+      "pharmacy"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-28",
+    "source": "clo:kard",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_d1ab6ac2e3c6",
+    "merchant_key": "amazon",
+    "merchant_name": "Amazon",
+    "applies_to_issuer": "SBI Card",
+    "card_id": null,
+    "type": "pct",
+    "value": 10,
+    "min_spend": 5000,
+    "max_discount": 1500,
+    "categories": null,
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-13",
+    "source": "affiliate:cashkaro",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_daea6c79fe6c",
+    "merchant_key": "myntra",
+    "merchant_name": "Myntra",
+    "applies_to_issuer": "HDFC Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 10,
+    "min_spend": 3000,
+    "max_discount": 1000,
+    "categories": [
+      "apparel"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-13",
+    "source": "affiliate:cashkaro",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_b65a45aa94a6",
+    "merchant_key": "oyo",
+    "merchant_name": "OYO",
+    "applies_to_issuer": "HDFC Bank",
+    "card_id": null,
+    "type": "pct",
+    "value": 15,
+    "min_spend": 0.0,
+    "max_discount": 1000,
+    "categories": [
+      "travel_hotels"
+    ],
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-13",
+    "source": "affiliate:grabon",
+    "last_verified": "2026-06-29"
+  },
+  {
+    "id": "of_e06d7fa78d17",
+    "merchant_key": "nykaa",
+    "merchant_name": "Nykaa",
+    "applies_to_issuer": "SBI Card",
+    "card_id": null,
+    "type": "pct",
+    "value": 10,
+    "min_spend": 2500,
+    "max_discount": 750,
+    "categories": null,
+    "channel": "online",
+    "valid_from": "2026-06-29",
+    "valid_to": "2026-08-13",
+    "source": "affiliate:grabon",
+    "last_verified": "2026-06-29"
+  }
+]

app/scoring_engine.py

@@ -59,6 +59,11 @@ def _persona_line(card_id: str, persona):
 
 
 def apply_url_for(card_id: str) -> str:
+    # Official issuer page when we have it; web search only as a last resort.
+    from apply_links import APPLY_URL
+    direct = APPLY_URL.get(card_id)
+    if direct:
+        return direct
     card = CATALOGUE_BY_ID.get(card_id)
     import urllib.parse
     q = urllib.parse.quote(f"{card.name if card else ''} credit card apply {card.issuer if card else ''}")