Update app.py

app.py

@@ -1,22 +1,29 @@
+"""
+HackTrack Scraper v5.0 - Structured extraction, no LLM
+- Devfolio : reads __NEXT_DATA__ JSON blob (Next.js SSR, 100% accurate dates)
+- Unstop   : calls api.unstop.com REST API directly (structured JSON)
+- Devpost  : reads <time datetime> tags + structured sidebar
+- Others   : regex fallback on bodyText
+"""
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 import asyncio
 import re
 import sys
+import json
+import httpx
 from urllib.parse import urlparse
-from typing import List
-from datetime import datetime
+from typing import List, Optional
+from datetime import datetime, timezone
 
 if sys.platform == "win32":
-    # Playwright launches a driver subprocess; Proactor loop supports subprocess APIs on Windows.
     asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
 
-app = FastAPI(title="HackTrack Scraper", version="3.0.0")
-
-# Global Playwright runtime objects reused across requests.
+app = FastAPI(title="HackTrack Scraper", version="5.0.0")
 playwright = None
-browser = None
+browser    = None
 
 app.add_middleware(
     CORSMiddleware,
@@ -26,10 +33,13 @@ app.add_middleware(
 )
 
 
+# ============================================================
+# MODELS
+# ============================================================
+
 class ScrapeRequest(BaseModel):
     url: str
 
-
 class ScrapeResponse(BaseModel):
     name: str = ""
     platform: str = ""
@@ -48,322 +58,384 @@ class ScrapeResponse(BaseModel):
     url: str = ""
 
 
+# ============================================================
+# PLATFORM DETECTION
+# ============================================================
+
 def detect_platform(url: str) -> str:
     domain = urlparse(url).netloc.lower()
-    if "devfolio" in domain:
-        return "Devfolio"
-    elif "unstop" in domain:
-        return "Unstop"
-    elif "devpost" in domain:
-        return "Devpost"
-    elif "dorahacks" in domain:
-        return "DoraHacks"
+    if "devfolio"    in domain: return "Devfolio"
+    if "unstop"      in domain: return "Unstop"
+    if "devpost"     in domain: return "Devpost"
+    if "dorahacks"   in domain: return "DoraHacks"
+    if "mlh.io"      in domain: return "MLH"
+    if "hackerearth" in domain: return "HackerEarth"
     return "Other"
 
 
 # ============================================================
-# DATE PARSING — robust multi-format
+# DATE HELPERS
 # ============================================================
-MONTH_MAP = {
-    "jan": 1, "january": 1, "feb": 2, "february": 2, "mar": 3, "march": 3,
-    "apr": 4, "april": 4, "may": 5, "jun": 6, "june": 6,
-    "jul": 7, "july": 7, "aug": 8, "august": 8, "sep": 9, "sept": 9, "september": 9,
-    "oct": 10, "october": 10, "nov": 11, "november": 11, "dec": 12, "december": 12,
-}
+
+def iso_to_date(val: Optional[str]) -> str:
+    """Convert ISO-8601 / Unix timestamp -> YYYY-MM-DD."""
+    if not val:
+        return ""
+    val = str(val).strip()
+    if re.fullmatch(r"\d{10}", val):
+        try:
+            return datetime.fromtimestamp(int(val), tz=timezone.utc).strftime("%Y-%m-%d")
+        except Exception:
+            return ""
+    if re.fullmatch(r"\d{13}", val):
+        try:
+            return datetime.fromtimestamp(int(val) / 1000, tz=timezone.utc).strftime("%Y-%m-%d")
+        except Exception:
+            return ""
+    m = re.match(r"(\d{4}-\d{2}-\d{2})", val)
+    if m:
+        return m.group(1)
+    return ""
 
 DATE_FORMATS = [
     "%Y-%m-%d", "%Y/%m/%d",
     "%d %B %Y", "%d %b %Y", "%d %B, %Y", "%d %b, %Y",
     "%B %d, %Y", "%b %d, %Y", "%B %d %Y", "%b %d %Y",
     "%m/%d/%Y", "%d/%m/%Y",
-    "%B %d", "%b %d",
 ]
 
-
-def parse_any_date(text: str, fallback_year: int = None) -> str:
-    """Parse many date formats to YYYY-MM-DD. Handles partial dates."""
-    if not text:
-        return ""
-    text = text.strip()
-    text = re.sub(r"(\d+)(st|nd|rd|th)", r"\1", text)
+def parse_any_date(text: str) -> str:
+    if not text: return ""
+    text = re.sub(r"(\d+)(st|nd|rd|th)", r"\1", text.strip())
     text = re.sub(r"\s+", " ", text)
-
-    if not fallback_year:
-        fallback_year = datetime.now().year
-
     for fmt in DATE_FORMATS:
         try:
             dt = datetime.strptime(text, fmt)
-            if dt.year == 1900:  # no year in format
-                dt = dt.replace(year=fallback_year)
-                if dt < datetime.now():
-                    dt = dt.replace(year=fallback_year + 1)
+            if dt.year == 1900:
+                dt = dt.replace(year=datetime.now().year)
             return dt.strftime("%Y-%m-%d")
         except ValueError:
             continue
     return ""
 
-
 def find_dates_near(text: str, keywords: List[str], window: int = 400) -> str:
-    """Find dates within `window` chars after any keyword."""
     lower = text.lower()
-    all_date_patterns = [
+    patterns = [
         r"(\d{4}[-/]\d{1,2}[-/]\d{1,2})",
-        r"(\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)[,]?\s+\d{4})",
-        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2}(?:st|nd|rd|th)?[,]?\s*\d{0,4})",
+        r"(\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?"
+        r"|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)"
+        r"[,]?\s+\d{4})",
+        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?"
+        r"|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)"
+        r"\s+\d{1,2}(?:st|nd|rd|th)?[,]?\s*\d{0,4})",
         r"(\d{1,2}/\d{1,2}/\d{4})",
     ]
     for kw in keywords:
         idx = lower.find(kw.lower())
-        if idx == -1:
-            continue
-        chunk = text[idx:idx + window]
-        for pat in all_date_patterns:
-            match = re.search(pat, chunk, re.IGNORECASE)
-            if match:
-                parsed = parse_any_date(match.group(1))
-                if parsed:
-                    return parsed
+        if idx == -1: continue
+        chunk = text[idx: idx + window]
+        for pat in patterns:
+            m = re.search(pat, chunk, re.IGNORECASE)
+            if m:
+                parsed = parse_any_date(m.group(1))
+                if parsed: return parsed
     return ""
 
 
 # ============================================================
-# EXTRACT from full page innerText (the reliable approach)
+# DEVFOLIO - __NEXT_DATA__ extraction script
 # ============================================================
 
-def extract_all_from_text(body_text: str, platform: str) -> dict:
-    """Extract hackathon details from page innerText using text patterns."""
-    result = {
-        "registration_deadline": "",
-        "submission_deadline": "",
-        "result_date": "",
-        "start_date": "",
-        "end_date": "",
-        "prize_pool": "",
-        "team_size": {"min": 1, "max": 4},
-        "problem_statements": [],
+DEVFOLIO_SCRIPT = """() => {
+    const nextEl = document.getElementById('__NEXT_DATA__');
+    let nextData = null;
+    if (nextEl) { try { nextData = JSON.parse(nextEl.textContent); } catch(e) {} }
+
+    function findHackathon(obj, depth) {
+        if (!obj || typeof obj !== 'object' || depth > 8) return null;
+        if (obj.starts_at || obj.registration_deadline || obj.ends_at || obj.slug) return obj;
+        for (const k of Object.keys(obj)) {
+            const child = obj[k];
+            if (child && typeof child === 'object') {
+                const found = findHackathon(child, depth + 1);
+                if (found) return found;
+            }
+        }
+        return null;
     }
 
-    # ---- DATES ----
-    # Registration deadline
-    result["registration_deadline"] = find_dates_near(body_text, [
-        "registration close", "registrations close", "register by",
-        "last date to register", "registration deadline", "applications close",
-        "apply by", "registration ends", "sign up deadline",
-    ])
+    let hackathon = nextData ? findHackathon(nextData, 0) : null;
 
-    # Submission deadline
-    result["submission_deadline"] = find_dates_near(body_text, [
-        "submission deadline", "submission closes", "submissions close",
-        "submit by", "last date to submit", "submission end",
-        "final submission", "project submission",
-        "deadline",  # generic fallback last
-    ])
+    const getMeta = (n) => {
+        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
+        return el ? el.getAttribute('content') || '' : '';
+    };
 
-    # Start date — Devfolio uses "Runs from Mar 25 - 26, 2026"
-    runs_from = re.search(
-        r"(?:runs?\s+from|starts?\s+(?:on|from)?|begins?\s+(?:on)?|commences?\s+(?:on)?)\s*[:\-]?\s*"
-        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2})"
-        r"(?:\s*[-–]\s*(\d{1,2}))?"
-        r"(?:[,\s]+(\d{4}))?",
-        body_text, re.IGNORECASE
-    )
-    if runs_from:
-        start_text = runs_from.group(1)
-        year = runs_from.group(3) or str(datetime.now().year)
-        result["start_date"] = parse_any_date(f"{start_text} {year}")
-        if runs_from.group(2) and runs_from.group(1):
-            month = runs_from.group(1).split()[0]
-            result["end_date"] = parse_any_date(f"{month} {runs_from.group(2)} {year}")
+    let name = '';
+    if (hackathon) name = hackathon.name || hackathon.title || '';
+    if (!name) {
+        const el = document.querySelector('h1');
+        if (el && el.textContent.trim().length > 2) name = el.textContent.trim();
+    }
+    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
 
-    if not result["start_date"]:
-        result["start_date"] = find_dates_near(body_text, [
-            "start date", "starts on", "begins on", "hackathon starts",
-            "event starts", "event date", "dates:",
-        ])
+    const banner      = (hackathon && (hackathon.cover_image || hackathon.banner_image)) || getMeta('og:image') || '';
+    const description = (hackathon && (hackathon.tagline || hackathon.description)) || getMeta('og:description') || '';
+    const starts_at   = (hackathon && (hackathon.starts_at || hackathon.start_date)) || '';
+    const ends_at     = (hackathon && (hackathon.ends_at   || hackathon.end_date))   || '';
+    const reg_dl      = (hackathon && (hackathon.registration_deadline || hackathon.registration_ends_at)) || '';
+    const sub_dl      = (hackathon && (hackathon.submission_deadline   || hackathon.submission_ends_at))   || '';
+    const result_date = (hackathon && (hackathon.result_date           || hackathon.results_at))           || '';
+
+    let prize_pool = '';
+    if (hackathon) {
+        if (hackathon.prize_pool != null) prize_pool = String(hackathon.prize_pool);
+        else if (hackathon.prize)         prize_pool = String(hackathon.prize);
+    }
 
-    if not result["end_date"]:
-        result["end_date"] = find_dates_near(body_text, [
-            "end date", "ends on", "hackathon ends", "event ends",
-        ])
-
-    # Result date
-    result["result_date"] = find_dates_near(body_text, [
-        "result", "winners announced", "announcement", "winner announcement",
-        "results declared", "shortlist",
-    ])
+    let team_min = 1, team_max = 4;
+    if (hackathon) {
+        if (hackathon.min_team_size) team_min = hackathon.min_team_size;
+        if (hackathon.max_team_size) team_max = hackathon.max_team_size;
+    }
 
-    # ---- PRIZE POOL ----
-    prize_patterns = [
-        r"(₹\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
-        r"(\$\s*[\d,]+(?:\.\d+)?(?:\s*(?:K|k|M|million|thousand))?)",
-        r"(€\s*[\d,]+(?:\.\d+)?)",
-        r"(£\s*[\d,]+(?:\.\d+)?)",
-        r"(INR\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
-        r"(Rs\.?\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
-    ]
+    const ps = [];
+    const seenPs = new Set();
+    const tracks = hackathon ? (hackathon.tracks || hackathon.themes || hackathon.problem_statements || []) : [];
+    if (Array.isArray(tracks)) {
+        for (const t of tracks) {
+            const title = t.title || t.name || t.track || (typeof t === 'string' ? t : '');
+            const desc  = t.description || t.desc || '';
+            if (title && !seenPs.has(title.toLowerCase())) {
+                seenPs.add(title.toLowerCase());
+                ps.push({ track: t.track || '', title: title, description: desc });
+            }
+        }
+    }
 
-    # Find prize amounts near keywords like "prize", "reward", "worth", "win"
-    prize_lower = body_text.lower()
-    for kw in ["prize", "reward", "worth", "winning", "bounty", "in cash", "in prizes"]:
-        idx = prize_lower.find(kw)
-        if idx == -1:
-            continue
-        # Search ±200 chars around keyword
-        start = max(0, idx - 200)
-        chunk = body_text[start:idx + 200]
-        for pat in prize_patterns:
-            match = re.search(pat, chunk, re.IGNORECASE)
-            if match:
-                result["prize_pool"] = match.group(1).strip()
-                break
-        if result["prize_pool"]:
-            break
+    const resourceLinks = [];
+    const seenHrefs = new Set();
+    const kws = ['problem','statement','pdf','rule','guideline','brochure','document','brief','challenge','track','theme','schedule','timeline'];
+    document.querySelectorAll('a[href]').forEach(function(a) {
+        const href = a.href || '';
+        const text = a.textContent.trim();
+        const hl = href.toLowerCase(), tl = text.toLowerCase();
+        if (seenHrefs.has(href) || !href || href === '#') return;
+        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
+        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
+        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
+        if (isPdf || isDrive || isRel) {
+            seenHrefs.add(href);
+            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
+        }
+    });
 
-    # Fallback: any large currency amount
-    if not result["prize_pool"]:
-        for pat in prize_patterns:
-            match = re.search(pat, body_text)
-            if match:
-                result["prize_pool"] = match.group(1).strip()
-                break
-
-    # ---- TEAM SIZE ----
-    team_patterns = [
-        r"team\s*size[:\s]*(\d+)\s*[-–to]+\s*(\d+)",
-        r"(\d+)\s*[-–to]+\s*(\d+)\s*(?:members?|people|participants?|per team)",
-        r"teams?\s+of\s+(?:up\s+to\s+)?(\d+)",
-        r"max(?:imum)?\s*(?:team)?\s*(?:size)?\s*[:\s]*(\d+)",
-        r"(\d+)\s*[-–]\s*(\d+)\s*$",  # in FAQ: "2 - 4"
+    return {
+        name: name.substring(0, 200),
+        description: description.substring(0, 2000),
+        banner_url: banner,
+        starts_at: starts_at,
+        ends_at: ends_at,
+        registration_deadline: reg_dl,
+        submission_deadline: sub_dl,
+        result_date: result_date,
+        prize_pool: prize_pool,
+        team_min: team_min,
+        team_max: team_max,
+        problem_statements: ps.slice(0, 20),
+        resource_links: resourceLinks.slice(0, 30),
+        bodyText: document.body.innerText.substring(0, 15000),
+        found_next_data: hackathon !== null,
+        hackathon_keys: hackathon ? Object.keys(hackathon).join(',') : ''
+    };
+}"""
+
+
+def parse_devfolio(data: dict) -> dict:
+    return {
+        "name":                  data.get("name", ""),
+        "description":           data.get("description", ""),
+        "banner_url":            data.get("banner_url", ""),
+        "start_date":            iso_to_date(data.get("starts_at")),
+        "end_date":              iso_to_date(data.get("ends_at")),
+        "registration_deadline": iso_to_date(data.get("registration_deadline")),
+        "submission_deadline":   iso_to_date(data.get("submission_deadline")),
+        "result_date":           iso_to_date(data.get("result_date")),
+        "prize_pool":            data.get("prize_pool", ""),
+        "team_size":             {"min": data.get("team_min", 1), "max": data.get("team_max", 4)},
+        "problem_statements":    data.get("problem_statements", []),
+        "resource_links":        data.get("resource_links", []),
+        "body_text":             data.get("bodyText", ""),
+        "found_structured":      data.get("found_next_data", False),
+    }
+
+
+# ============================================================
+# UNSTOP - Direct REST API
+# ============================================================
+
+def extract_unstop_id(url: str) -> Optional[str]:
+    m = re.search(r"-(\d{5,8})(?:/|$|\?)", url)
+    if m: return m.group(1)
+    m = re.search(r"/(\d{5,8})(?:/|$|\?)", url)
+    return m.group(1) if m else None
+
+
+async def fetch_unstop_api(opportunity_id: str) -> Optional[dict]:
+    headers = {
+        "User-Agent": "Mozilla/5.0 (compatible; HackTrackBot/1.0)",
+        "Accept": "application/json",
+        "Referer": "https://unstop.com/hackathons",
+    }
+    endpoints = [
+        f"https://unstop.com/api/public/opportunity/get-applied-detail?id={opportunity_id}",
+        f"https://unstop.com/api/public/opportunity/{opportunity_id}",
+        f"https://unstop.com/api/public/hackathon/{opportunity_id}",
     ]
-    for pat in team_patterns:
-        match = re.search(pat, body_text, re.IGNORECASE)
-        if match:
-            groups = [g for g in match.groups() if g]
-            if len(groups) == 2:
-                result["team_size"] = {"min": int(groups[0]), "max": int(groups[1])}
-            elif len(groups) == 1:
-                result["team_size"] = {"min": 1, "max": int(groups[0])}
-            break
+    for api_url in endpoints:
+        try:
+            async with httpx.AsyncClient(timeout=15) as client:
+                resp = await client.get(api_url, headers=headers)
+                if resp.status_code != 200:
+                    continue
+                data = resp.json()
+                opp = data.get("data") or data
+                if isinstance(opp, dict) and "opportunity" in opp:
+                    opp = opp["opportunity"]
+                if isinstance(opp, dict) and (opp.get("id") or opp.get("title")):
+                    print(f"[Unstop] API success from {api_url}")
+                    print(f"[Unstop] Keys: {list(opp.keys())[:15]}")
+                    return opp
+        except Exception as e:
+            print(f"[Unstop] {api_url} failed: {e}")
+    return None
+
+
+def parse_unstop_api(opp: dict) -> dict:
+    start_date   = iso_to_date(opp.get("start_date")  or opp.get("starts_at"))
+    end_date     = iso_to_date(opp.get("end_date")    or opp.get("ends_at"))
+    reg_deadline = iso_to_date(
+        opp.get("registrations_end_date") or
+        opp.get("registration_deadline")  or
+        opp.get("registration_end_date")
+    )
+    sub_deadline = iso_to_date(
+        opp.get("submission_end_date")  or
+        opp.get("submission_deadline")  or
+        opp.get("last_submission_date")
+    )
+    result_date = iso_to_date(opp.get("result_date") or opp.get("results_at"))
+
+    prize_pool = ""
+    if opp.get("prize_amount"):
+        prize_pool = str(opp["prize_amount"])
+    elif opp.get("prizes") and isinstance(opp["prizes"], list):
+        total = 0
+        for p in opp["prizes"]:
+            try: total += float(str(p.get("amount") or 0).replace(",", ""))
+            except: pass
+        if total:
+            prize_pool = "Rs. {:,}".format(int(total))
+    elif opp.get("total_prize"):
+        prize_pool = str(opp["total_prize"])
+
+    team_min = int(opp.get("min_team_size") or opp.get("min_team") or 1)
+    team_max = int(opp.get("max_team_size") or opp.get("max_team") or 4)
 
-    # ---- PROBLEM STATEMENTS / TRACKS / DOMAINS ----
     ps = []
     seen_ps = set()
-
-    # Pattern 1: "Domains: AI, ML, Web App" (Devfolio style)
-    domain_match = re.search(
-        r"(?:domains?|themes?|tracks?|categories|verticals|areas?)[:\s]+([^\n💡🏆🎁🎟️📍📅⏳📞🌮]+)",
-        body_text, re.IGNORECASE
-    )
-    if domain_match:
-        items = re.split(r"[,•|/]", domain_match.group(1))
-        for item in items:
-            item = item.strip().rstrip(".")
-            if 3 < len(item) < 150 and item.lower() not in seen_ps:
-                seen_ps.add(item.lower())
-                ps.append({"track": "", "title": item})
-
-    # Pattern 2: Numbered problem statements: "PS1: ...", "Problem Statement 1 - ..."
-    for match in re.finditer(
-        r"(?:PS|Problem\s*Statement|Theme|Track|Challenge)\s*#?(\d+)\s*[:\-–]\s*(.{5,200})",
-        body_text, re.IGNORECASE
-    ):
-        num = match.group(1)
-        title = match.group(2).strip().split("\n")[0]
-        if title.lower() not in seen_ps and len(title) > 4:
+    for r in (opp.get("rounds") or opp.get("problem_statements") or []):
+        if not isinstance(r, dict): continue
+        title = r.get("title") or r.get("name") or r.get("round_name") or ""
+        desc  = r.get("description") or r.get("details") or ""
+        if title and title.lower() not in seen_ps:
             seen_ps.add(title.lower())
-            ps.append({"track": f"Track {num}", "title": title})
-
-    # Pattern 3: Devpost-style theme tags (already in themes list from JS)
-    # Pattern 4: Bulleted lists after "Themes" or "Tracks" heading
-    for match in re.finditer(
-        r"(?:themes?|tracks?|problem\s*statements?|challenges?|domains?)\s*[:\n]"
-        r"((?:\s*[-•●▸]\s*.{5,200}\n?)+)",
-        body_text, re.IGNORECASE
-    ):
-        items = re.findall(r"[-•●▸]\s*(.{5,200})", match.group(1))
-        for item in items:
-            item = item.strip().split("\n")[0]
-            if item.lower() not in seen_ps and 4 < len(item) < 200:
-                seen_ps.add(item.lower())
-                ps.append({"track": "", "title": item})
+            ps.append({"track": "", "title": title, "description": desc[:300]})
 
-    result["problem_statements"] = ps[:20]
-    return result
+    tags = opp.get("tags") or opp.get("categories") or []
+    if isinstance(tags, list) and not ps:
+        for t in tags:
+            label = t.get("name") or t.get("label") or (t if isinstance(t, str) else "")
+            if label and label.lower() not in seen_ps:
+                seen_ps.add(label.lower())
+                ps.append({"track": "Theme", "title": label, "description": ""})
+
+    return {
+        "name":                  opp.get("title") or opp.get("name", ""),
+        "description":           (opp.get("short_description") or opp.get("description") or "")[:500],
+        "banner_url":            opp.get("banner_image") or opp.get("cover_image") or opp.get("image") or "",
+        "start_date":            start_date,
+        "end_date":              end_date,
+        "registration_deadline": reg_deadline,
+        "submission_deadline":   sub_deadline,
+        "result_date":           result_date,
+        "prize_pool":            prize_pool,
+        "team_size":             {"min": team_min, "max": team_max},
+        "problem_statements":    ps[:20],
+        "resource_links":        [],
+    }
 
 
 # ============================================================
-# PLAYWRIGHT SCRAPER — gets innerText + meta from rendered page
+# DEVPOST - <time datetime> tags + sidebar
 # ============================================================
 
-EXTRACT_SCRIPT = """() => {
-    const getMeta = (name) => {
-        const el = document.querySelector(`meta[property="${name}"], meta[name="${name}"]`);
+DEVPOST_SCRIPT = """() => {
+    const getMeta = function(n) {
+        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
         return el ? el.getAttribute('content') || '' : '';
     };
 
-    // Name: try multiple selectors
-    const nameSelectors = [
-        'h1',
-        '.hackathon-name', '.event-name', '.challenge-title',
-        '#challenge-title', '.opp-title',
-    ];
-    let name = '';
-    for (const sel of nameSelectors) {
-        const el = document.querySelector(sel);
-        if (el && el.textContent.trim().length > 2) {
-            name = el.textContent.trim();
-            break;
-        }
-    }
-    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
-
-    // Banner
-    const banner = getMeta('og:image') || '';
-
-    // Description
-    let description = getMeta('og:description') || getMeta('description') || '';
+    let name = getMeta('og:title') || document.title.split('|')[0].trim();
+    const h1 = document.querySelector('#challenge-title, h1.title, h1');
+    if (h1 && h1.textContent.trim().length > 2) name = h1.textContent.trim();
+
+    const banner      = getMeta('og:image') || '';
+    const description = getMeta('og:description') || '';
+
+    const timeMap = {};
+    document.querySelectorAll('time[datetime]').forEach(function(el) {
+        const dt  = el.getAttribute('datetime') || '';
+        const parent = el.closest('.deadline, .date, li, div');
+        const lbl = (parent ? parent.textContent : '').toLowerCase();
+        if      (lbl.includes('submission') || lbl.includes('submit'))  { if (!timeMap.submission)   timeMap.submission   = dt; }
+        else if (lbl.includes('registr')    || lbl.includes('apply'))   { if (!timeMap.registration) timeMap.registration = dt; }
+        else if (lbl.includes('result')     || lbl.includes('winner'))  { if (!timeMap.result)       timeMap.result       = dt; }
+        else if (lbl.includes('start')      || lbl.includes('begin'))   { if (!timeMap.start)        timeMap.start        = dt; }
+        else if (lbl.includes('end')        || lbl.includes('close'))   { if (!timeMap.end)          timeMap.end          = dt; }
+        else if (!timeMap.first)                                         { timeMap.first              = dt; }
+    });
 
-    // Full page text for parsing
-    const bodyText = document.body.innerText;
+    let prize_pool = '';
+    const prizeSection = document.querySelector('#prizes, .prize-amount, [id*="prize"]');
+    if (prizeSection) {
+        const txt = prizeSection.textContent;
+        const m = txt.match(/([\\u20b9][\\d,]+|[$][\\d,]+(?:K|k|M)?)/);
+        if (m) prize_pool = m[1];
+        else prize_pool = txt.trim().substring(0, 80);
+    }
 
-    // For Devpost: extract themes from tag links
     const themes = [];
-    document.querySelectorAll('a[href*="themes"]').forEach(a => {
+    const seenT = new Set();
+    document.querySelectorAll('a[href*="themes"], .software-list a').forEach(function(a) {
         const t = a.textContent.trim();
-        if (t && t.length > 2 && t.length < 100) themes.push(t);
-    });
-
-    // Devpost sidebar prize text
-    let sidebarPrize = '';
-    document.querySelectorAll('a[href*="prizes"], .prize, [class*="prize"]').forEach(el => {
-        const t = el.textContent.trim();
-        if (t && t.length > 2) sidebarPrize += t + ' ';
+        if (t && t.length > 1 && t.length < 80 && !seenT.has(t)) { seenT.add(t); themes.push(t); }
     });
 
-    // Resource links: PDFs, Google Drive, problem statements, rules, guidelines
     const resourceLinks = [];
     const seenHrefs = new Set();
-    const linkKeywords = ['problem', 'statement', 'pdf', 'rule', 'guideline', 'brochure', 'document', 'brief', 'challenge', 'track', 'theme', 'schedule', 'timeline'];
-    document.querySelectorAll('a[href]').forEach(a => {
+    const kws = ['problem','statement','pdf','rule','guideline','document','challenge','track','theme','schedule'];
+    document.querySelectorAll('a[href]').forEach(function(a) {
         const href = a.href || '';
         const text = a.textContent.trim();
-        const hrefLower = href.toLowerCase();
-        const textLower = text.toLowerCase();
+        const hl = href.toLowerCase(), tl = text.toLowerCase();
         if (seenHrefs.has(href) || !href || href === '#') return;
-
-        const isPdf = hrefLower.endsWith('.pdf') || hrefLower.includes('/pdf');
-        const isDrive = hrefLower.includes('drive.google.com') || hrefLower.includes('docs.google.com');
-        const isDropbox = hrefLower.includes('dropbox.com');
-        const isRelevant = linkKeywords.some(kw => textLower.includes(kw) || hrefLower.includes(kw));
-
-        if (isPdf || isDrive || isDropbox || isRelevant) {
+        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
+        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
+        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
+        if (isPdf || isDrive || isRel) {
             seenHrefs.add(href);
-            resourceLinks.push({
-                text: text.substring(0, 150) || 'Document',
-                url: href,
-                type: isPdf ? 'pdf' : isDrive ? 'google_drive' : isDropbox ? 'dropbox' : 'link',
-            });
+            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
         }
     });
 
@@ -371,150 +443,350 @@ EXTRACT_SCRIPT = """() => {
         name: name.substring(0, 200),
         description: description.substring(0, 2000),
         banner_url: banner,
-        bodyText: bodyText.substring(0, 30000),
+        time_map: timeMap,
+        prize_pool: prize_pool,
         themes: themes,
-        sidebarPrize: sidebarPrize.trim(),
-        resourceLinks: resourceLinks.slice(0, 30),
+        resource_links: resourceLinks.slice(0, 30),
+        bodyText: document.body.innerText.substring(0, 15000)
     };
 }"""
 
 
-@app.on_event("startup")
-async def startup() -> None:
-    global playwright, browser
-    from playwright.async_api import async_playwright
+def parse_devpost(data: dict) -> dict:
+    tm = data.get("time_map", {})
+    ps = [{"track": "Theme", "title": t, "description": ""} for t in data.get("themes", [])]
+    return {
+        "name":                  data.get("name", ""),
+        "description":           data.get("description", ""),
+        "banner_url":            data.get("banner_url", ""),
+        "start_date":            iso_to_date(tm.get("start") or tm.get("first")),
+        "end_date":              iso_to_date(tm.get("end")),
+        "registration_deadline": iso_to_date(tm.get("registration")),
+        "submission_deadline":   iso_to_date(tm.get("submission")),
+        "result_date":           iso_to_date(tm.get("result")),
+        "prize_pool":            data.get("prize_pool", ""),
+        "team_size":             {"min": 1, "max": 4},
+        "problem_statements":    ps,
+        "resource_links":        data.get("resource_links", []),
+        "body_text":             data.get("bodyText", ""),
+    }
 
-    playwright = await async_playwright().start()
-    browser = await playwright.chromium.launch(
-        headless=True,
-        args=["--no-sandbox", "--disable-setuid-sandbox"],
+
+# ============================================================
+# GENERIC SCRIPT + REGEX FALLBACK
+# ============================================================
+
+GENERIC_SCRIPT = """() => {
+    const getMeta = function(n) {
+        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
+        return el ? el.getAttribute('content') || '' : '';
+    };
+    let name = '';
+    const sels = ['h1','.hackathon-name','.event-name','#challenge-title','.opp-title'];
+    for (let i = 0; i < sels.length; i++) {
+        const el = document.querySelector(sels[i]);
+        if (el && el.textContent.trim().length > 2) { name = el.textContent.trim(); break; }
+    }
+    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
+    const banner      = getMeta('og:image') || '';
+    const description = getMeta('og:description') || getMeta('description') || '';
+    const resourceLinks = [];
+    const seenHrefs = new Set();
+    const kws = ['problem','statement','pdf','rule','guideline','document','challenge','track','theme','schedule'];
+    document.querySelectorAll('a[href]').forEach(function(a) {
+        const href = a.href || '';
+        const text = a.textContent.trim();
+        const hl = href.toLowerCase(), tl = text.toLowerCase();
+        if (seenHrefs.has(href) || !href || href === '#') return;
+        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
+        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
+        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
+        if (isPdf || isDrive || isRel) {
+            seenHrefs.add(href);
+            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
+        }
+    });
+    return {
+        name: name.substring(0, 200),
+        description: description.substring(0, 2000),
+        banner_url: banner,
+        bodyText: document.body.innerText.substring(0, 20000),
+        resource_links: resourceLinks.slice(0, 30)
+    };
+}"""
+
+
+def regex_extract(body_text: str) -> dict:
+    result = {
+        "registration_deadline": "", "submission_deadline": "",
+        "result_date": "", "start_date": "", "end_date": "",
+        "prize_pool": "", "team_size": {"min": 1, "max": 4},
+        "problem_statements": [],
+    }
+    result["registration_deadline"] = find_dates_near(body_text, [
+        "registration close", "register by", "registration deadline",
+        "applications close", "apply by", "registration ends",
+    ])
+    result["submission_deadline"] = find_dates_near(body_text, [
+        "submission deadline", "submissions close", "submit by",
+        "final submission", "project submission", "deadline",
+    ])
+    runs = re.search(
+        r"(?:runs?\s+from|starts?\s+(?:on|from)?)\s*"
+        r"((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2})"
+        r"(?:\s*[-\u2013]\s*(\d{1,2}))?(?:[,\s]+(\d{4}))?",
+        body_text, re.IGNORECASE,
     )
-    print("[Scraper] Playwright browser initialized")
+    if runs:
+        year = runs.group(3) or str(datetime.now().year)
+        result["start_date"] = parse_any_date(f"{runs.group(1)} {year}")
+        if runs.group(2):
+            month = runs.group(1).split()[0]
+            result["end_date"] = parse_any_date(f"{month} {runs.group(2)} {year}")
+    if not result["start_date"]:
+        result["start_date"] = find_dates_near(body_text, ["start date","starts on","begins on"])
+    if not result["end_date"]:
+        result["end_date"]   = find_dates_near(body_text, ["end date","ends on","hackathon ends"])
+    result["result_date"]    = find_dates_near(body_text, ["result","winners announced","results declared"])
 
+    prize_patterns = [
+        r"(Rs\.?\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
+        r"(INR\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
+        r"(\$\s*[\d,]+(?:\s*(?:K|k|M))?)",
+        r"(\u20b9\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
+    ]
+    lower = body_text.lower()
+    for kw in ["prize","reward","worth","winning","bounty","in cash","in prizes"]:
+        idx = lower.find(kw)
+        if idx == -1: continue
+        chunk = body_text[max(0, idx-200): idx+200]
+        for pat in prize_patterns:
+            m = re.search(pat, chunk, re.IGNORECASE)
+            if m: result["prize_pool"] = m.group(1).strip(); break
+        if result["prize_pool"]: break
+    if not result["prize_pool"]:
+        for pat in prize_patterns:
+            m = re.search(pat, body_text)
+            if m: result["prize_pool"] = m.group(1).strip(); break
 
-@app.on_event("shutdown")
-async def shutdown() -> None:
-    global playwright, browser
+    for pat in [
+        r"team\s*size[:\s]*(\d+)\s*[-\u2013to]+\s*(\d+)",
+        r"(\d+)\s*[-\u2013to]+\s*(\d+)\s*(?:members?|people|per team)",
+        r"teams?\s+of\s+(?:up\s+to\s+)?(\d+)",
+        r"max(?:imum)?\s*(?:team)?\s*size\s*[:\s]*(\d+)",
+    ]:
+        m = re.search(pat, body_text, re.IGNORECASE)
+        if m:
+            g = [x for x in m.groups() if x]
+            result["team_size"] = (
+                {"min": int(g[0]), "max": int(g[1])} if len(g) == 2
+                else {"min": 1, "max": int(g[0])}
+            )
+            break
 
-    try:
-        if browser is not None:
-            await browser.close()
-            print("[Scraper] Browser closed")
-    finally:
-        browser = None
+    ps, seen = [], set()
+    dm = re.search(
+        r"(?:domains?|themes?|tracks?|categories|verticals)[:\s]+([^\n]+)",
+        body_text, re.IGNORECASE,
+    )
+    if dm:
+        for item in re.split(r"[,|/]", dm.group(1)):
+            item = item.strip().rstrip(".")
+            if 3 < len(item) < 150 and item.lower() not in seen:
+                seen.add(item.lower())
+                ps.append({"track": "", "title": item, "description": ""})
+    for m in re.finditer(
+        r"(?:PS|Problem\s*Statement|Theme|Track|Challenge)\s*#?(\d+)\s*[:\-]\s*(.{5,200})",
+        body_text, re.IGNORECASE,
+    ):
+        title = m.group(2).strip().split("\n")[0]
+        if title.lower() not in seen and len(title) > 4:
+            seen.add(title.lower())
+            ps.append({"track": f"Track {m.group(1)}", "title": title, "description": ""})
+    result["problem_statements"] = ps[:20]
+    return result
 
-    try:
-        if playwright is not None:
-            await playwright.stop()
-            print("[Scraper] Playwright stopped")
-    finally:
-        playwright = None
+
+# ============================================================
+# SAFE EVALUATE
+# ============================================================
+
+EMPTY_DATA = {"name": "", "description": "", "banner_url": "", "bodyText": "", "resource_links": []}
+
+async def safe_evaluate(page, script: str, fallback=None) -> dict:
+    for attempt in range(3):
+        try:
+            try:
+                await page.wait_for_load_state("networkidle", timeout=8000)
+            except Exception:
+                pass
+            return await page.evaluate(script)
+        except Exception as e:
+            err = str(e)
+            print(f"[Scraper] evaluate attempt {attempt+1} failed: {err[:120]}")
+            if "Execution context was destroyed" in err or "Frame was detached" in err:
+                print("[Scraper] Redirect detected, waiting to settle...")
+                try:
+                    await page.wait_for_load_state("domcontentloaded", timeout=12000)
+                    await asyncio.sleep(2)
+                except Exception:
+                    await asyncio.sleep(3)
+                continue
+            if fallback and attempt == 1:
+                script = fallback
+                continue
+            break
+    return EMPTY_DATA
+
+
+# ============================================================
+# MAIN SCRAPER
+# ============================================================
 
 async def scrape_with_playwright(url: str, platform: str) -> dict:
-    """Scrape using Playwright — renders JS, grabs full innerText for parsing."""
     global browser
+    if browser is None:
+        return {"scrape_success": False, "error": "Browser not initialized"}
+
+    # Unstop: try API first
+    if platform == "Unstop":
+        opp_id = extract_unstop_id(url)
+        print(f"[Unstop] Extracted ID: {opp_id}")
+        if opp_id:
+            opp = await fetch_unstop_api(opp_id)
+            if opp:
+                result = parse_unstop_api(opp)
+                result["scrape_success"] = bool(result.get("name"))
+                print(f"[Unstop] API: name='{result['name']}' reg={result['registration_deadline']} sub={result['submission_deadline']} ps={len(result['problem_statements'])}")
+                return result
+        print("[Unstop] API failed, falling back to Playwright")
+
+    context = await browser.new_context(
+        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+        viewport={"width": 1920, "height": 1080},
+    )
     try:
-        if browser is None:
-            return {
-                "scrape_success": False,
-                "error": "Browser is not initialized. Service startup failed.",
-            }
-
-        context = await browser.new_context(
-            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-            viewport={"width": 1920, "height": 1080},
-        )
-
+        page = await context.new_page()
+        print(f"[Scraper] => {url}  platform={platform}")
+        wait_until = "load" if platform in ("Devfolio", "MLH") else "domcontentloaded"
         try:
-            page = await context.new_page()
-
-            print(f"[Scraper] Navigating to {url} (platform: {platform})")
-            await page.goto(url, wait_until="domcontentloaded", timeout=20000)
-
-            # Wait for JS rendering — longer for SPAs
-            wait_time = 8 if platform in ("Unstop",) else 5
-            print(f"[Scraper] Waiting {wait_time}s for JS rendering...")
-            await page.wait_for_timeout(wait_time * 1000)
-
-            # Scroll to trigger lazy content
-            await page.evaluate("window.scrollTo(0, document.body.scrollHeight / 3)")
-            await asyncio.sleep(1)
-            await page.evaluate("window.scrollTo(0, document.body.scrollHeight * 2 / 3)")
-            await asyncio.sleep(1)
-            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
-            await asyncio.sleep(1)
-            await page.evaluate("window.scrollTo(0, 0)")
-            await asyncio.sleep(0.5)
-
-            # Extract structured + raw text data
-            data = await page.evaluate(EXTRACT_SCRIPT)
-
-            body_text = data.get("bodyText", "")
-            name = data.get("name", "")
-            description = data.get("description", "")
-
-            print(f"[Scraper] Extracted name: '{name}', bodyText length: {len(body_text)}")
-
-            # Parse all fields from full innerText
-            extracted = extract_all_from_text(body_text, platform)
-
-            # Devpost themes from sidebar tags
-            themes = data.get("themes", [])
-            if themes and not extracted["problem_statements"]:
-                seen = set()
-                for t in themes:
-                    if t.lower() not in seen:
-                        seen.add(t.lower())
-                        extracted["problem_statements"].append({"track": "Theme", "title": t})
-
-            # Sidebar prize fallback (Devpost)
-            if not extracted["prize_pool"] and data.get("sidebarPrize"):
-                prize_text = data["sidebarPrize"]
-                for pat in [r"(\$[\d,]+(?:\.\d+)?(?:\s*(?:K|k|M))?)", r"(₹[\d,]+)"]:
-                    m = re.search(pat, prize_text)
-                    if m:
-                        extracted["prize_pool"] = m.group(1)
-                        break
-                if not extracted["prize_pool"]:
-                    extracted["prize_pool"] = prize_text[:100]
-
-            return {
-                "name": name,
-                "description": description,
-                "banner_url": data.get("banner_url", ""),
-                "scrape_success": bool(name and len(name) > 2),
-                "resource_links": data.get("resourceLinks", []),
-                **extracted,
+            await page.goto(url, wait_until=wait_until, timeout=30000)
+        except Exception as e:
+            if "Timeout" not in str(e): raise
+            print("[Scraper] goto timeout, proceeding anyway")
+
+        wait_map = {"Unstop": 9, "DoraHacks": 8, "Devfolio": 8, "MLH": 4}
+        wait_sec = wait_map.get(platform, 5)
+        print(f"[Scraper] Waiting {wait_sec}s for JS...")
+        await page.wait_for_timeout(wait_sec * 1000)
+
+        for frac in [0.33, 0.66, 1.0, 0.0]:
+            try:
+                await page.evaluate(f"window.scrollTo(0, document.body.scrollHeight * {frac})")
+            except Exception:
+                pass
+            await asyncio.sleep(0.6)
+        await asyncio.sleep(1.0)
+
+        if platform == "Devfolio":
+            raw = await safe_evaluate(page, DEVFOLIO_SCRIPT, GENERIC_SCRIPT)
+            print(f"[Devfolio] found_next_data={raw.get('found_next_data')} keys={raw.get('hackathon_keys','')[:80]}")
+            result = parse_devfolio(raw)
+            # Regex fill for any empty structured fields
+            if not result.get("registration_deadline") or not result.get("start_date"):
+                print("[Devfolio] Filling gaps with regex")
+                regex = regex_extract(raw.get("bodyText", ""))
+                for f in ("start_date","end_date","registration_deadline","submission_deadline","result_date","prize_pool"):
+                    if not result.get(f) and regex.get(f):
+                        result[f] = regex[f]
+                if not result["problem_statements"]:
+                    result["problem_statements"] = regex.get("problem_statements", [])
+                if result["team_size"] == {"min": 1, "max": 4}:
+                    result["team_size"] = regex.get("team_size", {"min": 1, "max": 4})
+
+        elif platform == "Devpost":
+            raw = await safe_evaluate(page, DEVPOST_SCRIPT, GENERIC_SCRIPT)
+            result = parse_devpost(raw)
+            if not result.get("submission_deadline") or not result.get("start_date"):
+                regex = regex_extract(raw.get("bodyText", ""))
+                for f in ("start_date","end_date","registration_deadline","submission_deadline","result_date"):
+                    if not result.get(f) and regex.get(f):
+                        result[f] = regex[f]
+
+        else:
+            raw = await safe_evaluate(page, GENERIC_SCRIPT)
+            regex = regex_extract(raw.get("bodyText", ""))
+            result = {
+                "name":        raw.get("name", ""),
+                "description": raw.get("description", ""),
+                "banner_url":  raw.get("banner_url", ""),
+                "resource_links": raw.get("resource_links", []),
+                **regex,
             }
-        finally:
-            await context.close()
+
+        result["scrape_success"] = bool(result.get("name") and len(result.get("name","")) > 2)
+        print(f"[Scraper] Done: name='{result.get('name','')}' reg={result.get('registration_deadline','')} sub={result.get('submission_deadline','')} start={result.get('start_date','')} prize='{result.get('prize_pool','')}' ps={len(result.get('problem_statements',[]))}")
+        return result
 
     except Exception as e:
-        print(f"[Scraper] Error: {e}")
         import traceback
         traceback.print_exc()
         return {"scrape_success": False, "error": str(e)}
+    finally:
+        await context.close()
 
 
 # ============================================================
-# API ROUTES
+# APP LIFECYCLE & ROUTES
 # ============================================================
 
+@app.on_event("startup")
+async def startup() -> None:
+    global playwright, browser
+    from playwright.async_api import async_playwright
+    playwright = await async_playwright().start()
+    browser = await playwright.chromium.launch(
+        headless=True,
+        args=["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+    )
+    print("[Scraper] v5.0 ready - structured extraction (no LLM)")
+
+
+@app.on_event("shutdown")
+async def shutdown() -> None:
+    global playwright, browser
+    try:
+        if browser: await browser.close()
+    finally:
+        browser = None
+    try:
+        if playwright: await playwright.stop()
+    finally:
+        playwright = None
+
+
 @app.get("/")
 async def root():
-    return {"status": "ok", "service": "HackTrack Scraper v3"}
+    return {
+        "status": "ok",
+        "service": "HackTrack Scraper v5",
+        "strategy": "__NEXT_DATA__ + REST API + time-tags + regex",
+        "platforms": ["Devfolio", "Devpost", "Unstop", "DoraHacks", "MLH"],
+    }
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "timestamp": datetime.utcnow().isoformat()}
 
 
 @app.post("/scrape", response_model=ScrapeResponse)
 async def scrape(request: ScrapeRequest):
     url = request.url.strip()
     platform = detect_platform(url)
-    print(f"\n[Scraper] === New scrape request: {url} (platform={platform}) ===")
-
+    print(f"\n[Scraper] === {url}  platform={platform} ===")
     try:
         data = await scrape_with_playwright(url, platform)
-
-        response = ScrapeResponse(
+        return ScrapeResponse(
             name=data.get("name", ""),
             platform=platform,
             banner_url=data.get("banner_url", ""),
@@ -531,10 +803,6 @@ async def scrape(request: ScrapeRequest):
             scrape_success=data.get("scrape_success", False),
             url=url,
         )
-
-        print(f"[Scraper] Result: name='{response.name}', dates=({response.start_date}, {response.end_date}, reg={response.registration_deadline}, sub={response.submission_deadline}), prize='{response.prize_pool}', team={response.team_size}, ps={len(response.problem_statements)}")
-        return response
-
     except Exception as e:
         print(f"[Scraper] Endpoint error: {e}")
-        return ScrapeResponse(platform=platform, url=url, scrape_success=False)
+        return ScrapeResponse(platform=platform, url=url, scrape_success=False)