Comment scraper les prix crypto depuis CoinMarketCapdonnées de marché en direct avec Python

CoinMarketCap est la référence par défaut pour les données du marché crypto : il suit les prix en direct, la capitalisation boursière, le volume de trading et les classements sur des milliers de coins, et il met à jour ces chiffres en quasi temps réel. Ce tableau public est exactement ce qui alimente les tableaux de bord de prix, les trackers de portefeuille et la recherche de marché, c'est pourquoi tant de personnes souhaitent en obtenir une copie structurée propre.

Ce guide vous montre comment scraper les prix crypto depuis CoinMarketCap avec Python. Vous construisez un petit scraper exécutable qui récupère la page de liste rendue via la Crawling API, analyse les champs souhaités avec BeautifulSoup et écrit un enregistrement propre par coin. L'ensemble du tutoriel reste limité aux données de marché publiques : nom du coin, symbole, prix, capitalisation boursière, variation sur 24h et volume. La section légalité proche de la fin n'est pas un boilerplate, et CoinMarketCap propose une API officielle, alors lisez les deux avant de pointer ceci vers un volume réel.

Ce que vous allez construire

Un script Python qui récupère la page d'accueil publique de CoinMarketCap, récupère le HTML rendu via la Crawling API, et extrait un enregistrement structuré pour les principaux coins du tableau. Pour chaque coin vous récupérerez ces champs :

• Name le nom complet du coin, comme "Bitcoin".
• Symbol le symbole ticker, comme "BTC".
• Price le prix actuel en USD.
• Market cap la capitalisation boursière totale affichée sur la ligne.
• 24h change le pourcentage de variation sur les dernières 24 heures.
• Volume le volume de trading sur 24 heures.

Pourquoi une simple requête échoue sur CoinMarketCap

Si vous demandez CoinMarketCap avec un client HTTP brut, vous obtenez rarement le tableau de prix propre que vous voyez dans un navigateur. Deux choses jouent contre vous. Premièrement, CoinMarketCap rend une grande partie de son tableau de marché côté client : le HTML initial est une fine coquille, et les lignes ne se remplissent qu'après l'exécution du JavaScript de la page. Deuxièmement, le site est protégé par une protection anti-bot comme Cloudflare, de sorte que les adresses IP de centres de données et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont contestés ou limités avant même d'atteindre le tableau rendu.

Donc un requests.get() naïf tend à renvoyer soit une coquille vide, soit une page de défi au lieu des données sur les coins. Un scraper CoinMarketCap fonctionnel a besoin de deux choses ensemble : un navigateur qui rend la page, et une IP que le site lit comme un visiteur normal.

Vous pouvez assembler cela vous-même avec un navigateur headless plus un pool de proxies résidentiels rotatifs, mais assembler ces éléments et les maintenir en bonne santé représente la majeure partie du travail. La Crawling API regroupe les parties difficiles en un seul appel : vous lui envoyez l'URL CoinMarketCap avec un token JavaScript, elle rend la page derrière une IP de confiance, et elle remet du HTML terminé pour que vous l'analysiez. Si vous préférez router vos propres requêtes via un pool rotatif, le Smart AI Proxy vous donne la même rotation d'IPs résidentielles comme point de terminaison proxy de substitution.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des packages avec pip. Si vous êtes nouveau dans l'analyse HTML, notre guide sur comment utiliser BeautifulSoup en Python couvre les bases des sélecteurs que ce tutoriel suppose.

Python 3.8 ou supérieur. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

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. Traitez le token comme un mot de passe : il authentifie vos requêtes, alors ne le mettez pas dans le contrôle de version.

Configurer le projet

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

python --version

python -m venv cmc_env
source cmc_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec cmc_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML renvoyé afin que vous puissiez extraire des champs individuels par sélecteur CSS.

Étape 1 : Récupérer la page rendue

Commencez par obtenir la page terminée. Importez la classe CrawlingAPI, initialisez-la avec votre token JS et demandez l'URL CoinMarketCap. Vérifier le code de statut avant d'analyser garde les échecs visibles plutôt que silencieux.

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")

Les deux options d'attente comptent pour une cible rendue côté client comme celle-ci : ajax_wait indique à l'API d'attendre la fin du chargement du contenu asynchrone, et page_wait attend un nombre fixe de millisecondes après le chargement pour que les lignes du tableau à rendu tardif apparaissent avant que la page soit capturée. Cinq secondes est un bon point de départ ; augmentez-les si le tableau revient vide. CoinMarketCap envoie des pages dans diverses encodages, donc le décodage avec latin1 évite les erreurs d'octets qu'un décodage UTF-8 strict peut lever. Exécutez le script et vous devriez voir un vrai balisage de marché, pas la fine coquille qu'une simple récupération renvoie.

Étape 2 : Analyser les champs des coins avec BeautifulSoup

Avec le HTML rendu en main, chargez-le dans BeautifulSoup et parcourez les lignes du tableau. CoinMarketCap dispose chaque coin comme une ligne dans le tableau de marché principal, avec le nom et le symbole dans la cellule du coin et les champs numériques dans les colonnes à droite. Entourez l'extraction de chaque ligne dans un try/except pour qu'un champ manquant ne fasse pas planter l'ensemble de l'exécution.

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

Le nom et le symbole ont des crochets de classe stables et lisibles par l'humain, p.coin-item-name et p.coin-item-symbol, vous les ciblez donc directement. Les colonnes numériques (prix, variation sur 24h, capitalisation boursière et volume) sont extraites positionnellement depuis les cellules td de la ligne, car le nom de classe de la cellule de prix de CoinMarketCap est haché et change fréquemment, ce qui le rend impropre à être codé en dur. L'assistant text_of renvoie None au lieu de lever une exception quand un élément est manquant, et le try/except protège contre une ligne dont la disposition de colonnes diffère, de sorte qu'une ligne atypique ne fait jamais planter l'exécution.

Étape 3 : Assembler le tout

Reliez maintenant la récupération et l'analyse en un seul script exécutable. Récupérez le HTML rendu, passez-le au parseur et affichez les enregistrements structurés en JSON.

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()

À quoi ressemble la sortie

Exécutez le script complet avec python scraper.py et vous obtenez une liste propre d'enregistrements structurés, prête à être écrite en JSON, CSV ou en base de données. Les prix exacts différeront de l'exemple ci-dessous, puisque le marché évolue constamment.

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

Exporter en CSV et JSON

Un seul dump JSON dans la console convient pour une démonstration, mais vous voudrez généralement les données sur le disque pour les stocker ou les analyser ultérieurement. Les enregistrements sont déjà une liste de dictionnaires plats, donc écrire les deux formats ne prend que quelques lignes. Réutilisez les fonctions crawl et scrape_coins du script complet ci-dessus.

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")

À partir de là, un CSV s'intègre directement dans un tableur ou un DataFrame pandas pour l'analyse, et le fichier JSON est facile à charger dans un service en aval. Si vous souhaitez un flux en direct plutôt qu'un instantané ponctuel, planifiez le script pour qu'il s'exécute à intervalle régulier et ajoutez chaque extraction à un fichier daté.

Passer à plus de coins et de pages

La page d'accueil liste les principaux coins, mais CoinMarketCap pagine le classement complet. La forme du travail ne change pas : la structure de la liste est la même sur chaque page, donc le parseur que vous avez déjà écrit continue de fonctionner. Parcourez les pages numérotées, récupérez chacune via la Crawling API et collectez les lignes.

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")

Si vous avez besoin que cela s'exécute sans surveillance à grande échelle, mettez en file d'attente les URLs des pages via le Crawler asynchrone au lieu de boucler de manière synchrone, vous soumettez ainsi l'ensemble des pages et collectez les résultats au fur et à mesure qu'ils arrivent. Pour plus d'informations sur les cibles à rendu intensif, notre tutoriel sur comment scraper des pages JavaScript avec Python approfondit le schéma d'attente et de rendu sur lequel ce scraper s'appuie.

Rester non bloqué

Même avec le rendu géré, CoinMarketCap surveille le trafic en forme de scraper. Quelques habitudes maintiennent une exécution saine, et elles s'appliquent à toute cible protégée et à fort contenu JavaScript.

• Rythmez vos requêtes. Récupérer chaque page dans une boucle serrée est le moyen le plus rapide d'être limité. Espacez les requêtes, et pour un flux en direct toutes les quelques minutes suffit plutôt que de surcharger à cadence serrée.
• Misez sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune n'atteigne une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des défis ou des erreurs vous indique que le débit actuel ou le niveau d'IP n'est plus suffisant. Traitez cela comme un signal pour ralentir, pas comme du bruit à ignorer.

Pour le guide plus large, consultez comment scraper des sites sans être bloqué et l'analyse approfondie sur comment contourner les captchas lors du web scraping.

Est-il légal de scraper CoinMarketCap ?

La légalité du scraping de CoinMarketCap dépend des conditions d'utilisation du site, de votre juridiction et de ce que vous faites avec les données. CoinMarketCap publie des conditions d'utilisation et un robots.txt, et les deux fixent la limite pour l'accès automatisé. Aucun code ici ne change cela ; il fait juste fonctionner la partie technique. Lisez ces documents et traitez-les comme la limite de ce que vous collectez et de la fréquence à laquelle vous le demandez, en particulier avant tout projet commercial.

Gardez votre portée réduite. Le tableau de marché couvert ici est de véritables données publiques : nom du coin, symbole, prix, capitalisation boursière, variation sur 24h et volume, tous visibles sans compte. C'est la ligne qui rend le travail défendable. Ce que ce guide ne couvre pas est tout aussi important : tout ce qui se trouve derrière une connexion, les données de compte ou de liste de surveillance liées à un utilisateur, les informations personnelles et les médias protégés par le droit d'auteur que vous redistribueriez sont tous hors de portée. Ne contournez pas l'authentification pour atteindre des données que le tableau public ne montre pas déjà.

Une dernière chose spécifique à cette cible : CoinMarketCap propose une API officielle. Pour les systèmes de production, l'utilisation commerciale ou les extractions à volume élevé, cette API officielle est la bonne voie, car elle vous donne un contrat supporté, des limites de débit prévisibles et des données que vous êtes clairement autorisé à utiliser. Le scraping du site public convient à l'apprentissage, au prototypage et aux petits travaux sur données publiques, pas à une entreprise qui a besoin d'une disponibilité garantie et de droits d'utilisation clairs. En cas de doute, préférez l'API officielle.

Foire aux questions

Pourquoi une simple requête ne renvoie-t-elle aucun prix crypto depuis CoinMarketCap ?

Deux raisons. Premièrement, CoinMarketCap rend une grande partie de son tableau de marché côté client avec JavaScript, donc le HTML brut est une fine coquille qui ne se remplit qu'après l'exécution des scripts de la page. Deuxièmement, le site est protégé par une protection anti-bot comme Cloudflare, donc le trafic automatisé depuis des IPs de centres de données est souvent contesté ou limité avant d'atteindre les données. Rendre la page avec le token JS de la Crawling API, derrière une IP de confiance, est ce qui fait apparaître les lignes.

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

Le token JS. Le token normal récupère le HTML statique, qui sur CoinMarketCap tend à être la même fine coquille qu'une simple récupération renvoie. Le token JS rend la page dans un vrai navigateur avant de remettre le HTML, de sorte que les lignes du tableau, y compris le prix, la capitalisation boursière et le volume, sont présentes quand BeautifulSoup les analyse.

À quelle fréquence puis-je scraper les prix crypto ?

Pour un flux en direct, extraire toutes les quelques minutes est généralement sûr et vous maintient bien en dessous de tout plafond de débit. Surcharger le site dans une boucle serrée est le moyen le plus rapide d'être limité ou contesté. Routez via des IPs résidentielles rotatives, surveillez vos codes de statut et ralentissez quand vous commencez à voir des défis. Pour un débit garanti, l'API officielle CoinMarketCap est le meilleur choix.

Mes sélecteurs renvoient des valeurs incorrectes. Qu'est-ce qui a changé ?

Presque certainement le balisage de CoinMarketCap. Ses noms de classes CSS hachés changent fréquemment et l'ordre des colonnes peut changer, de sorte que des sélecteurs et des indices positionnels qui fonctionnaient le mois dernier peuvent se casser. Ancrez-vous sur les hooks stables p.coin-item-name et p.coin-item-symbol quand vous le pouvez, réinspectez une page en direct dans les outils de développement de votre navigateur quand un champ semble incorrect, et mettez à jour le sélecteur ou l'index de cellule. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Dois-je scraper CoinMarketCap ou utiliser son API officielle ?

Pour l'apprentissage, le prototypage et les petits travaux sur données publiques, scraper le tableau public est un bon moyen d'obtenir le nom, le symbole, le prix, la capitalisation boursière, la variation sur 24h et le volume. Pour les systèmes de production, l'utilisation commerciale ou les extractions à volume élevé, utilisez l'API officielle de CoinMarketCap : elle vous donne un contrat supporté, des limites de débit prévisibles et des droits d'utilisation clairs. Choisissez l'outil qui correspond aux enjeux de votre projet.

Quelles données crypto puis-je légalement collecter ?

Restez sur les données de marché publiques affichées sans compte : nom du coin, symbole, prix, capitalisation boursière, variation sur 24h et volume. Ne collectez pas les données de compte, de liste de surveillance ou personnelles, ne touchez rien derrière une connexion et ne contournez jamais l'authentification. Respectez les conditions d'utilisation et le robots.txt de CoinMarketCap, et pour un usage commercial ou en volume, appuyez-vous sur l'API officielle plutôt que de faire évoluer un scraper contre le site public.

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.