UFC-Statistiken scrapenKämpfer, Rekorde und Ergebnisse

Die Ultimate Fighting Championship veröffentlicht ein umfangreiches Archiv öffentlicher Kampfdaten auf ufcstats.com: jedes abgeschlossene Event, jeden Kampf und eine detaillierte Aufschlüsselung von Schlägen, Takedowns und Ergebnissen pro Kämpfer. Für alle, die ein Vorhersagemodell für Kämpfe, einen Datensatz für Wettforschung oder eine einfache "Wer hat wen besiegt"-Referenz erstellen, ist diese öffentliche Statistikseite eine Fundgrube, und das manuelle Abtippen von Zahlen hört auf zu funktionieren, sobald man sich für mehr als eine Kampfkarte interessiert.

Dieser Leitfaden zeigt den besten Weg, UFC-Statistiken mit Python zu scrapen: Sie rufen die gerenderten Statistikseiten über die Crawling API ab, parsen die Tabellen mit BeautifulSoup und erstellen einen sauberen Datensatz für jeden Kämpfer und Kampf. Die gesamte Anleitung beschränkt sich auf öffentliche Sportstatistiken (Kämpfernamen, Rekorde, Ergebnisse und Kampfmetriken). Sie berührt keine sozialen Medien, keine personenbezogenen Daten oder Inhalte hinter einem Login, und der Abschnitt zur Rechtslage am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf echtes Volumen anwenden.

Was Sie erstellen werden

Ein Python-Skript, das eine öffentliche ufcstats.com-Kämpfer- oder Event-URL nimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz extrahiert. Wir verwenden die öffentliche Detailseite eines Kämpfers als laufendes Beispiel und extrahieren diese Felder:

• Kämpfername der Kämpfer, zu dem die Seite gehört, zum Beispiel "Jon Jones".
• Rekord die Karriere-Gewinn-Verlust-Unentschieden-Zeile, etwa "27-1-0".
• Event und Datum die Kampfkarte, zu der jeder aufgeführte Kampf gehörte, mit ihrem Datum.
• Gegner der andere Kämpfer in jedem Kampf.
• Ergebnis das Resultat aus der Perspektive dieses Kämpfers: Sieg, Niederlage oder Unentschieden.
• Schlüsselstatistiken signifikante Schläge und Takedowns, die für den Kampf aufgezeichnet wurden.

Warum eine einfache Anfrage bei ufcstats.com Probleme bereitet

Manchmal können Sie das statische Markup von ufcstats.com mit einem einfachen HTTP-Client abrufen, aber ein roher Scraper stößt auf öffentlichen Sportseiten auf zwei wiederkehrende Probleme. Erstens basiert das Layout auf Tabellen, deren Zeilen zusammen mit Skripten und Styling laden, sodass ein naiver Abruf eine unvollständige Seite oder eine abgespeckte Hülle liefern kann, der die gesuchten Stat-Spalten fehlen. Zweitens beobachten Websites automatisierten Traffic: Ein Strom von Anfragen von einer einzigen Datacenter-IP, die alle im engen Loop denselben Pfad treffen, wird gedrosselt oder herausgefordert, lange bevor Sie eine Saison von Events abgeschlossen haben.

Ein funktionierender UFC-Stats-Scraper benötigt also zwei Dinge in einer Anfrage: einen Abruf, der die vollständig geformte Seite zurückgibt, und eine IP, die die Website als normalen Besucher liest. Sie können das selbst aufbauen mit einem Headless Browser plus einem Pool von rotierenden Residential-Proxys, aber das Zusammenfügen und Gesundhalten dieser Komponenten ist der Großteil der Arbeit. Die Crawling API bündelt beides in einem einzigen Aufruf: Sie senden ihr die URL, sie ruft die Seite hinter einer vertrauenswürdigen IP ab und gibt fertiges HTML zurück, das Sie parsen können.

Voraussetzungen

Bevor Sie Code schreiben, müssen einige Dinge vorhanden sein. Keines davon dauert lange.

Grundlegendes Python. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn Sie neu beim Parsen von HTML sind, behandelt der Leitfaden zu BeautifulSoup in Python die Selektor-Arbeit, die dieses Tutorial voraussetzt.

Python 3.8 oder höher. Überprüfen Sie Ihre Version mit python --version. Wenn Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und ein Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihren Token von der Account-Seite. Behandeln Sie den Token wie ein Passwort: Er authentifiziert Ihre Anfragen, also halten Sie ihn aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit die Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv ufc_env
source ufc_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit ufc_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie einzelne Felder per CSS-Selektor extrahieren können.

Schritt 1: Die gerenderte Statistikseite abrufen

Beginnen Sie damit, die fertige Seite abzurufen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem Token und fordern Sie die Kämpfer-URL an. Das Überprüfen des Status-Codes vor dem Parsen macht Fehler laut statt still.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "http://www.ufcstats.com/statistics/events/completed"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Dies spiegelt den minimalen Ausschnitt aus der ursprünglichen Anleitung wider, modernisiert auf den offiziellen Client: Anstatt die Anfrage-URL manuell zu erstellen und das Ziel selbst URL-zu kodieren, übergeben Sie die Seiten-URL an api.get und überlassen dem Client die Kodierung und den Token. Führen Sie das Skript mit python scraper.py aus und Sie sollten echtes Stats-Markup sehen, die Tabelle der abgeschlossenen Events, keine leere Hülle. Das bestätigt, dass der Abruf funktioniert, bevor Sie einen einzigen Selektor schreiben. Ersetzen Sie die Beispiel-URL durch eine Kämpfer-Details-URL wie http://www.ufcstats.com/fighter-details/<id>, um die Seite eines bestimmten Kämpfers anzusteuern.

Schritt 2: Die Kämpferfelder mit BeautifulSoup parsen

Mit dem vorliegenden HTML laden Sie es in BeautifulSoup und extrahieren jedes Feld. Eine ufcstats.com-Kämpferseite legt den Namen und den Karriererekord nahe der Spitze ab und listet dann jeden Kampf in einer Ergebnistabelle, in der jede Zeile den Gegner, das Event, das Datum, das Ergebnis und die Kampfmetriken enthält. Hüllen Sie die Extraktion in kleine Helfer, damit ein einzelnes fehlendes Feld den Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

def text_of(node):
    return node.get_text(strip=True) if node else None

def scrape_fighter(html):
    soup = BeautifulSoup(html, "html.parser")

    name = text_of(soup.select_one(".b-content__title-record"))
    record = text_of(soup.select_one(".b-content__title-record"))

    bouts = []
    rows = soup.select("tr.b-fight-details__table-row")
    for row in rows:
        cells = row.select("td.b-fight-details__table-col")
        if len(cells) < 10:
            continue
        fighters = [text_of(p) for p in cells[1].select("p")]
        opponent = fighters[1] if len(fighters) > 1 else None
        strikes = [text_of(p) for p in cells[4].select("p")]
        takedowns = [text_of(p) for p in cells[5].select("p")]
        event = [text_of(p) for p in cells[6].select("p")]

        bouts.append({
            "result": text_of(cells[0]),
            "opponent": opponent,
            "sig_strikes": strikes[0] if strikes else None,
            "takedowns": takedowns[0] if takedowns else None,
            "event": event[0] if event else None,
            "date": event[1] if len(event) > 1 else None,
        })

    return {"name": name, "record": record, "bouts": bouts}

Der Helfer text_of tut eine nützliche Sache: Er gibt den getrimmten Text eines Knotens zurück, oder None, wenn der Knoten fehlt, sodass ein .get_text()-Aufruf nie gegen nichts wirft. Die Kämpferseite packt den Namen und den Gewinn-Verlust-Unentschieden-Rekord in denselben Titel-Block, weshalb beide Felder aus .b-content__title-record lesen und Sie den Namen nachgelagert vom Rekord-String trennen. Jede Ergebniszeile liegt in einem tr.b-fight-details__table-row, und seine Zellen folgen einer stabilen Reihenfolge: Ergebnis, die zwei Kämpfer, Knockdowns, signifikante Schläge, Takedowns, dann Event und Datum. Das Indizieren der Zellen nach Position hält den Parser lesbar, während er Ergebnis, Gegner, Schlüsselstatistiken und Event für jeden Kampf extrahiert. Wenn Sie eine Auffrischung zur Auswahl robuster Selektoren möchten, ist der Leitfaden zu XPath- und CSS-Selektoren ein guter Begleiter.

Schritt 3: Alles zusammensetzen

Verbinden Sie jetzt Abruf und Parse zu einem lauffähigen Skript. Rufen Sie das HTML ab, übergeben Sie es an den Parser und geben Sie den strukturierten Datensatz aus.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(node):
    return node.get_text(strip=True) if node else None

def scrape_fighter(html):
    soup = BeautifulSoup(html, "html.parser")
    name = text_of(soup.select_one(".b-content__title-record"))
    record = text_of(soup.select_one(".b-content__title-record"))

    bouts = []
    for row in soup.select("tr.b-fight-details__table-row"):
        cells = row.select("td.b-fight-details__table-col")
        if len(cells) < 10:
            continue
        fighters = [text_of(p) for p in cells[1].select("p")]
        strikes = [text_of(p) for p in cells[4].select("p")]
        takedowns = [text_of(p) for p in cells[5].select("p")]
        event = [text_of(p) for p in cells[6].select("p")]
        bouts.append({
            "result": text_of(cells[0]),
            "opponent": fighters[1] if len(fighters) > 1 else None,
            "sig_strikes": strikes[0] if strikes else None,
            "takedowns": takedowns[0] if takedowns else None,
            "event": event[0] if event else None,
            "date": event[1] if len(event) > 1 else None,
        })

    return {"name": name, "record": record, "bouts": bouts}

def main():
    page_url = "http://www.ufcstats.com/fighter-details/f4c49976c75c5ab2"
    html = crawl(page_url)
    if not html:
        return
    data = scrape_fighter(html)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus und Sie erhalten einen sauberen strukturierten Datensatz für den Kämpfer, der in JSON, CSV oder eine Datenbank geschrieben werden kann. Die genauen Zahlen hängen vom Kämpfer und dem Kampf ab; die Form bleibt gleich.

{
  "name": "Jon Jones",
  "record": "Record: 27-1-0",
  "bouts": [
    {
      "result": "win",
      "opponent": "Ciryl Gane",
      "sig_strikes": "9",
      "takedowns": "1",
      "event": "UFC 285: Jones vs. Gane",
      "date": "Mar. 04, 2023"
    }
  ]
}

Auf viele Kämpfer und Events skalieren

Eine Kämpferseite ist eine Demo; ein echter Datensatz läuft über viele davon. Die Form bleibt gleich: Halten Sie eine Liste von Kämpfer-URLs, rufen Sie jede über die Crawling API ab, parsen Sie sie mit derselben Funktion und sammeln Sie die Zeilen. Da jede Kämpferseite dieselbe Tabellenstruktur teilt, funktioniert der Parser, den Sie bereits geschrieben haben, über alle ohne Änderungen. Ein häufiges Muster ist, vom Index der abgeschlossenen Events zu beginnen, zu den Kampflisten jedes Events zu navigieren und von dort den Kämpfer-Links zu folgen, dann alles am Ende zu exportieren.

import time

fighters = [
    "http://www.ufcstats.com/fighter-details/f4c49976c75c5ab2",
    "http://www.ufcstats.com/fighter-details/07f72a2a7591b409",
]

results = []
for url in fighters:
    html = crawl(url)
    if html:
        results.append(scrape_fighter(html))
    time.sleep(2)

with open("ufc_stats.json", "w") as f:
    json.dump(results, f, indent=2)

Der time.sleep-Aufruf zwischen Anfragen ist absichtlich. Obwohl die Crawling API IPs für Sie rotiert, hält das Drosseln den Lauf höflich und vorhersehbar und gibt jeder Seite Zeit, zurückzukommen, ohne Anfragen übereinander zu stapeln. Um die Pro-Kämpfer-Datensätze in eine flache Tabelle zu verwandeln, durchlaufen Sie die bouts-Liste und schreiben Sie eine CSV-Zeile pro Kampf mit dem Kämpfernamen angehängt; dasselbe Fetch-then-parse-Muster erweitert sich auf Event-Seiten, wenn Sie lieber nach Kampfkarte als nach Kämpfer indexieren möchten.

Nicht blockiert werden

Selbst auf einer öffentlichen Statistik-Website kann ein Strom automatisierter Anfragen gedrosselt werden. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jede Website, die Sie im großen Maßstab scrapen.

• Anfragen drosseln. Seiten in einer engen Schleife zu bombardieren ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Ziele, anstatt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool von Residential-IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt dies für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist dies der Teil, den Sie richtig machen müssen.
• Status-Codes lesen. Ein Lauf, der beginnt, Herausforderungen oder Fehler zurückzugeben, signalisiert Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen zum Ignorieren.

Für das breitere Playbook sehen Sie den Tiefeneinstieg zum Scrapen ohne blockiert zu werden und den allgemeinen Leitfaden zum Scrapen einer Website mit Python. Wenn Sie Ihren eigenen Traffic lieber über einen rotierenden Pool leiten möchten, anstatt die verwaltete API zu nutzen, gibt Ihnen der Smart AI Proxy (auch als AI Proxy bezeichnet) dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, UFC-Statistiken zu scrapen?

Ob das Scrapen von UFC-Statistiken erlaubt ist, hängt von den Nutzungsbedingungen der Statistikseite, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten tun. Das Scrapen öffentlicher Informationen, die jeder ohne Account einsehen kann, ist in der Regel auf sichererem Grund als das Sammeln geschützter oder personenbezogener Daten, aber "öffentlich" ist kein Freifahrtschein. Lesen Sie die Nutzungsbedingungen und die robots.txt jeder Website, die Sie damit ansteuern, einschließlich ufcstats.com, und behandeln Sie beides als Grenze für das, was Sie erfassen und wie schnell. Nichts am Code hier ändert diese Bedingungen; er lässt nur den technischen Teil funktionieren.

Halten Sie die Arbeit eng begrenzt. Dieser Leitfaden ist bewusst auf öffentliche Kampf- und Kämpferstatistiken beschränkt: Namen, Gewinn-Verlust-Unentschieden-Rekorde, Events und Daten, Ergebnisse und Kampfmetriken wie signifikante Schläge und Takedowns. Er deckt keine Social-Media-Daten, keine personenbezogenen Daten über Kämpfer oder Fans, keine login-geschützten Inhalte oder Versuche zur Umgehung der Authentifizierung ab, und er verteilt keine urheberrechtlich geschützten Medien wie Event-Footage oder Fotos. Diese sind hier absichtlich außerhalb des Rahmens, weil die öffentlichen Statistiken die Arbeit vertretbar machen. Wenn Sie versucht sind, das Netz auf Social-Media-Beiträge oder persönliche Profile auszuweiten, ist das genau dort, wo dieses Tutorial aufhört.

Für kommerzielle Zwecke bevorzugen Sie eine offizielle oder lizenzierte Quelle. Die UFC und ihre Datenpartner lizenzieren Kampfstatistiken über offizielle Feeds, und breitere Sportdatenanbieter bieten kostenpflichtige APIs mit klaren Nutzungsrechten und einem stabilen Schema, das Sie nicht jedes Mal neu entdecken müssen, wenn eine Seite neu gestaltet wird. Das Scrapen der öffentlichen Statistikseite ist das richtige Werkzeug für Forschung, ein persönliches Projekt oder einen einmaligen Datensatz, bei dem kein lizenzierter Feed Ihren Bedarf deckt; wenn Sie ein Produkt auf dieser Grundlage aufbauen, ist eine lizenzierte Sportdaten-API der sauberere und sicherere Weg.

Häufig gestellte Fragen

Was ist der beste Weg, UFC-Statistiken mit Python zu scrapen?

Rufen Sie die öffentliche Statistikseite über die Crawling API ab, damit Sie das vollständige HTML hinter einer vertrauenswürdigen, rotierenden IP erhalten, und parsen Sie es dann mit BeautifulSoup. Diese Kombination behandelt die zwei schwierigen Teile: einen Abruf, der die vollständige Seite zurückgibt, und eine IP, die die Website als normalen Besucher liest, während Sie sich auf die Auswahl der gewünschten Felder aus den Tabellen konzentrieren.

Welche UFC-Statistiken kann ich extrahieren?

Von einer öffentlichen Kämpfer- oder Event-Seite können Sie den Kämpfernamen, den Gewinn-Verlust-Unentschieden-Rekord, den Gegner jedes Kampfes, das Event und Datum, das Ergebnis und Kampfmetriken wie signifikante Schläge und Takedowns extrahieren. Dieser Leitfaden beschränkt sich nur auf öffentliche Sportstatistiken; er deckt keine sozialen Medien, personenbezogenen Daten oder Inhalte hinter einem Login ab.

Benötige ich den normalen Token oder den JS-Token für ufcstats.com?

Beginnen Sie mit dem normalen Token. Viele ufcstats.com-Seiten geben ihre Tabellen im statischen HTML zurück, sodass der normale Token in der Regel ausreicht. Wenn eine Stat-Spalte leer zurückkommt, wechseln Sie zum JavaScript (JS)-Token, der die Seite in einem echten Browser rendert, bevor er das HTML zurückgibt, und der spät ladende Inhalt wird dann beim Parsen vorhanden sein.

Meine Selektoren geben None zurück. Was hat sich geändert?

Mit ziemlicher Sicherheit das Markup der Website. Klassennamen wie b-content__title-record und die b-fight-details__table-Zeilen ändern sich, wenn eine Seite neu gestaltet wird, sodass Selektoren, die letzten Monat funktionierten, jetzt brechen können. Inspizieren Sie eine Live-Seite in den Dev Tools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Bietet die UFC eine offizielle Stats API?

Die UFC und ihre Datenpartner lizenzieren Kampfstatistiken über offizielle Feeds, und breitere Sportdatenanbieter verkaufen kostenpflichtige APIs mit klaren Nutzungsrechten und einem stabilen Schema. Für kommerzielle Zwecke bevorzugen Sie eine dieser lizenzierten Quellen. Das Scrapen der öffentlichen Statistikseite ist am besten für Forschung, ein persönliches Projekt oder einen einmaligen Datensatz geeignet, bei dem kein lizenzierter Feed Ihren Bedarf deckt.

Wie vermeide ich Blockierungen beim Scrapen von UFC-Statistiken?

Halten Sie Ihre Anfragerate pro IP niedrig, variieren Sie Ihre Ziele anstatt einen Pfad zu durchlaufen, und leiten Sie durch rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Status-Codes und rudern Sie zurück, wenn Sie anfangen, Herausforderungen zu sehen.

BA

Bilal Ahmed

Softwareentwickler · Crawlbase

Softwareentwickler, der einige der meistgelesenen Beiträge im Crawlbase-Blog verfasst hat, über Web Scraping, Proxys und Daten-Tooling.