README.md

---
license: mit
---

## FalconNet/FunPay-Minecraft-Lots-Mini-6k
- Prices are in Rubles


### Script used to create this:
```python
from __future__ import annotations

import argparse
import asyncio
import csv
import json
import re
from dataclasses import dataclass, asdict
from pathlib import Path
from typing import List, Optional

from bs4 import BeautifulSoup
from playwright.async_api import async_playwright, TimeoutError as PlaywrightTimeout


@dataclass
class Lot:
    """Represents a single offer on FunPay."""

    lot_id: int
    server: str
    title: str
    category: str
    seller: str
    reviews: int
    price: float
    currency: str
    link: str


class FunpayParser:
    """High-level API for scraping the public FunPay catalog."""

    BASE_URL = "https://funpay.com"

    def __init__(
        self,
        language: str = "ru",
        currency: str = "RUB",
        headless: bool = False,
        timeout: int = 10_000,
    ) -> None:
        self.language = language
        self.currency = currency
        self.headless = headless
        self.timeout = timeout

    # ─────────────────────────── internal helpers ──────────────────────────── #

    async def _fetch_html(self, url: str) -> str:
        """Render *url* with Playwright and return the final HTML source."""
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=self.headless)
            context = await browser.new_context(
                locale=self.language,
                extra_http_headers={
                    "Accept-Language": self.language,
                    "User-Agent": (
                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                        "AppleWebKit/537.36 (KHTML, like Gecko) "
                        "Chrome/124.0.0.0 Safari/537.36"
                    ),
                },
            )
            # Pre-set currency so the prices are parsed consistently
            await context.add_cookies(
                [
                    {
                        "name": "cy",
                        "value": self.currency,
                        "domain": "funpay.com",
                        "path": "/",
                    }
                ]
            )

            page = await context.new_page()
            try:
                # Navigate and wait for the full page load, including JS content
                await page.goto(url, wait_until="load", timeout=self.timeout)

                # Явное ожидание появления важного элемента (например, списка лотов)
                await page.wait_for_selector(".tc-item", timeout=10_000)  # Ждем появления первого лота

            except PlaywrightTimeout:
                await browser.close()
                raise RuntimeError(f"Page load timeout: {url}")

            # Accept cookies banner if present
            try:
                await page.locator("button:has-text('Agree')").click(timeout=2_000)
            except PlaywrightTimeout:
                pass  # banner not shown

            html = await page.content()
            await browser.close()
            return html

    def _parse_html(self, html: str) -> List[Lot]:
        """Extract structured data from the rendered HTML using BeautifulSoup."""
        soup = BeautifulSoup(html, "lxml")
        lots: List[Lot] = []

        for anchor in soup.select("a.tc-item"):
            link = self.BASE_URL + anchor.get("href", "")

            # Server / sub-category (can be empty)
            server_el = anchor.select_one(".tc-server")
            server = server_el.get_text(strip=True) if server_el else ""

            # Title / description
            title_el = anchor.select_one(".tc-desc") or anchor.select_one(".tc-title")
            title = title_el.get_text(strip=True) if title_el else ""

            # Small badge with an additional category mark
            badge_el = anchor.select_one(".badge")
            category = badge_el.get_text(strip=True) if badge_el else ""

            # Seller block
            seller_el = anchor.select_one(".media-user-name")
            seller = seller_el.get_text(strip=True) if seller_el else ""
            # Reviews are rendered as “(1234)”
            rev_el = anchor.select_one(".rating-count")
            reviews = int(rev_el.get_text(strip=True).strip("()")) if rev_el else 0

            # Price block
            price_el = anchor.select_one(".tc-price")
            price_val, price_curr = 0.0, self.currency
            if price_el:
                match = re.match(r"([\d\.,]+)\s*([^\d\s]+)", price_el.get_text(strip=True))
                if match:
                    raw, price_curr = match.groups()
                    price_val = float(raw.replace(",", "."))

            # Lot ID is available only in the lot link
            match_id = re.search(r"id=(\d+)", link)
            lot_id = int(match_id.group(1)) if match_id else 0

            lots.append(
                Lot(
                    lot_id=lot_id,
                    server=server,
                    title=title,
                    category=category,
                    seller=seller,
                    reviews=reviews,
                    price=price_val,
                    currency=price_curr,
                    link=link,
                )
            )
        return lots

    async def _collect_lots(self, section_id: int, pages: int) -> List[Lot]:
        """Coroutine that loads *pages* pages for *section_id* sequentially."""
        result: List[Lot] = []
        for idx in range(1, pages + 1):
            url = f"{self.BASE_URL}/{self.language}/lots/{section_id}/?page={idx}"
            html = await self._fetch_html(url)
            page_lots = self._parse_html(html)
            if not page_lots:
                break  # reached last page
            result.extend(page_lots)
        return result

    # ───────────────────────────── public API ──────────────────────────────── #

    def parse(self, section_id: int, pages: int = 1) -> List[Lot]:
        """Synchronously scrape *pages* from a lots section."""
        return asyncio.run(self._collect_lots(section_id, pages))


# I/O helpers remain unchanged

def save_json(lots: List[Lot], path: Path) -> None:
    path.write_text(json.dumps([asdict(x) for x in lots], ensure_ascii=False, indent=2), "utf-8")

def save_csv(lots: List[Lot], path: Path) -> None:
    if not lots:
        return
    with path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=asdict(lots[0]).keys())
        writer.writeheader()
        for row in lots:
            writer.writerow(asdict(row))


# CLI entry unchanged
if __name__ == "__main__":
    def _cli() -> None:
        parser = argparse.ArgumentParser(description="Scrape FunPay lots into JSON/CSV files")
        parser.add_argument("section", type=int, help="Section numeric ID (e.g. 223 for Minecraft Services)")
        parser.add_argument("--pages", type=int, default=1, help="Number of paginated screens to scan")
        parser.add_argument("--out", type=Path, help="Output file (.json or .csv)")
        parser.add_argument("--headed", action="store_true", help="Run browser in headed mode (for debugging)")

        args = parser.parse_args()

        funpay = FunpayParser(headless=not args.headed)
        lots = funpay.parse(args.section, pages=args.pages)
        print(f"Collected {len(lots)} lots from section #{args.section}")

        if args.out:
            if args.out.suffix == ".json":
                save_json(lots, args.out)
            elif args.out.suffix == ".csv":
                save_csv(lots, args.out)
            else:
                raise SystemExit("Supported output formats: .json / .csv")
            print(f"Saved to {args.out.resolve()}")
        else:
            from pprint import pprint
            pprint(lots[:10])
```