Comment extraire des données de CoinGeckoprix des cryptos et capitalisations boursières

CoinGecko centralise le suivi de milliers de cryptomonnaies en un seul endroit, et ses pages de marché contiennent précisément les données structurées qui alimentent le suivi des prix, les outils de portefeuille et la recherche : le nom de la pièce et son symbole, le prix actuel, la capitalisation boursière, le volume de trading sur 24 heures, la variation de prix sur 24 heures et 7 jours, ainsi que le rang par capitalisation. Pour quiconque surveille un panier de pièces, ces données de marché publiques constituent la matière première, et les copier à la main sur des centaines de lignes est lent et devient obsolète dès que vous avez terminé.

Ce guide vous montre comment extraire des données de cryptomonnaies depuis CoinGecko avec Python. CoinGecko publie une API publique officielle, et pour tout usage en production c'est la voie à privilégier en premier. La méthode HTML présentée ici est un recours éducatif pour les champs ou pages que le niveau gratuit de l'API ne couvre pas, et elle reste strictement limitée aux données de marché publiques, qui sont factuelles et non personnelles. Une section consacrée à la légalité se trouve vers la fin ; lisez-la avant de viser un volume réel.

Ce que vous allez construire

Un script Python qui récupère une page de marché CoinGecko rendue via l'API Crawling, analyse chaque ligne de pièce avec BeautifulSoup et produit un enregistrement structuré par pièce. L'exemple utilisé est celui des meilleures pièces du listing principal CoinGecko. Nous extrayons ces champs :

• Name le nom complet de la pièce, comme Bitcoin ou Ethereum.
• Symbol le code abrégé, comme BTC ou ETH.
• Price le prix actuel dans la devise fiduciaire choisie.
• Market cap la capitalisation boursière totale de la pièce.
• Volume le volume de trading au cours des 24 dernières heures.
• Change 24h la variation de prix en pourcentage sur les 24 dernières heures.
• Change 7d la variation de prix en pourcentage sur les 7 derniers jours.
• Rank le rang par capitalisation affiché sur la ligne.

Pourquoi une requête simple échoue sur CoinGecko

Si vous requêtez une page de marché CoinGecko avec un client HTTP brut, vous obtenez souvent une réponse avec le statut 200 et seulement une fraction du tableau dans le corps. Deux facteurs vous desservent. Premièrement, CoinGecko hydrate une grande partie de son tableau de marché dans le navigateur via JavaScript : les prix et les variations en pourcentage se mettent à jour en temps réel, et certaines parties de la ligne ne se remplissent qu'après l'exécution des scripts de la page. Si vous analysez la première réponse, vous pouvez récupérer un tableau partiel plutôt que l'ensemble complet des lignes. Deuxièmement, comme tout site à fort trafic, CoinGecko surveille le trafic automatisé, et les adresses IP de datacenters qui le sollicitent en boucle serrée sont limitées en débit ou mises au défi avant d'atteindre le contenu rendu.

Un scraper fonctionnel nécessite donc deux choses en une seule requête : un navigateur qui rend réellement la page, et une IP que le site lit comme un visiteur réel. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique et un pool de proxies résidentiels rotatifs, mais les assembler et les maintenir en bon état représente l'essentiel du travail. L'API Crawling intègre les deux dans un seul appel : vous lui envoyez l'URL avec un token JavaScript, elle rend la page derrière une IP de confiance, et vous renvoie le HTML finalisé à analyser.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend beaucoup de temps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous débutez avec l'analyse syntaxique, le guide BeautifulSoup est un bon complément à ce tutoriel.

Python 3.8 ou version ultérieure. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda, et assurez-vous que Python est dans votre PATH.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS) depuis la page de documentation du compte. Crawlbase inclut jusqu'à 20 000 requêtes gratuites pour commencer, ce qui est largement suffisant pour suivre ce guide. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les bibliothèques dont le scraper a besoin.

python --version

python -m venv coingecko_env
source coingecko_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec coingecko_env\Scripts\activate à la place de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour l'API Crawling, et beautifulsoup4 analyse le HTML renvoyé pour extraire les champs individuels par sélecteur CSS. Les modules json et csv sont inclus dans la bibliothèque standard, il n'y a donc rien de plus à installer pour l'étape d'export.

Étape 1 : Récupérer une page CoinGecko rendue

Commencez par obtenir une page finalisée. Importez la classe CrawlingAPI, initialisez-la avec votre token JS et requêtez l'URL des pièces CoinGecko. CoinGecko met à jour certaines parties de son tableau côté client, donc passez ajax_wait et page_wait pour attendre le contenu dynamique avant la capture de la page. Vérifier le cb_status (legacy pc_status) de Crawlbase avant d'analyser permet de rendre les échecs visibles plutôt que silencieux.

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"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_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")

Les deux options d'attente sont importantes pour une cible partiellement rendue côté client. ajax_wait demande à l'API d'attendre que le contenu asynchrone ait fini de se charger, et page_wait maintient un délai fixe en millisecondes après le chargement afin que les cellules à rendu tardif apparaissent avant la capture de la page. Cinq secondes est un bon point de départ ; augmentez cette valeur si les lignes reviennent incomplètes. Exécutez le script avec python coingecko_scraper.py et vous devriez voir de véritables balises de marché CoinGecko, pas un squelette vide. Cela confirme que le rendu fonctionne avant d'écrire le moindre sélecteur.

Étape 2 : Analyser les lignes de pièces

La page de pièces CoinGecko est un tableau où chaque ligne représente une pièce. Chargez le HTML rendu dans BeautifulSoup et sélectionnez les lignes du corps du tableau, puis lisez chaque cellule via son attribut de données. CoinGecko étiquette ses cellules de marché avec des valeurs data-coin-table-target, ce qui les rend stables à cibler par champ plutôt que par position de colonne fragile.

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

L'assistant text_of interroge un élément dans une ligne et renvoie son texte nettoyé, ou None si l'élément est absent, de sorte qu'une pièce qui omet un champ ne brise pas la boucle. Le rang est lu depuis la deuxième cellule de colonne, le nom et le symbole proviennent de leurs éléments étiquetés, et le prix, les deux colonnes de variation, le volume et la capitalisation correspondent chacun à une valeur data-coin-table-target. La garde if not name: continue ignore les lignes d'espacement ou d'en-tête qui n'ont pas de nom de pièce.

Étape 3 : Gérer la pagination sur les pages de pièces

Une page de marché n'est qu'une tranche de la liste complète. CoinGecko pagine avec un paramètre de requête ?page=N, vous parcourez donc chaque page en collectant les pièces jusqu'à un plafond que vous définissez. Un petit wrapper de retry autour de la récupération empêche qu'une seule page lente mette fin à l'exécution.

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 retente une récupération échouée jusqu'à deux fois avec une courte pause, renvoyant le HTML en cas de succès et None une fois qu'il abandonne. collect_all_coins parcourt les pages de un jusqu'au plafond max_pages pour qu'une longue liste ne s'emballe pas, analyse chaque page en enregistrements de pièces et les accumule. Le time.sleep(2) entre les pages cadence l'exécution pour ne pas surcharger le site et rester dans ses limites de débit.

Étape 4 : Assembler le script complet

Reliez maintenant les pièces en un script exécutable : parcourez les pages, analysez chaque pièce et exportez les enregistrements vers JSON et CSV.

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"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_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()

Le script parcourt jusqu'à deux pages de marché, récupère chacune avec le wrapper de retry, l'analyse en enregistrements de pièces et cadence la boucle avec une pause de deux secondes. save_outputs écrit à la fois un fichier JSON et un CSV en utilisant les clés du premier enregistrement comme en-tête, vous disposez ainsi des données dans la forme que votre outil aval préfère. Ajustez max_pages et l'URL de base selon la tranche du marché qui vous intéresse.

À quoi ressemble la sortie

Exécutez le script complet avec python coingecko_scraper.py et vous obtenez un enregistrement structuré propre par pièce, prêt pour l'analyse, une base de données ou un tableur. Les valeurs ci-dessous sont des exemples illustratifs montrant la structure, pas des cotations en direct.

[
  {
    "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"
  }
]

Le CSV correspondant contient les mêmes colonnes, une ligne par pièce, ce qui s'importe directement dans pandas ou tout tableur pour trier par capitalisation, filtrer par variation sur 7 jours ou tracer le volume. À partir de là, le même schéma s'applique à d'autres trackers de marché ; l'approche est proche de celle du scraping des prix crypto sur CoinMarketCap.

Rester débloqué à l'échelle

Même avec le rendu pris en charge, CoinGecko surveille le trafic ressemblant à du scraping. Quelques habitudes maintiennent une exécution longue en bonne santé, et elles s'appliquent à tout site de données à fort trafic.

• Cadencez vos requêtes. Bombarder les pages en boucle serrée est le moyen le plus rapide d'être limité ou mis au défi. Les pauses de deux secondes ci-dessus sont le plancher, pas le plafond ; élargissez-les pour les gros travaux et respectez les limites de débit publiées par le site.
• Misez sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels de sorte qu'aucune seule ne déclenche une limite de débit. L'API Crawling s'en charge pour vous ; si vous construisez votre propre stack, c'est la partie à bien soigner.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des valeurs cb_status non-200 vous indique que le débit ou le niveau d'IP actuel ne suffit plus. Traitez cela comme un signal pour lever le pied, pas comme du bruit à ignorer.

Pour les crawls plus importants, le Crawler asynchrone met les requêtes en file d'attente et livre les résultats à un webhook, ce qui convient pour exécuter de nombreuses pages sans maintenir de connexions ouvertes. Pour le guide pratique complet, consultez comment scraper des sites sans être bloqué.

Est-il légal de scraper CoinGecko ?

Commencez par la meilleure voie évidente : CoinGecko publie une API publique officielle qui renvoie le nom de la pièce, le symbole, le prix, la capitalisation, le volume sur 24 heures, les variations en pourcentage et le rang sous forme de JSON propre, avec des limites de débit documentées et des niveaux payants pour un débit plus élevé. Pour tout usage en production ou commercial, cette API est la voie officielle, elle est à la fois plus stable et plus respectueuse de la plateforme que l'analyse du HTML rendu. La méthode HTML dans ce guide est un recours éducatif pour les champs spécifiques à une page ou l'exploration ponctuelle, pas un remplacement de l'API lorsqu'elle existe.

La légalité du scraping du site web lui-même dépend des Conditions d'utilisation de CoinGecko, de votre juridiction et de ce que vous faites des données. Lisez les Conditions de CoinGecko et son fichier robots.txt, et traitez les deux comme la limite de ce que vous collectez et à quelle vitesse vous le demandez. Gardez votre volume de requêtes suffisamment bas pour ne pas surcharger ses serveurs, et préférez l'API pour tout usage au-delà d'une utilisation légère et occasionnelle. Les données de marché ici sont factuelles et non personnelles, ce qui les place sur un terrain plus sûr que le contenu généré par les utilisateurs, mais les conditions régissent néanmoins l'accès automatisé.

Ce guide est délibérément limité aux données de marché publiques : noms de pièces, symboles, prix, capitalisations, volumes, variations en pourcentage et rangs que tout le monde peut voir sans compte. Il ne couvre rien derrière une connexion ou un paywall, aucune donnée personnelle ou de compte, ni la redistribution de la marque, des logos ou du contenu éditorial de CoinGecko, qui restent sa propriété. Si votre projet nécessite un accès fiable à volume élevé, la bonne voie est l'API officielle de CoinGecko ou un flux de données sous licence, pas un scraper plus lourd. Pour un aperçu plus large des fournisseurs, consultez les meilleurs fournisseurs de données financières.

Foire aux questions

Dois-je utiliser l'API CoinGecko ou scraper le HTML ?

Utilisez l'API. CoinGecko propose une API publique gratuite qui renvoie le nom de la pièce, le symbole, le prix, la capitalisation, le volume sur 24 heures, les variations en pourcentage et le rang sous forme de JSON propre, avec des limites de débit documentées. Elle est plus stable que l'analyse du HTML et c'est la voie officielle pour la production. Scrapez la page rendue uniquement pour les champs ou vues que votre niveau d'API n'expose pas, et respectez les mêmes limites de débit dans ce cas.

Pourquoi une requête simple ne renvoie-t-elle qu'une partie du tableau CoinGecko ?

Parce que CoinGecko hydrate certaines parties de son tableau de marché côté client avec JavaScript : les prix et les variations en pourcentage se mettent à jour en temps réel, et certaines cellules ne se remplissent qu'après l'exécution des scripts de la page dans un navigateur. Une requête HTTP brute peut renvoyer un statut 200 avec un tableau partiel ou incomplet. Pour obtenir l'ensemble complet des lignes, vous devez d'abord rendre la page, ce que gère le token JS de l'API Crawling.

Ai-je besoin du token normal ou du token JS pour CoinGecko ?

Le token JS. Le token normal récupère le HTML statique, ce qui sur une page partiellement rendue côté client peut manquer les cellules en temps réel. Le token JS rend la page dans un vrai navigateur avant de restituer le HTML, de sorte que les lignes de pièces et leurs cellules de prix, variation, volume et capitalisation sont présentes quand BeautifulSoup les analyse.

Quelles données puis-je extraire de CoinGecko ?

Les données de marché publiques : le nom et le symbole de la pièce, le prix actuel, la capitalisation, le volume sur 24 heures, la variation en pourcentage sur 24 heures et 7 jours, et le rang par capitalisation. Ce sont des données de marché factuelles et non personnelles, visibles par tout visiteur. Restez à l'écart de tout ce qui se trouve derrière une connexion ou un paywall, et ne redistribuez pas les logos, la marque ou le contenu éditorial de CoinGecko.

Mes sélecteurs renvoient None. Qu'est-ce qui a changé ?

Presque certainement le balisage de CoinGecko. Ses noms de classes et ses attributs data-coin-table-target peuvent changer sans préavis, et les colonnes de variation en pourcentage sont disposées différemment sur les viewports étroits. Réinspectez une page en direct dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. Une maintenance périodique des sélecteurs est normale pour tout scraper en production, c'est une raison supplémentaire de préférer l'API officielle lorsque c'est possible.

Puis-je utiliser commercialement des données CoinGecko scrapées ?

Traitez cela comme une question juridique, pas technique. Les Conditions d'utilisation de CoinGecko régissent l'accès automatisé et la réutilisation, et l'usage commercial ou à volume élevé appartient généralement à son API officielle ou à un niveau payant plutôt qu'à un scraper. Examinez les conditions, utilisez l'API ou un flux sous licence pour tout usage à l'échelle, et consultez un juriste avant de construire un produit sur ces données.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.