metadata
license: mit
FalconNet/FunPay-Minecraft-Lots-Mini-6k
- Prices are in Rubles
Script used to create this:
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])