Daten von CoinGecko extrahierenKrypto-Preise und Marktkapitalisierungen

CoinGecko erfasst Tausende von Kryptowährungen an einem Ort, und seine Marktseiten enthalten genau die strukturierten Daten, die Preis-Tracking, Portfolio-Tools und Recherchen antreiben: Name und Symbol der Münze, aktueller Preis, Marktkapitalisierung, 24-Stunden-Handelsvolumen, die Preisänderung über 24 Stunden und 7 Tage sowie den Marktkapitalisierungsrang. Wer einen Korb aus Münzen beobachtet, benötigt diese öffentlichen Marktdaten als Rohmaterial, und das manuelle Kopieren über Hunderte von Zeilen ist langsam und bereits veraltet, wenn man fertig ist.

Diese Anleitung zeigt, wie man mit Python Kryptowährungsdaten von CoinGecko extrahiert. CoinGecko veröffentlicht eine offizielle öffentliche API, und für jede produktive Anwendung sollte man zuerst zu dieser greifen. Die hier beschriebene HTML-Methode ist ein Lernfallback für Felder oder Seiten, die der kostenlose API-Tarif nicht abdeckt. Sie beschränkt sich ausschließlich auf öffentliche Marktdaten, die sachlich und nicht personenbezogen sind. Am Ende befindet sich ein Abschnitt zur Rechtslage; lesen Sie diesen, bevor Sie das Verfahren auf echte Volumina anwenden.

Was Sie bauen werden

Ein Python-Skript, das eine gerenderte CoinGecko-Marktseite über die Crawling API abruft, jede Münzzeile mit BeautifulSoup parst und einen strukturierten Datensatz pro Münze erzeugt. Als laufendes Beispiel dienen die Top-Münzen der CoinGecko-Hauptliste. Folgende Felder werden extrahiert:

• Name der vollständige Name der Münze, z. B. Bitcoin oder Ethereum.
• Symbol das kurze Ticker-Kürzel, z. B. BTC oder ETH.
• Preis der aktuelle Preis in der gewählten Fiatwährung.
• Marktkapitalisierung die gesamte Marktkapitalisierung der Münze.
• Volumen das Handelsvolumen der letzten 24 Stunden.
• Änderung 24h die prozentuale Preisänderung der letzten 24 Stunden.
• Änderung 7d die prozentuale Preisänderung der letzten 7 Tage.
• Rang der in der Zeile angezeigte Marktkapitalisierungsrang.

Warum eine einfache Anfrage auf CoinGecko scheitert

Wenn Sie eine CoinGecko-Marktseite mit einem einfachen HTTP-Client anfragen, erhalten Sie häufig eine Antwort mit Status 200, aber nur einen Bruchteil der Tabelle im Body. Zwei Faktoren spielen dagegen. Erstens hydratisiert CoinGecko einen Großteil seiner Markttabelle clientseitig über JavaScript: Preise und prozentuale Änderungen aktualisieren sich live, und Teile der Zeile werden erst nach Ausführung der Seitenskripte befüllt. Parst man die erste Antwort, erhält man eine dünne oder unvollständige Tabelle statt des vollen Zeilensatzes. Zweitens beobachtet CoinGecko wie jede stark frequentierte Website automatisierten Datenverkehr, und Datacenter-IPs, die es im engen Takt treffen, werden gedrosselt oder herausgefordert, bevor sie den gerenderten Inhalt erreichen.

Ein funktionierender Scraper benötigt daher zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP-Adresse, die die Site wie einen echten Besucher liest. Man kann das selbst mit einem Headless-Browser und einem Pool rotierender Residential-Proxies zusammenstellen, aber das Zusammenhalten dieses Stacks ist der größte Aufwand. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden die URL mit einem JavaScript-Token, die API rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

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

Grundlegende Python-Kenntnisse. Sie sollten mit dem Schreiben und Ausführen eines Python-Skripts sowie dem Installieren von Paketen mit pip vertraut sein. Wer neu in der Parsing-Seite ist, findet im BeautifulSoup-Leitfaden einen guten Begleiter zu diesem Tutorial.

Python 3.8 oder neuer. Prüfen Sie Ihre Version mit python --version. Falls nicht vorhanden, installieren Sie Python von python.org oder über eine Distribution wie Anaconda, und stellen Sie sicher, dass Python im PATH liegt.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token (JS-Token) von der Konto-Dokumentationsseite. Crawlbase enthält 1.000 kostenlose Anfragen zum Einstieg, was für diese Anleitung mehr als ausreicht. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, daher sollte es nicht in die Versionskontrolle gelangen.

Projekt einrichten

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

python --version

python -m venv coingecko_env
source coingecko_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit coingecko_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 einzelne Felder per CSS-Selektor herausgezogen werden können. Sowohl json als auch csv sind Teil der Standardbibliothek, es muss also nichts weiter für den Exportschritt installiert werden.

Schritt 1: Eine gerenderte CoinGecko-Seite abrufen

Beginnen Sie damit, eine fertig gerenderte Seite zu holen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die CoinGecko-Coins-URL an. Da CoinGecko Teile seiner Tabelle clientseitig aktualisiert, übergeben Sie ajax_wait und page_wait, damit dynamische Inhalte vor der Erfassung der Seite geladen sind. Das Prüfen des Crawlbase-pc_status vor dem Parsen lässt Fehler laut statt still werden.

from crawlbase import CrawlingAPI

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

OPTIONS = {
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/122.0",
    "ajax_wait": "true",
    "page_wait": 5000,
}

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

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

Die beiden Warteoptionen sind bei einem teilweise clientseitig gerenderten Ziel wichtig. ajax_wait weist die API an, auf das Laden asynchroner Inhalte zu warten, und page_wait hält nach dem Laden für eine feste Anzahl von Millisekunden inne, damit spät gerenderte Zellen erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn Zeilen unvollständig zurückkommen. Führen Sie das Skript mit python coingecko_scraper.py aus und Sie sollten echtes CoinGecko-Markt-Markup sehen, keinen Stub. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Münzzeilen parsen

Die CoinGecko-Coins-Seite ist eine Tabelle, in der jede Zeile eine Münze darstellt. Laden Sie das gerenderte HTML in BeautifulSoup und selektieren Sie die Tabellenzeilen, dann lesen Sie jede Zelle über ihr Daten-Attribut. CoinGecko versieht seine Marktzellen mit data-coin-table-target-Werten, was sie stabil nach Feld statt nach fragiler Spaltenposition ansprechbar macht.

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 parse_coins(html):
    soup = BeautifulSoup(html, "html.parser")
    rows = soup.select("table tbody tr")
    coins = []
    for row in rows:
        name = text_of(row, '[data-coin-table-target="coinName"]')
        if not name:
            continue
        coins.append({
            "rank": text_of(row, "td:nth-child(2)"),
            "name": name,
            "symbol": text_of(row, '[data-coin-table-target="coinSymbol"]'),
            "price": text_of(row, '[data-coin-table-target="price"]'),
            "change_24h": text_of(row, '[data-coin-table-target="priceChange24h"]'),
            "change_7d": text_of(row, '[data-coin-table-target="priceChange7d"]'),
            "volume_24h": text_of(row, '[data-coin-table-target="volume"]'),
            "market_cap": text_of(row, '[data-coin-table-target="marketCap"]'),
        })
    return coins

Der Helfer text_of fragt ein Element innerhalb einer Zeile ab und gibt dessen bereinigten Text zurück, oder None, wenn das Element fehlt, sodass eine Münze, die ein Feld nicht enthält, die Schleife nicht unterbricht. Der Rang wird aus der zweiten Tabellenzelle gelesen, Name und Symbol kommen aus ihren getaggten Elementen, und Preis, die beiden Änderungsspalten, Volumen und Marktkapitalisierung werden jeweils einem data-coin-table-target-Wert zugeordnet. Der Wächter if not name: continue überspringt Leerzeilen oder Kopfzeilen ohne Münzname.

Schritt 3: Paginierung über Münzseiten hinweg

Eine Marktseite ist ein Ausschnitt der Gesamtliste. CoinGecko paginiert mit dem Abfrageparameter ?page=N, sodass man jede Seite durchläuft und Münzen bis zu einer selbst gesetzten Obergrenze sammelt. Ein kleiner Wiederholungsrahmen um den Abruf verhindert, dass eine einzelne langsame Seite den Lauf beendet.

import time

def fetch_html(page_url, max_retries=2):
    for attempt in range(max_retries + 1):
        html = crawl(page_url)
        if html:
            return html
        if attempt < max_retries:
            print(f"Retrying ({attempt + 1}/{max_retries})...")
            time.sleep(1)
    print(f"Unable to fetch {page_url}")
    return None

def collect_all_coins(base_url, max_pages):
    all_coins = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}?page={page}"
        html = fetch_html(page_url)
        if html:
            all_coins.extend(parse_coins(html))
        time.sleep(2)
    return all_coins

fetch_html wiederholt einen fehlgeschlagenen Abruf bis zu zweimal mit einer kurzen Pause und gibt bei Erfolg das HTML zurück, bei Aufgabe None. collect_all_coins durchläuft die Seiten von eins bis zur selbst gesetzten max_pages-Obergrenze, damit eine lange Liste nicht unbegrenzt läuft, parst jede Seite in Münzdatensätze und akkumuliert diese. Das time.sleep(2) zwischen den Seiten gibt dem Lauf ein ruhigeres Tempo, sodass Sie die Site nicht überlasten und deren Rate-Limits einhalten.

Schritt 4: Das vollständige Skript zusammensetzen

Verknüpfen Sie nun die Teile zu einem lauffähigen Skript: Seiten durchlaufen, jede Münze parsen und die Datensätze sowohl als JSON als auch als CSV exportieren.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

OPTIONS = {
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/122.0",
    "ajax_wait": "true",
    "page_wait": 5000,
}

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

def fetch_html(page_url, max_retries=2):
    for attempt in range(max_retries + 1):
        html = crawl(page_url)
        if html:
            return html
        if attempt < max_retries:
            time.sleep(1)
    return None

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

def parse_coins(html):
    soup = BeautifulSoup(html, "html.parser")
    rows = soup.select("table tbody tr")
    coins = []
    for row in rows:
        name = text_of(row, '[data-coin-table-target="coinName"]')
        if not name:
            continue
        coins.append({
            "rank": text_of(row, "td:nth-child(2)"),
            "name": name,
            "symbol": text_of(row, '[data-coin-table-target="coinSymbol"]'),
            "price": text_of(row, '[data-coin-table-target="price"]'),
            "change_24h": text_of(row, '[data-coin-table-target="priceChange24h"]'),
            "change_7d": text_of(row, '[data-coin-table-target="priceChange7d"]'),
            "volume_24h": text_of(row, '[data-coin-table-target="volume"]'),
            "market_cap": text_of(row, '[data-coin-table-target="marketCap"]'),
        })
    return coins

def collect_all_coins(base_url, max_pages):
    all_coins = []
    for page in range(1, max_pages + 1):
        html = fetch_html(f"{base_url}?page={page}")
        if html:
            all_coins.extend(parse_coins(html))
        time.sleep(2)
    return all_coins

def save_outputs(records):
    with open("coingecko_coins.json", "w") as f:
        json.dump(records, f, indent=2)
    if not records:
        return
    with open("coingecko_coins.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=records[0].keys())
        writer.writeheader()
        writer.writerows(records)

def main():
    coins_url = "https://www.coingecko.com/"
    coins = collect_all_coins(coins_url, max_pages=2)
    save_outputs(coins)
    print(f"Saved {len(coins)} coins")

if __name__ == "__main__":
    main()

Das Skript durchläuft bis zu zwei Marktseiten, ruft jede mit dem Wiederholungs-Wrapper ab, parst sie in Münzdatensätze und hält die Schleife mit einem Zwei-Sekunden-Schlaf an. save_outputs schreibt sowohl eine JSON-Datei als auch eine CSV-Datei, wobei die Schlüssel des ersten Datensatzes als Kopfzeile verwendet werden, sodass die Daten in der Form vorliegen, die das nachgelagerte Tool benötigt. Passen Sie max_pages und die Basis-URL an den Marktausschnitt an, der Sie interessiert.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python coingecko_scraper.py aus und Sie erhalten einen sauberen strukturierten Datensatz pro Münze, bereit zur Analyse, für eine Datenbank oder eine Tabellenkalkulation. Die nachstehenden Werte sind illustrative Platzhalter, die die Form zeigen, keine Live-Kurse.

[
  {
    "rank": "1",
    "name": "Bitcoin",
    "symbol": "BTC",
    "price": "$X,XXX.XX",
    "change_24h": "+1.2%",
    "change_7d": "-3.4%",
    "volume_24h": "$XX,XXX,XXX,XXX",
    "market_cap": "$X,XXX,XXX,XXX,XXX"
  },
  {
    "rank": "2",
    "name": "Ethereum",
    "symbol": "ETH",
    "price": "$X,XXX.XX",
    "change_24h": "+0.6%",
    "change_7d": "+2.1%",
    "volume_24h": "$XX,XXX,XXX,XXX",
    "market_cap": "$XXX,XXX,XXX,XXX"
  }
]

Die zugehörige CSV enthält dieselben Spalten, eine Zeile pro Münze, die sich direkt in pandas oder eine Tabellenkalkulation zum Sortieren nach Marktkapitalisierung, Filtern nach 7-Tage-Änderung oder Visualisieren des Volumens laden lässt. Von hier aus lässt sich dasselbe Muster auf andere Markt-Tracker übertragen; der Ansatz ähnelt dem Scrapen von Krypto-Preisen von CoinMarketCap.

Im großen Maßstab entsperrt bleiben

Selbst wenn das Rendering abgedeckt ist, beobachtet CoinGecko Scraper-typischen Datenverkehr. Einige Gewohnheiten halten einen längeren Lauf gesund, und sie gelten für jede stark frequentierte Datensite.

• Anfragen dosieren. Seiten im engen Takt zu treffen ist der schnellste Weg, gedrosselt oder herausgefordert zu werden. Die oben genannten Zwei-Sekunden-Pausen sind das Minimum, nicht das Maximum; für größere Aufgaben erweitern und die veröffentlichten Rate-Limits der Site einhalten.
• Auf Rotation setzen. Ein Pool aus Residential-IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne IP ein Rate-Limit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie einen eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Status-Codes lesen. Ein Lauf, der beginnt, Nicht-200-pc_status-Werte zurückzugeben, signalisiert, dass die aktuelle Rate oder das IP-Tier nicht mehr ausreicht. Das als Signal zum Zurückziehen behandeln, nicht als Rauschen ignorieren.

Für größere Crawls stellt der asynchrone Crawler Anfragen in die Warteschlange und liefert Ergebnisse an einen Webhook, was sich für das Verarbeiten vieler Seiten ohne offene Verbindungen eignet. Das übergeordnete Playbook finden Sie unter wie man Webseiten scrapt, ohne gesperrt zu werden.

Ist das Scrapen von CoinGecko legal?

Beginnen Sie mit dem offensichtlich besseren Weg: CoinGecko veröffentlicht eine offizielle öffentliche API, die Münzname, Symbol, Preis, Marktkapitalisierung, 24-Stunden-Volumen, prozentuale Änderungen und Rang als sauberes JSON zurückgibt, mit dokumentierten Rate-Limits und kostenpflichtigen Tarifen für höheren Durchsatz. Für jede produktive oder kommerzielle Nutzung ist diese API der vorgesehene Weg. Sie ist stabiler und respektvoller gegenüber der Plattform als das Parsen von gerendertem HTML. Der HTML-Ansatz in dieser Anleitung ist ein Lern-Fallback für seitenexklusive Felder oder einmalige Erkundungen, kein Ersatz für die API, wenn eine vorhanden ist.

Ob das Scrapen der Website selbst erlaubt ist, hängt von CoinGeckos Nutzungsbedingungen, Ihrer Jurisdiktion und dem Verwendungszweck der Daten ab. Lesen Sie CoinGeckos Bedingungen und die robots.txt, und behandeln Sie beide als Grenze dessen, was Sie sammeln und wie schnell Sie anfragen. Halten Sie das Anfragevolumen niedrig genug, um die Server nicht zu belasten, und bevorzugen Sie die API für alles jenseits gelegentlicher, leichter Nutzung. Die hier abgedeckten Marktdaten sind sachlich und nicht personenbezogen, was sie rechtlich auf sichererem Terrain belässt als nutzergenerierte Inhalte, aber die Bedingungen regeln trotzdem den automatisierten Zugang.

Diese Anleitung ist bewusst auf öffentliche Marktdaten beschränkt: Münznamen, Symbole, Preise, Marktkapitalisierungen, Volumina, prozentuale Änderungen und Ränge, die jeder ohne Konto einsehen kann. Sie behandelt nichts hinter einem Login oder einer Bezahlschranke, keine persönlichen oder Kontodaten sowie nicht die Weiterverbreitung von CoinGeckos Marken, Logos oder redaktionellen Inhalten, die deren Eigentum bleiben. Wenn Ihr Projekt zuverlässigen Zugang mit hohem Volumen benötigt, ist der richtige Weg CoinGeckos offizielle API oder ein lizenzierter Datenfeed, kein umfangreicherer Scraper. Einen breiteren Überblick über Anbieter finden Sie unter die besten Finanzdatenanbieter der Welt.

Häufig gestellte Fragen

Soll ich die CoinGecko-API verwenden oder das HTML scrapen?

Verwenden Sie die API. CoinGecko bietet eine kostenlose öffentliche API, die Münzname, Symbol, Preis, Marktkapitalisierung, 24-Stunden-Volumen, prozentuale Änderungen und Rang als sauberes JSON zurückgibt, mit dokumentierten Rate-Limits. Sie ist stabiler als das Parsen von HTML und der vorgesehene Weg für Produktionszwecke. Scrapen Sie die gerenderte Seite nur für Felder oder Ansichten, die der jeweilige API-Tarif nicht abdeckt, und halten Sie dabei die gleichen Rate-Limits ein.

Warum gibt eine einfache Anfrage nur einen Teil der CoinGecko-Tabelle zurück?

Weil CoinGecko Teile seiner Markttabelle clientseitig mit JavaScript hydratisiert: Preise und prozentuale Änderungen aktualisieren sich live, und einige Zellen füllen sich erst, nachdem die Seitenskripte im Browser ausgeführt wurden. Eine einfache HTTP-Anfrage kann Status 200 mit einer dünnen oder unvollständigen Tabelle zurückgeben. Um den vollen Zeilensatz zu erhalten, müssen Sie die Seite zunächst rendern, was das JS-Token der Crawling API übernimmt.

Benötige ich das normale Token oder das JS-Token für CoinGecko?

Das JS-Token. Das normale Token ruft statisches HTML ab, was auf einer teilweise clientseitig gerenderten Seite die Live-Zellen verpassen kann. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Münzzeilen mit ihren Preis-, Änderungs-, Volumen- und Marktkapitalisierungszellen vorhanden sind, wenn BeautifulSoup sie parst.

Welche Daten kann ich von CoinGecko extrahieren?

Öffentliche Marktdaten: Münzname und -symbol, aktueller Preis, Marktkapitalisierung, 24-Stunden-Volumen, die prozentuale Änderung über 24 Stunden und 7 Tage sowie der Marktkapitalisierungsrang. Das sind sachliche, nicht personenbezogene Marktdaten, die jeder Besucher einsehen kann. Von allem hinter einem Login oder einer Bezahlschranke die Finger lassen und CoinGeckos Logos, Marken oder redaktionelle Inhalte nicht weiterverbreiten.

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

Höchstwahrscheinlich CoinGeckos Markup. Klassennamen und data-coin-table-target-Attribute können sich ohne Vorankündigung ändern, und die prozentualen Änderungsspalten sind auf schmalen Viewports anders angeordnet. Prüfen Sie eine Live-Seite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist für jeden Produktions-Scraper normal und ein weiterer Grund, wo möglich die offizielle API zu bevorzugen.

Darf ich gescrapete CoinGecko-Daten kommerziell nutzen?

Das ist eine rechtliche Frage, keine technische. CoinGeckos Nutzungsbedingungen regeln den automatisierten Zugang und die Weiterverwendung, und kommerzielle oder volumenmäßig starke Nutzung gehört generell zur offiziellen API oder einem kostenpflichtigen Tarif und nicht zu einem Scraper. Lesen Sie die Bedingungen, nutzen Sie die API oder einen lizenzierten Feed für alles im großen Maßstab und holen Sie vor dem Aufbau eines Produkts auf Basis der Daten rechtlichen Rat ein.

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.