← Blog
10 min de lecture
|
Publié le
|
Mis à jour le

Configurer un nœud Binance Smart Chain (BSC)

Configurez un nœud BSC selon la méthode officielle : snapshot, fork geth de bnb-chain, unité systemd, matériel, coûts, et quand une API est préférable.

Chapitres
C
Chaingateway Team
Experts blockchain

Relu par Maurice Sobiera

Un nœud BSC est un ordinateur qui exécute le client BNB Smart Chain. Il télécharge et valide chaque bloc, puis expose un endpoint JSON-RPC local : votre logiciel lit la chaîne et envoie des transactions sans passer par un tiers. BNB Smart Chain s’appelait Binance Smart Chain jusqu’en février 2022.

La chaîne produit un bloc toutes les 0,45 seconde depuis le hard fork Fermi du 14 janvier 2026. Maxwell avait réduit l’intervalle de moitié, à 0,75 seconde, mi-2025. Cette vitesse est agréable pour les utilisateurs et exigeante pour les opérateurs de nœuds : avec un mauvais matériel ou une mauvaise stratégie de synchronisation, le nœud n’atteint jamais la tête de la chaîne.

Ce guide est la version copier-coller que la documentation officielle ne fournit pas. Il couvre une installation à partir d’un snapshot avec le fork geth de bnb-chain, une unité systemd, des notes de sécurité pour les nœuds RPC, le calcul du temps de synchronisation et des coûts, ainsi que les cas où vous ne devriez pas faire tourner de nœud. Les numéros de version et les tailles ont été vérifiés dans les dépôts GitHub du projet le 5 novembre 2026.

Qu’est-ce qu’un nœud BSC, et de quel type avez-vous besoin ?

Un nœud BSC exécute le client de la chaîne, valide les blocs et vous donne un endpoint JSON-RPC local avec la même interface qu’Ethereum : eth_blockNumber, eth_call, eth_sendRawTransaction et le reste. Quatre variantes comptent en pratique.

  • Un full node conserve l’état récent et sert le RPC. C’est le choix par défaut et le sujet de ce guide.
  • Un fast node est un full node démarré avec --tries-verify-mode none. La documentation officielle le recommande pour de hautes performances quand la cohérence de l’état vous importe peu.
  • Un archive node stocke tous les états historiques. Il demande plusieurs téraoctets de plus et n’a de sens que pour l’indexation et l’analytique.
  • Un validator produit des blocs. Il doit être élu dans le petit ensemble de validateurs avec du BNB staké, un sujet à part qui dépasse un guide d’installation.

Et un nœud léger ? Le fork geth a hérité du code du client léger, mais en pratique presque rien sur BSC ne sert de pairs légers : considérez le « nœud léger BSC » comme indisponible. Si même un full node élagué dépasse vos besoins, c’est le cas d’usage d’une API. Voir la dernière section.

Le même choix sous forme de tableau, avec les chiffres de disque issus des dépôts du projet (vérifiés le 5 novembre 2026) :

Type de nœudDisqueHistoriqueQui l’exécute
Full node élaguésnapshot d’environ 1,9 To compressé ; prévoir 4 To NVMeblocs récentsquiconque a besoin de son propre RPC
Fast node (--tries-verify-mode none)comme un full nodeblocs récentsRPC sous forte charge
Archive nodeenviron 7,8 To (snapshot archive Reth-BSC du 2 novembre 2026)completindexeurs, plateformes d’analytique
Validatornon couvert iciblocs récentsuniquement l’ensemble élu

BSC et Geth : une base de code, deux chaînes

Le client de BSC est un fork de go-ethereum, maintenu sur github.com/bnb-chain/bsc, et le binaire s’appelle littéralement geth. Il parle le même JSON-RPC, accepte la plupart des mêmes flags et ajoute les spécificités de BSC : le consensus proof-of-staked-authority Parlia (un seul processus constitue tout le nœud, sans client de consensus séparé comme sur Ethereum après la fusion), ainsi que des flags comme --tries-verify-mode. Deux conséquences pratiques en découlent :

  • Vos outils Ethereum fonctionnent sans changement face à un nœud BSC.
  • Vous devez exécuter le build de bnb-chain. Le Geth upstream ne peut pas synchroniser BSC. C’est l’erreur de débutant la plus courante avec « bsc geth ».

Quelle configuration matérielle pour un nœud BSC ?

La base vient du README de bnb-chain/bsc. Sa colonne de droite ci-dessous est notre suggestion pour un usage RPC intensif, pas un chiffre officiel.

ComposantFull node élagué (README)RPC intensif (notre suggestion)
CPU16 cœurs16 cœurs, fréquence élevée
RAM64 Go128 Go
DisqueSSD de 3 To (chiffre du README de décembre 2023 ; prévoir 4 To), 8k IOPS, 500 Mo/s, latence de lecture inférieure à 1 ms, NVMe pour la snap sync4 To+ NVMe, ≥10k IOPS
Réseau5 Mo/s (environ 40 Mbit/s) montant et descendant100 Mbit/s+, sans limite de volume

La ligne qui fait échouer la plupart des installations, ce sont les IOPS, pas la capacité. Avec des blocs de 0,45 seconde, le nœud écrit en permanence. Un stockage bloc cloud aux IOPS par défaut prend du retard sur la tête de la chaîne et ne le rattrape jamais. La référence du README est AWS gp3 avec 8 000 IOPS et une latence de lecture inférieure à la milliseconde, sur une instance m5zn.6xlarge ou r7iz.4xlarge (c2-standard-16 sur Google Cloud). Un disque NVMe local dans un serveur dédié dépasse largement ce seuil.

Pas à pas : full node BSC à partir du snapshot officiel

Synchroniser depuis la genèse est possible, mais c’est une mauvaise idée. La documentation du full node le déconseille : cela demande un matériel plus puissant et beaucoup de temps. La voie prise en charge consiste à télécharger le snapshot des données de la chaîne, à démarrer le nœud dessus et à le laisser rattraper son retard. Les commandes supposent Ubuntu 24.04.

1. Préparer le serveur

Terminal window
sudo apt update && sudo apt install -y aria2 lz4 unzip jq
sudo useradd --no-create-home --shell /usr/sbin/nologin bsc
sudo mkdir -p /var/lib/bsc
sudo chown bsc:bsc /var/lib/bsc
sudo ufw allow 30311 comment 'bsc p2p'

Le port 30311 est le port pair-à-pair de BSC et le seul port blockchain qui doit être ouvert. Le port RPC reste sur localhost.

2. Télécharger le binaire geth de bnb-chain

Terminal window
cd /tmp
curl -s https://api.github.com/repos/bnb-chain/bsc/releases/latest \
| jq -r '.assets[] | select(.name=="geth_linux") | .browser_download_url' \
| xargs wget -O geth_linux
chmod +x geth_linux
sudo mv geth_linux /usr/local/bin/geth-bsc
geth-bsc version

Renommer le binaire en geth-bsc évite l’accident classique : démarrer un geth upstream installé par la distribution sur des données BSC.

3. Récupérer config.toml et genesis.json

Terminal window
cd /tmp
curl -s https://api.github.com/repos/bnb-chain/bsc/releases/latest \
| jq -r '.assets[] | select(.name=="mainnet.zip") | .browser_download_url' \
| xargs wget -O mainnet.zip
unzip -o mainnet.zip
sudo mv config.toml genesis.json /var/lib/bsc/
sudo chown bsc:bsc /var/lib/bsc/config.toml /var/lib/bsc/genesis.json

Remarque : geth-bsc init genesis.json n’est nécessaire que pour une synchronisation depuis la genèse. Avec la méthode par snapshot, vous sautez l’init : le snapshot apporte sa propre base de données.

4. Télécharger et décompresser le snapshot

Les snapshots se trouvent dans le dépôt officiel bsc-snapshots. Le 5 novembre 2026, il liste deux jeux de données pour le mainnet, tous deux issus du snapshot du 9 octobre 2026 et tous deux exigeant BSC v1.7.2 ou plus récent :

SnapshotTaille (compressé)Usage
Élagué (...-pruneancient)environ 1,9 ToBlocs récents uniquement. Le bon choix pour ce guide.
Completenviron 7,4 ToHistorique complet des blocs.

Le dépôt renvoie aussi vers des snapshots d’autres sources, comme un snapshot de full node élagué d’environ 900 Go du BNB48 Club et des snapshots Reth-BSC pour le client Reth. Il fournit fetch-snapshot.sh, qui télécharge, vérifie la somme de contrôle MD5 (-c) et décompresse en une seule commande. Utilisez -p pour le snapshot élagué. La méthode manuelle ci-dessous montre ce que le script fait en coulisses. Deux façons de mettre l’archive sur le disque :

Terminal window
cd /var/lib/bsc
# Option A: resumable download, needs space for archive + extracted data
sudo -u bsc aria2c -x8 -s8 -c '<PASTE_SNAPSHOT_URL>'
sudo -u bsc bash -c "lz4 -cd geth.tar.lz4 | tar -x"
# Option B: stream-extract, needs space only once, but no resume
sudo -u bsc bash -c "wget -qO- '<PASTE_SNAPSHOT_URL>' | lz4 -d | tar -x"

aria2c télécharge sur huit connexions et reprend après une interruption (-c). Avec un simple wget, un téléchargement de plusieurs téraoctets interrompu repart de zéro. Après l’extraction, la base de données de la chaîne doit se trouver dans /var/lib/bsc/geth/chaindata. La disposition de l’archive a changé d’une génération de snapshots à l’autre : déplacez le dossier geth interne à cet emplacement si nécessaire.

Vérifiez avant de décompresser : comparez le MD5 de la page du snapshot, ou laissez fetch-snapshot.sh -c s’en charger. Une archive d’un téraoctet corrompue d’un seul bit vous coûte une journée.

L’option A exige de la place pour l’archive et pour les données extraites en même temps. C’est la vraie raison de la recommandation d’un disque de 4 To.

5. Unité systemd

Créez /etc/systemd/system/bsc.service :

[Unit]
Description=BSC full node (bnb-chain geth fork)
After=network-online.target
Wants=network-online.target
[Service]
User=bsc
Group=bsc
Type=simple
Restart=always
RestartSec=5
TimeoutStopSec=600
LimitNOFILE=65536
ExecStart=/usr/local/bin/geth-bsc \
--config /var/lib/bsc/config.toml \
--datadir /var/lib/bsc \
--cache 8000 \
--tries-verify-mode none \
--history.transactions 0 \
--rpc.allow-unprotected-txs \
--http --http.addr 127.0.0.1 --http.port 8545 \
--http.api eth,net,web3
[Install]
WantedBy=multi-user.target

--tries-verify-mode none est l’interrupteur « fast node » de la documentation officielle, pour servir du RPC quand vous acceptez le compromis sur la cohérence de l’état. Retirez-le pour exécuter un full node élagué normal. --history.transactions 0 indexe toutes les transactions des blocs que contient votre base de données. Les guides plus anciens utilisent pour cela le flag déprécié --txlookuplimit 0.

Le README de bsc-snapshots suggère d’autres flags de rétention pour le snapshot élagué : --syncmode=full --history.transactions=600000 --history.blocks=600000 --history.logs=600000 --tries-verify-mode=local. Avec des blocs de 0,45 seconde, 600 000 blocs représentent environ 3,1 jours d’historique. Le README précise aussi que l’ancien flag --pruneancient est déprécié. Choisissez la rétention qui correspond à la profondeur d’historique dont votre application a besoin. TimeoutStopSec=600 donne au nœud dix minutes pour vider ses tampons à l’arrêt : des arrêts brutaux finissent tôt ou tard par corrompre la base de données.

6. Démarrer et vérifier

Terminal window
sudo systemctl daemon-reload
sudo systemctl enable --now bsc
journalctl -fu bsc

Une sortie saine est un flux régulier de lignes « Imported new chain segment ». Comparez votre hauteur avec celle d’un explorateur public :

Terminal window
curl -s -X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
http://127.0.0.1:8545

Convertissez le résultat hexadécimal et vérifiez-le sur bscscan.com. Quand eth_syncing renvoie false et que la hauteur correspond, le nœud est en service.

Comment sécuriser un nœud RPC BSC ?

L’unité ci-dessus lie le RPC à 127.0.0.1, ce qui convient à un nœud que seuls des logiciels locaux utilisent. Si d’autres machines ont besoin d’y accéder, n’exposez pas le port 8545 tel quel sur internet. Placez nginx ou Caddy devant, avec TLS, un jeton d’authentification ou une liste d’IP autorisées, et une limitation de débit. Gardez --http.api sur eth,net,web3 : n’exposez jamais admin, debug ou txpool sur un nœud accessible. Un port RPC ouvert attire les abus, et des appels eth_getLogs sans restriction sur de larges plages de blocs peuvent surcharger même un matériel puissant. Le port P2P 30311 reste le seul port blockchain ouvert.

Une différence avec Ethereum : il n’y a ici ni engine API ni secret JWT, car Parlia n’a pas besoin de client de consensus séparé. Le pare-feu et la liaison à localhost forment tout le périmètre, ils doivent donc être corrects.

Comment surveiller un nœud BSC ?

Un nœud BSC tombe en panne d’une manière typique : le processus continue de tourner pendant que le nœud prend du retard sur la tête de la chaîne. Les contrôles de disponibilité au niveau du processus passent complètement à côté. Vérifiez donc l’état de synchronisation et la hauteur.

Terminal window
# false = at the head; a sync object = still catching up
curl -s -X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' \
http://127.0.0.1:8545
# peer count as hex
curl -s -X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' \
http://127.0.0.1:8545

Le contrôle le plus strict compare votre eth_blockNumber à une seconde source, un endpoint public ou un explorateur, toutes les quelques minutes, et alerte quand l’écart grandit. Calibrez le seuil sur le rythme de BSC : 400 blocs semblent beaucoup et représentent trois minutes de temps de chaîne à 0,45 seconde par bloc. Des seuils copiés des outils Ethereum sont ici bien trop laxistes.

Le fork hérite de la pile de métriques de Geth. Démarrez avec --metrics (endpoint Prometheus sur le port 6060, à garder sur localhost) et les tableaux de bord Grafana standard de Geth fonctionnent en grande partie sans modification. Avant tout tableau de bord, fixez deux alertes : utilisation du disque au-dessus de 85 %, et hauteur de bloc locale figée pendant cinq minutes. Un journalctl -u bsc --since -24h | grep -ci error quotidien dans un mail cron complète le dispositif : un nombre d’erreurs en hausse précède la plupart des pannes de plusieurs jours.

Combien de temps dure la synchronisation d’un nœud BSC ?

De l’arithmétique plutôt que des promesses : le snapshot élagué de 1,9 To, à 100 Mo/s soutenus, met environ 5,3 heures à se télécharger, et environ 10,5 heures à 50 Mo/s. L’extraction est limitée par le disque et ajoute quelques heures sur du NVMe. Le snapshot a de quelques jours à quelques semaines de retard sur la tête de la chaîne, selon le moment où vous démarrez, et un nœud sain importe plusieurs fois plus vite que le temps réel. Au total, prévoyez une journée de travail.

La synchronisation depuis la genèse, en comparaison, exige un matériel bien plus puissant et un temps très long. C’est pourquoi la recommandation officielle est le snapshot.

À quelle vitesse un nœud BSC grossit-il, et comment l’élaguer ?

La base de données continue de croître après le premier jour : l’état avec chaque nouveau contrat et chaque nouveau compte, les données de bloc au rythme que dictent des blocs de 0,45 seconde. La croissance exacte dépend de l’activité du réseau. Plutôt que de vous fier à un chiffre fixe, exécutez du -sh /var/lib/bsc/geth/chaindata chaque semaine et construisez votre propre courbe de tendance. Attendez-vous à des centaines de Go par trimestre, pas par an.

Trois outils maintiennent la taille sous contrôle. geth-bsc snapshot prune-state est l’élagage hors ligne intégré : il supprime les nœuds d’état que plus rien ne référence, prend de nombreuses heures sur une base de plusieurs téraoctets, et le nœud ne sert rien pendant ce temps. L’alternative que beaucoup d’opérateurs préfèrent est de tout effacer puis de restaurer : tous les quelques mois, supprimer le datadir et restaurer le dernier snapshot élagué. L’arrêt total est souvent plus court qu’avec l’élagage, et vous obtenez en prime une base de données fraîchement compactée.

Le troisième outil est le snapshot incrémental, spécifié dans le BEP-593. Au lieu de retélécharger tout le snapshot élagué à chaque rafraîchissement, vous fusionnez de petits snapshots incrémentaux sur un snapshot de base mensuel. Le texte du BEP compare un snapshot incrémental mensuel d’environ 120 Go à un snapshot prune-ancient de plus de 1,0 To. Vérifiez dans le README de bsc-snapshots si les fichiers incrémentaux sont actuellement publiés avant de planifier autour d’eux.

Qu’est devenu Erigon sur BSC ?

bsc-erigon, le portage d’Erigon par NodeReal, a été pendant des années le client d’archive. Son README porte désormais un avis de fin de vie : le développement et la maintenance se sont arrêtés fin 2025, et le dépôt est archivé. L’avis oriente les opérateurs vers Reth-BSC, le successeur basé sur Rust maintenu par bnb-chain.

Au 5 novembre 2026, le README de bsc-snapshots liste des snapshots Reth-BSC à côté de ceux de geth. Le snapshot archive du mainnet du 2 novembre 2026 pèse 7 789,76 Go, le snapshot de full node 3 621,42 Go et celui de fast node 840,42 Go.

Pour le nœud RPC élagué de ce guide, le fork geth officiel reste la référence. Pour les charges d’archive, évaluez d’abord Reth-BSC. Considérez toute machine bsc-erigon restante comme une migration en attente : un client non maintenu rate le prochain hard fork.

Combien coûte un nœud BSC ?

Voyez ceci comme une méthode de calcul, pas comme une grille tarifaire. La classe 16 cœurs / 64 Go / 4 To NVMe relève des serveurs dédiés, et aucun palier de VPS ordinaire ne la couvre. Demandez un devis à deux ou trois hébergeurs de serveurs dédiés avec ces spécifications. Une configuration cloud avec 8k IOPS provisionnées (la référence AWS du README) facture les IOPS séparément : chiffrez donc explicitement cette ligne.

Ajoutez ensuite vos heures. Prévoyez une journée de travail pour l’installation initiale avec ce guide, plus quelques heures par mois pour les mises à niveau lors des hard forks et les rafraîchissements de snapshot. Multipliez par votre taux horaire et placez le résultat à côté du devis d’hébergement.

Comment garder un nœud BSC à jour ?

BSC effectue des hard forks à un rythme qui surprend les opérateurs Ethereum. La seule année 2025 a apporté Lorentz (29 avril) et Maxwell (30 juin), qui ont ramené l’intervalle des blocs à 1,5 puis à 0,75 seconde. Fermi a suivi le 14 janvier 2026 et a fait passer les blocs de 0,75 à 0,45 seconde. Chaque fork a une version client minimale. Pour Fermi, c’était v1.6.4, et un nœud en dessous se bloque au bloc du fork. La dernière version au 5 novembre 2026 est v1.8.2, et les snapshots actuels exigent au moins v1.7.2.

Abonnez-vous donc au flux de releases de bnb-chain/bsc sur GitHub et traitez les mises à niveau comme une routine, pas comme un événement. La procédure est courte : télécharger le nouveau geth_linux, le vérifier, arrêter le service, remplacer /usr/local/bin/geth-bsc, redémarrer. La base de données est conservée. Les notes de version signalent les changements de configuration, et BSC renomme les flags plus souvent que Geth upstream : parcourez-les avant le redémarrage, pas après. Prévoyez un quart d’heure par release et attendez-vous à un fork tous les quelques mois.

Pour les environnements de développement, un réseau privé local est disponible avec le toolkit BSC-Deploy, sans faire tourner de nœuds mainnet.

Dépannage

Le nœud importe des blocs mais continue de prendre du retard sur la tête de la chaîne

Presque toujours les IOPS du disque. Mesurez avec fio et comparez à la référence de 8k IOPS ; un stockage en réseau aux IOPS par défaut est le coupable habituel. Confirmez que --tries-verify-mode none est défini. Si le matériel est en dessous du tableau des prérequis, aucun flag ne comblera l’écart.

Erreurs « missing trie node », ou le nœud recommence à synchroniser depuis le bloc 0 après une restauration de snapshot

La disposition du datadir est incorrecte. La base de données de la chaîne doit se trouver dans <datadir>/geth/chaindata. Si le journal affiche « Writing custom genesis block », geth a trouvé un datadir vide et a recommencé de zéro. Arrêtez le service, déplacez le dossier geth extrait au bon endroit, redémarrez.

Le nombre de pairs reste proche de zéro

Vérifiez que le port 30311 est ouvert et redirigé. Un config.toml périmé est le deuxième suspect : les listes de bootstrap et de nœuds statiques changent avec le temps, retéléchargez donc mainnet.zip depuis la dernière release. Sur une connexion domestique, vérifiez aussi le NAT.

lz4 signale une « Decoding error » pendant l’extraction

L’archive est incomplète. Reprenez le téléchargement avec aria2c -c et comparez la taille du fichier à celle de la page du snapshot avant de décompresser à nouveau. N’oubliez pas que l’option A exige de la place libre pour l’archive et pour les données extraites en même temps.

L’OOM killer arrête le nœud

journalctl -k | grep -i oom tranche la question. L’unité définit --cache 8000, et l’utilisation réelle de la mémoire dépasse largement la valeur du cache pendant le rattrapage : cela passe avec les 64 Go recommandés, pas sur un matériel réduit. Réduisez --cache avant tout autre réglage, gardez le swap activé comme tampon anti-crash, et rappelez-vous qu’un nœud tué par l’OOM ne vide rien : le prochain démarrage peut vous renvoyer le cas « missing trie node » ci-dessus.

Le disque se remplit

df -h d’abord, puis du -h --max-depth=2 /var/lib/bsc pour repérer la croissance. Les archives de snapshot oubliées sont la trouvaille la plus fréquente : le seul .tar.lz4 élagué pèse environ 1,9 To, et l’option A le laisse en place si vous sautez le nettoyage. Si chaindata lui-même est le problème, rafraîchissez depuis le dernier snapshot élagué ou lancez un élagage hors ligne (voir la section sur la croissance de l’état). Avec la courbe de croissance de BSC, un disque plein est un échec de planification, pas de la malchance ; l’alerte à 85 % de la section sur la surveillance existe pour vous donner la semaine dont vous avez besoin.

Faut-il faire tourner son propre nœud ou utiliser une API ?

Chaingateway vend l’alternative : voici donc la comparaison, avec ses points faibles.

Faites tourner le nœud quand vous consommez du JSON-RPC brut à un volume élevé et soutenu (indexation, backtesting, scan de logs sur des millions de blocs), ou quand aucun tiers ne doit se trouver entre vous et la chaîne. Un serveur dédié est un coût fixe sans facturation par requête, et à fort volume d’appels il peut battre un plan facturé à l’usage.

Utilisez une API quand le nœud ne servirait que de tuyauterie pour des paiements. Un full node BSC synchronisé vous donne eth_sendRawTransaction et des logs. Tout ce dont un système de paiement a réellement besoin (adresses de dépôt par client, détection des transferts BEP-20 entrants, webhooks signés, stockage des clés, nouvelles tentatives) est un logiciel que vous devriez construire par-dessus et maintenir en fonctionnement. Comptez ces heures d’ingénierie dans la comparaison, au taux de la section sur les coûts.

L’API BNB Smart Chain de Chaingateway couvre cette couche en REST : importer des adresses (POST /api/v2/bsc/addresses/import), envoyer des tokens BEP-20 (POST /api/v2/bsc/transactions/bep20) et recevoir des webhooks de dépôt. Les webhooks portent un en-tête HMAC X-Signature dès que vous définissez un secret personnel (guide de vérification). Les livraisons échouées ne sont pas renvoyées automatiquement : GET /api/v2/bsc/webhooks/notifications/failed les liste, et chacune peut être renvoyée via l’endpoint de nouvelle tentative. Le seuil de rentabilité en une ligne : un serveur dédié plus vos heures de construction et d’exploitation, contre un plan sur /pricing/. Le quickstart et le guide des webhooks vous amènent à un premier test en quelques minutes, et l’essai de 7 jours ne demande aucun KYC (inscription).

Vous faites aussi tourner d’autres chaînes ? Consultez les guides d’installation pour Ethereum et TRON.

Questions fréquentes

Oui. La chaîne a été renommée de Binance Smart Chain en BNB Smart Chain en février 2022. La documentation, les binaires et ce guide décrivent le même réseau ; seule la marque a changé.

Le snapshot élagué officiel pèse environ 1,9 To compressé et le snapshot complet environ 7,4 To (bsc-snapshots, snapshot du 9 octobre 2026, vérifié le 5 novembre 2026). L’extraction exige l’archive et les données extraites sur le disque en même temps : un disque NVMe de 4 To est donc la taille réaliste.

Non. BSC utilise le consensus Parlia et ses propres règles de protocole ; seul le fork sur github.com/bnb-chain/bsc peut le synchroniser. Le nom de binaire identique crée cette confusion, d’où le renommage en geth-bsc à l’étape 2.

Pratiquement pas. Le code du client léger existe dans le fork, mais le réseau ne sert presque pas de pairs légers. Vos options réalistes sont un full node élagué, un fast node ou une API.

Non. Les récompenses de bloc vont à l’ensemble de validateurs élus, ce qui exige beaucoup de BNB stakés et des votes de la communauté. Un full node vous donne un accès indépendant à la chaîne, pas un revenu.

Comment nous rédigeons ces articles

Prêt à le construire vous-même ? Obtenir votre clé API — essai de 7 jours, sans carte bancaire — ou consultez API Binance Smart Chain pour la référence complète des endpoints.

C
Chaingateway Team
Experts blockchain

L'équipe Chaingateway s'attache à simplifier l'intégration blockchain pour les développeurs du monde entier.