Krypto-Preise von CoinMarketCap scrapenLive-Marktdaten mit Python

CoinMarketCap ist die Standardreferenz für Krypto-Marktdaten: Es verfolgt Live-Preise, Marktkapitalisierung, Handelsvolumen und Rankings für Tausende von Coins und aktualisiert diese Zahlen nahezu in Echtzeit. Diese öffentliche Tabelle ist genau das, was Preis-Dashboards, Portfolio-Tracker und Marktforschung antreibt, weshalb so viele Menschen eine saubere strukturierte Kopie davon möchten.

Dieser Leitfaden zeigt Ihnen, wie Sie Krypto-Preise von CoinMarketCap mit Python scrapen. Sie bauen einen kleinen, lauffähigen Scraper, der die gerenderte Listingseite über die Crawling API abruft, die gewünschten Felder mit BeautifulSoup parst und einen sauberen Datensatz pro Coin schreibt. Die gesamte Anleitung beschränkt sich auf öffentliche Marktdaten: Coin-Name, Symbol, Preis, Marktkapitalisierung, 24h-Veränderung und Volumen. Der Abschnitt zur Rechtslage am Ende ist kein Standardtext, und CoinMarketCap bietet eine offizielle API an, lesen Sie daher beides, bevor Sie diesen Code in großem Umfang einsetzen.

Was Sie bauen werden

Ein Python-Skript, das die öffentliche CoinMarketCap-Startseite abruft, das gerenderte HTML über die Crawling API holt und einen strukturierten Datensatz für die Top-Coins der Tabelle extrahiert. Für jeden Coin werden diese Felder gezogen:

• Name der vollständige Name des Coins, wie „Bitcoin".
• Symbol das Ticker-Symbol, wie „BTC".
• Price der aktuelle Preis in USD.
• Market cap die gesamte Marktkapitalisierung, wie in der Zeile angezeigt.
• 24h change die prozentuale Bewegung in den letzten 24 Stunden.
• Volume das 24-Stunden-Handelsvolumen.

Warum eine einfache Anfrage bei CoinMarketCap scheitert

Wenn Sie CoinMarketCap mit einem einfachen HTTP-Client anfordern, erhalten Sie selten die saubere Preistabelle, die Sie im Browser sehen. Zwei Dinge arbeiten gegen Sie. Erstens rendert CoinMarketCap einen Großteil seiner Markttabelle clientseitig: Das initiale HTML ist eine dünne Hülle, und die Zeilen füllen sich erst, nachdem das JavaScript der Seite ausgeführt wurde. Zweitens sitzt die Website hinter Bot-Schutz wie Cloudflare, sodass Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, herausgefordert oder gedrosselt werden, bevor sie jemals die gerenderte Tabelle erreichen.

Ein einfaches requests.get() gibt also tendenziell entweder eine leere Hülle oder eine Challenge-Seite statt Coin-Daten zurück. Ein funktionierender CoinMarketCap-Scraper benötigt zwei Dinge zusammen: einen Browser, der die Seite rendert, und eine IP, die die Website als normalen Besucher erkennt.

Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Wohnproxys zusammenstellen, aber diese zusammenzufügen und funktionsfähig zu halten, ist der Großteil der Arbeit. Die Crawling API fasst die schwierigen Teile in einem einzigen Aufruf zusammen: Sie übergeben ihr die CoinMarketCap-URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück. Wenn Sie Ihre eigenen Anfragen lieber über einen rotierenden Pool leiten möchten, bietet der Smart AI Proxy dieselbe Wohn-IP-Rotation als Drop-in-Proxy-Endpunkt.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge vorhanden sein. Keines davon nimmt viel Zeit in Anspruch.

Python-Grundkenntnisse. 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 unser Leitfaden wie man BeautifulSoup in Python verwendet die Selektor-Grundlagen, 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 JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihren JavaScript (JS)-Token von der Kontodokumentationsseite. Behandeln Sie den Token wie ein Passwort: Er authentifiziert Ihre Anfragen, halten Sie ihn daher aus der Versionskontrolle heraus.

Projekt einrichten

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

python --version

python -m venv cmc_env
source cmc_env/bin/activate

pip install crawlbase beautifulsoup4

Aktivieren Sie die Umgebung unter Windows mit cmc_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, sodass Sie einzelne Felder per CSS-Selektor extrahieren können.

Schritt 1: Die gerenderte Seite abrufen

Beginnen Sie damit, die fertige Seite abzurufen. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die CoinMarketCap-URL an. Das Prüfen des Statuscodes vor dem Parsen hält Fehler laut statt still.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://coinmarketcap.com/"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Wait-Optionen sind für ein clientseitig gerendertes Ziel wie dieses wichtig: ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, sodass die spät gerenderten Tabellenzeilen erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn die Tabelle leer zurückkommt. CoinMarketCap sendet Seiten in verschiedenen Encodings, sodass das Dekodieren mit latin1 die Byte-Fehler vermeidet, die ein striktes UTF-8-Dekodieren auslösen kann. Führen Sie das Skript aus und Sie sollten echtes Markt-Markup sehen, nicht die dünne Hülle, die ein einfacher Abruf zurückgibt.

Schritt 2: Coin-Felder mit BeautifulSoup parsen

Mit gerendetrem HTML laden Sie es in BeautifulSoup und durchlaufen die Tabellenzeilen. CoinMarketCap legt jeden Coin als Zeile in der Hauptmarkttabelle an, mit Name und Symbol in der Coin-Zelle und den numerischen Feldern in den Spalten rechts davon. Verpacken Sie die Extraktion jeder Zeile in ein try/except, sodass ein fehlender Wert den gesamten Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

def text_of(row, selector):
    el = row.select_one(selector)
    return el.get_text(strip=True) if el else None

def scrape_coins(html, limit=10):
    soup = BeautifulSoup(html, "html.parser")
    rows = soup.select("table tbody tr")[:limit]

    coins = []
    for row in rows:
        try:
            cells = row.select("td")
            coins.append({
                "name": text_of(row, "p.coin-item-name"),
                "symbol": text_of(row, "p.coin-item-symbol"),
                "price": cells[3].get_text(strip=True),
                "change_24h": cells[4].get_text(strip=True),
                "market_cap": cells[7].get_text(strip=True),
                "volume_24h": cells[8].get_text(strip=True),
            })
        except (IndexError, AttributeError) as e:
            print("Skipping a row due to error:", e)
    return coins

Name und Symbol haben stabile, menschenlesbare Klassen-Hooks, p.coin-item-name und p.coin-item-symbol, sodass Sie diese direkt ansprechen. Die numerischen Spalten (Preis, 24h-Veränderung, Marktkapitalisierung und Volumen) werden positional aus den td-Zellen der Zeile gezogen, weil CoinMarketCap's Preiszelle einen gehashten, häufig wechselnden Klassennamen trägt, der nicht sicher hardcodiert werden kann. Der text_of-Helfer gibt None zurück, anstatt zu werfen, wenn ein Element fehlt, und das try/except schützt vor einer Zeile, deren Spaltenlayout abweicht, sodass eine einzelne ungewöhnliche Zeile den Lauf nie beendet.

Schritt 3: Alles zusammenführen

Verknüpfen Sie jetzt Abruf und Parsing in einem lauffähigen Skript. Rufen Sie das gerenderte HTML ab, übergeben Sie es an den Parser und geben Sie die strukturierten Datensätze als JSON aus.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(row, selector):
    el = row.select_one(selector)
    return el.get_text(strip=True) if el else None

def scrape_coins(html, limit=10):
    soup = BeautifulSoup(html, "html.parser")
    rows = soup.select("table tbody tr")[:limit]

    coins = []
    for row in rows:
        try:
            cells = row.select("td")
            coins.append({
                "name": text_of(row, "p.coin-item-name"),
                "symbol": text_of(row, "p.coin-item-symbol"),
                "price": cells[3].get_text(strip=True),
                "change_24h": cells[4].get_text(strip=True),
                "market_cap": cells[7].get_text(strip=True),
                "volume_24h": cells[8].get_text(strip=True),
            })
        except (IndexError, AttributeError) as e:
            print("Skipping a row due to error:", e)
    return coins

def main():
    html = crawl("https://coinmarketcap.com/")
    if not html:
        return
    data = scrape_coins(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 eine saubere Liste strukturierter Datensätze, bereit zum Schreiben in JSON, CSV oder eine Datenbank. Die genauen Preise unterscheiden sich von der folgenden Beispielausgabe, da sich der Markt ständig bewegt.

[
  {
    "name": "Bitcoin",
    "symbol": "BTC",
    "price": "$92,477.64",
    "change_24h": "2.14%",
    "market_cap": "$1.83T",
    "volume_24h": "$38.20B"
  },
  {
    "name": "Ethereum",
    "symbol": "ETH",
    "price": "$1,744.77",
    "change_24h": "1.06%",
    "market_cap": "$210.6B",
    "volume_24h": "$14.95B"
  }
]

Export als CSV und JSON

Ein JSON-Dump in die Konsole ist für einen Demo in Ordnung, aber normalerweise möchten Sie die Daten auf der Festplatte, um sie später zu speichern oder zu analysieren. Die Datensätze sind bereits eine Liste flacher Dictionaries, sodass das Schreiben beider Formate nur wenige Zeilen erfordert. Verwenden Sie die crawl- und scrape_coins-Funktionen aus dem vollständigen Skript oben wieder.

import csv
import json

html = crawl("https://coinmarketcap.com/")
coins = scrape_coins(html)
fields = ["name", "symbol", "price", "change_24h", "market_cap", "volume_24h"]

with open("crypto_prices.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerows(coins)

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

print(f"Saved {len(coins)} coins to crypto_prices.csv and crypto_prices.json")

Von hier aus lässt sich eine CSV direkt in eine Tabellenkalkulation oder einen pandas DataFrame zur Analyse laden, und die JSON-Datei ist einfach in einen nachgelagerten Dienst zu laden. Wenn Sie einen Live-Feed statt eines einmaligen Snapshots möchten, planen Sie die Ausführung des Skripts in einem Intervall und hängen Sie jeden Abruf an eine datierte Datei an.

Auf mehr Coins und Seiten skalieren

Die Startseite listet die Top-Coins, aber CoinMarketCap paginiert das vollständige Ranking. Die Struktur der Arbeit ändert sich nicht: Die Listingstruktur ist auf jeder Seite dieselbe, sodass der bereits geschriebene Parser weiter funktioniert. Durchlaufen Sie die nummerierten Seiten, rufen Sie jede über die Crawling API ab und sammeln Sie die Zeilen.

all_coins = []

for page in range(1, 4):  # first three pages of the ranking
    url = f"https://coinmarketcap.com/?page={page}"
    html = crawl(url)
    if html:
        all_coins.extend(scrape_coins(html, limit=100))

print(f"Collected {len(all_coins)} coins across pages")

Wenn Sie diesen Prozess unbeaufsichtigt in großem Umfang ausführen müssen, stellen Sie die Seiten-URLs über den asynchronen Crawler in eine Warteschlange, anstatt synchron zu schleifen, sodass Sie den gesamten Seitensatz einreichen und die Ergebnisse abrufen, wenn sie fertig sind. Für mehr zu Rendering-intensiven Zielen geht unsere Anleitung wie man JavaScript-Seiten mit Python scrapt tiefer in das Wait-and-Render-Muster ein, auf das dieser Scraper angewiesen ist.

Nicht blockiert werden

Selbst wenn das Rendering gehandhabt wird, achtet CoinMarketCap auf Scraper-artigen Datenverkehr. Einige Gewohnheiten halten einen Lauf gesund und gelten für jedes geschützte, JavaScript-intensive Ziel.

• Anfragen dosieren. Jede Seite in einer engen Schleife abzurufen ist der schnellste Weg zu Drosselung. Verteilen Sie Anfragen, und für einen Live-Feed sind alle paar Minuten ausreichend, anstatt in einem engen Takt zu hämmern.
• Rotation nutzen. Ein Pool von Wohn-IPs verteilt Anfragen über viele echte Nutzerkennzeichnungen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API erledigt das für Sie; wenn Sie einen eigenen Stack aufbauen, ist das der Teil, auf den es ankommt.
• Statuscodes beachten. Ein Lauf, der beginnt, Challenges oder Fehler zurückzuliefern, signalisiert Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen, das Sie ignorieren können.

Für das umfassendere Vorgehen lesen Sie wie Sie Websites scrapen, ohne gesperrt zu werden und die vertiefte Behandlung wie Sie CAPTCHAs beim Web Scraping umgehen.

Ist es legal, CoinMarketCap zu scrapen?

Ob das Scrapen von CoinMarketCap erlaubt ist, hängt von den Nutzungsbedingungen der Website, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten tun. CoinMarketCap veröffentlicht Nutzungsbedingungen und eine robots.txt, und beide setzen die Grenze für automatisierten Zugriff. Keiner der hier verwendeten Code ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie diese Dokumente und behandeln Sie sie als Limit für das, was Sie sammeln und wie oft Sie es anfordern, insbesondere vor jedem kommerziellen Projekt.

Halten Sie Ihren Umfang eng. Die hier behandelte Markttabelle sind echte öffentliche Daten: Coin-Name, Symbol, Preis, Marktkapitalisierung, 24h-Veränderung und Volumen, alle ohne Konto sichtbar. Das ist die Linie, die die Arbeit verteidigbar macht. Was dieser Leitfaden nicht abdeckt, ist ebenso wichtig: alles hinter einem Login, Konto- oder Watchlist-Daten, die einem Nutzer zugeordnet sind, personenbezogene Daten und urheberrechtlich geschützte Medien, die Sie weiterverbreiten würden, liegen alle außerhalb des Rahmens. Umgehen Sie keine Authentifizierung, um Daten zu erreichen, die die öffentliche Tabelle nicht bereits zeigt.

Noch etwas Spezifisches zu diesem Ziel: CoinMarketCap bietet eine offizielle API an. Für Produktionssysteme, kommerzielle Nutzung oder Hochvolumen-Abrufe ist diese offizielle API der richtige Weg, denn sie gibt Ihnen einen unterstützten Vertrag, vorhersehbare Ratenlimits und Daten, die Sie klar lizenziert haben zu nutzen. Das Scrapen der öffentlichen Website passt zum Lernen, Prototyping und kleinen öffentlichen Datenjobs, nicht zu einem Unternehmen, das garantierte Betriebszeit und klare Nutzungsrechte benötigt. Im Zweifelsfall bevorzugen Sie die offizielle API.

Häufig gestellte Fragen

Warum liefert eine einfache Anfrage keine Krypto-Preise von CoinMarketCap?

Zwei Gründe. Erstens rendert CoinMarketCap einen Großteil seiner Markttabelle clientseitig mit JavaScript, sodass das rohe HTML eine dünne Hülle ist, die sich erst füllt, nachdem die Seitenskripte ausgeführt wurden. Zweitens sitzt die Website hinter Bot-Schutz wie Cloudflare, sodass automatisierter Datenverkehr von Datacenter-IPs oft herausgefordert oder gedrosselt wird, bevor er die Daten erreicht. Das Rendern der Seite mit dem JS-Token der Crawling API hinter einer vertrauenswürdigen IP ist das, was die Zeilen zum Erscheinen bringt.

Benötige ich den normalen Token oder den JS-Token für CoinMarketCap?

Den JS-Token. Der normale Token ruft statisches HTML ab, das bei CoinMarketCap tendenziell dieselbe dünne Hülle ist, die ein einfacher Abruf zurückgibt. Der JS-Token rendert die Seite in einem echten Browser, bevor er das HTML zurückgibt, sodass die Tabellenzeilen, einschließlich Preis, Marktkapitalisierung und Volumen, vorhanden sind, wenn BeautifulSoup sie parst.

Wie oft kann ich Krypto-Preise scrapen?

Für einen Live-Feed ist ein Abruf alle paar Minuten in der Regel sicher und hält Sie deutlich unter jedem Ratenlimit. Die Website in einer engen Schleife zu hämmern ist der schnellste Weg zu Drosselung oder Challenges. Leiten Sie durch rotierende Wohn-IPs, beobachten Sie Ihre Statuscodes und rudern Sie zurück, wenn Sie beginnen, Challenges zu sehen. Für garantierten Durchsatz ist die offizielle CoinMarketCap API die bessere Wahl.

Meine Selektoren liefern falsche Werte. Was hat sich geändert?

Fast sicher CoinMarketCap's Markup. Seine gehashten CSS-Klassennamen ändern sich häufig und die Spaltenreihenfolge kann sich verschieben, sodass Selektoren und positionale Indizes, die letzten Monat funktionierten, kaputtgehen können. Verankern Sie auf den stabilen p.coin-item-name- und p.coin-item-symbol-Hooks, wenn möglich, überprüfen Sie eine Live-Seite in den Entwicklertools Ihres Browsers, wenn ein Feld falsch aussieht, und aktualisieren Sie den Selektor oder den Zellenindex. Regelmäßige Selektor-Wartung ist für jeden produktiven Scraper normal.

Sollte ich CoinMarketCap scrapen oder die offizielle API verwenden?

Für das Lernen, Prototyping und kleine öffentliche Datenjobs ist das Scrapen der öffentlichen Tabelle eine gute Möglichkeit, Name, Symbol, Preis, Marktkapitalisierung, 24h-Veränderung und Volumen zu erhalten. Für Produktionssysteme, kommerzielle Nutzung oder Hochvolumen-Abrufe nutzen Sie CoinMarketCap's offizielle API: Sie gibt Ihnen einen unterstützten Vertrag, vorhersehbare Ratenlimits und klare Nutzungsrechte. Wählen Sie das Werkzeug, das dem Einsatz Ihres Projekts entspricht.

Welche Krypto-Daten kann ich legal sammeln?

Bleiben Sie bei öffentlichen Marktdaten, die ohne Konto angezeigt werden: Coin-Name, Symbol, Preis, Marktkapitalisierung, 24h-Veränderung und Volumen. Sammeln Sie keine Konto-, Watchlist- oder personenbezogenen Daten, berühren Sie nichts hinter einem Login und umgehen Sie niemals Authentifizierung. Respektieren Sie CoinMarketCap's Nutzungsbedingungen und robots.txt, und verlassen Sie sich bei kommerzieller oder Massennutzung auf die offizielle API statt einen Scraper gegen die öffentliche Website zu skalieren.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.