API d’explorateur Solana : quoi appeler quand vous voulez les données, pas la page

Tout explorateur Solana est une interface posée sur une API. Quand vous recherchez une signature sur Solscan ou Solana Explorer, le site appelle l’interface JSON-RPC de Solana, souvent via son propre indexeur, puis met en forme le résultat. Quand on cherche une API d’explorateur Solana, on veut donc généralement l’une de ces trois choses : des données on-chain brutes récupérables gratuitement, une API indexée plus riche avec étiquettes et historique, ou des données de marché comme les prix et les paires de trading. Ce guide compare les trois en septembre 2026, avec du code fonctionnel et les limites que nous avons mesurées nous-mêmes.

Les options d’API d’explorateur Solana en un coup d’œil

En résumé : JSON-RPC pour les données brutes, un indexeur pour l’historique et le parsing, des API de marché pour les prix. Le tableau reprend les options que nous avons testées pour l’outil de recherche en direct de Solscanner.

Fournisseur	Clé requise	Idéal pour	Limites
api.mainnet-beta.solana.com	Non	Tests, scripts légers	100 req / 10 s par IP
solana-rpc.publicnode.com	Non	Tx, signatures, soldes, blocs	Pas d’appels tokens indexés
public.rpc.solanavibestation.com	Non	Comptes de tokens, détenteurs, offre	Débit limité
Solscan Pro API	Oui	Étiquettes, transferts, tokens	Lite : 49 $/mois, 20M CU
Helius	Oui	Historique parsé, DAS, archives	Gratuit : 1M crédits, 10 req/s
Jupiter lite-api	Non	Prix et métadonnées de tokens	Débit limité
DexScreener	Non	Paires DEX, liquidité	60–300 req/min

Quelques autres résultats de nos tests, pour vous éviter de perdre un après-midi. L’accès anonyme de Tatum n’autorisait que 5 requêtes par minute, et de nombreuses méthodes étaient payantes. Ankr exigeait une clé. L’offre gratuite de dRPC n’incluait pas Solana. BlockEden était uniquement payant. Les API publiques de SolanaFM et de Solana Beach renvoyaient des erreurs HTTP 502 pendant nos vérifications.

Les méthodes JSON-RPC de base qu’utilise chaque explorateur

Quatre méthodes couvrent l’essentiel de ce qu’affiche une page d’explorateur. Chacune prend un corps JSON avec jsonrpc, id, method et params, envoyé en POST à n’importe quel endpoint RPC.

• getSignaturesForAddress renvoie les signatures des transactions ayant touché une adresse, de la plus récente à la plus ancienne. Chaque entrée comprend signature, slot, err (null en cas de succès), memo, blockTime et confirmationStatus. limit va de 1 à 1 000, avec 1 000 par défaut. C’est la liste « historique » d’une page de portefeuille.
• getTransaction renvoie la transaction complète pour une signature : instructions, comptes, frais, compute units consommées, logs et soldes avant/après. Passez "maxSupportedTransactionVersion": 0, sinon les transactions versionnées échoueront.
• getBalance renvoie le solde SOL d’un compte en lamports (1 SOL = 1 000 000 000 lamports).
• getTokenAccountsByOwner renvoie les comptes de tokens SPL détenus par un portefeuille, filtrés par mint ou par programme de token (SPL Token historique ou Token-2022). Utilisez l’encodage jsonParsed pour obtenir des soldes lisibles.

Ce sont les briques des vues explorateur de portefeuilles et explorateur de transactions. Les listes de détenteurs, l’offre d’un token et l’analyse des comptes détenus par un programme reposent sur des méthodes plus lourdes comme getTokenLargestAccounts, getSupply et getProgramAccounts, que beaucoup de nœuds publics considèrent comme des requêtes « indexées » et bloquent.

Exemple getSignaturesForAddress : fetch et curl

Voici un exemple minimal, pour navigateur ou Node 18+, qui liste les 25 dernières signatures d’une adresse. Il utilise le mint USDC comme adresse d’exemple, mais n’importe quel portefeuille ou programme fonctionne.

const RPC = 'https://solana-rpc.publicnode.com';
const address = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

const res = await fetch(RPC, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getSignaturesForAddress',
    params: [address, { limit: 25, commitment: 'confirmed' }],
  }),
});
const { result, error } = await res.json();
if (error) throw new Error(`${error.code}: ${error.message}`);
for (const s of result) {
  console.log(s.signature, s.slot, s.err ? 'failed' : 'ok', s.blockTime);
}

Le même appel depuis un terminal :

curl -s https://solana-rpc.publicnode.com \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSignaturesForAddress",
       "params":["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",{"limit":5}]}'

Pour récupérer l’une de ces transactions, remplacez la méthode par getTransaction et passez [signature, { "encoding": "jsonParsed", "maxSupportedTransactionVersion": 0 }]. blockTime est un horodatage Unix en secondes et peut valoir null pour des données très anciennes ou élaguées.

Pagination avec before et until

getSignaturesForAddress pagine en remontant le temps. Passez before avec la dernière signature de la page précédente pour obtenir la page suivante, plus ancienne ; passez until pour vous arrêter dès qu’une signature connue est atteinte. Un tableau vide signifie que vous avez atteint la fin de l’historique conservé par le nœud.

async function allSignatures(address, max = 5000) {
  const out = [];
  let before;
  while (out.length < max) {
    const params = [address, { limit: 1000, ...(before && { before }) }];
    const page = await rpc('getSignaturesForAddress', params); // votre fonction utilitaire POST
    if (!page.length) break;
    out.push(...page);
    before = page[page.length - 1].signature;
  }
  return out;
}

Pour une synchronisation incrémentale, stockez la signature la plus récente que vous avez vue et passez-la comme until la fois suivante. Vous ne récupérez alors que les nouveautés, ce qui vous maintient largement sous les limites publiques.

Niveaux de commitment : processed, confirmed, finalized

Le commitment indique au nœud à quel point un bloc doit être consolidé avant qu’il réponde. La documentation RPC officielle définit trois niveaux, et finalized est la valeur par défaut habituelle.

• processed : le dernier bloc du nœud. Le plus rapide, mais il peut encore être annulé.
• confirmed : voté par une supermajorité, soit plus des deux tiers du stake actif.
• finalized : verrouillage maximal ; la garantie la plus forte.

getSignaturesForAddress n’accepte que confirmed ou finalized. Pour des pages de type explorateur, confirmed est le compromis courant : une nouvelle signature apparaît en quelques slots (environ 250 à 300 ms par slot depuis les réductions d’août-septembre 2026), et les annulations à ce niveau sont très rares. Pour tout ce qui déplace de l’argent ou met à jour une base de référence, attendez finalized.

Bonnes pratiques de débit sur les endpoints publics

Les endpoints publics sont partagés : comportez-vous en invité poli. Les endpoints officiels mainnet, devnet et testnet autorisent 100 requêtes par 10 secondes et par IP, 40 par 10 secondes pour une même méthode et 40 connexions simultanées, et ne sont explicitement pas destinés à la production.

Les règles pratiques que nous appliquons dans le client de Solscanner (rpc.ts) :

1. Faites tourner, ne martelez pas. Notre outil de recherche gère deux groupes. Les appels « légers » (transactions, signatures, soldes, blocs, époque) partent d’abord vers publicnode, puis Solana Vibe Station, puis l’endpoint officiel. Les appels indexés « lourds » (getTokenAccountsByOwner, getTokenLargestAccounts, getSupply, getProgramAccounts, getTokenSupply) partent d’abord vers Solana Vibe Station. Le devnet et le testnet utilisent les endpoints officiels.
2. Traitez les erreurs de limite comme un « essayez ailleurs ». Les codes -32005, 429 et 403, ou les messages qui parlent de limites ou de forfaits, font passer la requête à l’endpoint suivant au lieu d’échouer.
3. Retenez ce qui a marché. Le dernier endpoint qui a répondu devient le premier choix la fois suivante.
4. Fixez un délai. Chaque requête est abandonnée au bout de 14 secondes pour qu’un nœud lent ne fige pas la page.
5. Mettez en cache et regroupez. Ne rechargez pas les transactions finalisées : elles ne changent jamais.

Pour les données de marché, nous appelons le lite-api.jup.ag de Jupiter, sans clé, pour les prix et métadonnées des tokens (jusqu’à 100 mints par requête dans notre client), CoinGecko en secours pour le prix du SOL, et DexScreener pour les paires de trading. DexScreener documente 60 requêtes par minute pour les endpoints de profil de token et 300 par minute pour les endpoints de paires dans sa référence d’API. Notre guide des explorateurs DeFi explique ce que signifient ces chiffres de paires.

Solscan Pro API, Helius et autres API d’explorateurs payantes

Une API payante se justifie quand vous avez besoin de données indexées que le RPC simple ne fournit pas à bas coût : transferts étiquetés, classements de détenteurs, activité DeFi décodée, ou des années d’historique en une seule requête.

Solscan Pro API. Solscan, propriété d’Etherscan depuis janvier 2024, expose ses données indexées (comptes, transferts, tokens, NFT, marchés) via la Pro API. Il existe une offre gratuite ; le forfait Lite coûte 49 $ par mois avec 20 millions de compute units et 1 000 requêtes par 60 secondes, et exclut les multi-endpoints, Market/price-ohlcv, Account/metadata et Account/funded_by. Des paliers supérieurs existent, mais nous n’avons pas pu vérifier leurs tarifs actuels : consultez vous-même la page de prix de Solscan. Les forfaits API ne sont pas remboursables.

Helius. Helius, l’équipe derrière l’explorateur Orb, propose un forfait gratuit avec clé d’API : 1 million de crédits par mois et 10 requêtes RPC par seconde au moment où nous écrivons. Ses API enrichies renvoient des transactions parsées et lisibles, et Orb lui-même s’appuie sur les données d’archives de Helius et la méthode getTransactionsForAddress.

API Solana Beach. Solana Beach publie une documentation sur solanabeach.io/docs et un dépôt GitHub, centrés sur les validateurs et le staking. Elle a renvoyé des erreurs 502 lors de nos tests : vérifiez son statut au préalable.

Erreurs courantes de l’API Solana et leur signification

La plupart des échecs d’API relèvent de quelques schémas, et le corps de l’erreur indique généralement lequel. Lisez error.code et error.message avant de relancer quoi que ce soit.

HTTP 403 ou 429. L’endpoint bloque ou limite votre IP. Ralentissez, passez à un autre endpoint ou prenez un forfait avec clé. L’endpoint mainnet officiel nous a renvoyé une 403 depuis une IP de data center, ce qui est fréquent pour les adresses cloud partagées.

Erreur -32005 ou messages évoquant un « plan ». Le fournisseur ne sert pas cette méthode sur votre palier. Les appels indexés comme getTokenAccountsByOwner en sont les victimes habituelles sur les nœuds gratuits.

Erreurs CORS dans la console du navigateur. L’endpoint répond depuis curl mais refuse les requêtes d’une page web. Tous les endpoints sans clé de notre tableau acceptaient les requêtes navigateur en septembre 2026, ce qui permet à un site statique comme Solscanner de faire tourner son outil de recherche sans back-end. Si vous ajoutez un fournisseur qui exige une clé, appelez-le depuis un serveur pour que la clé ne soit jamais envoyée aux utilisateurs.

Un résultat null. Pour getTransaction, null signifie généralement que ce nœud ne connaît pas la signature : mauvais cluster, niveau de commitment pas encore atteint, ou signature hors de l’historique du nœud. Notre client peut relancer ces appels sur l’endpoint suivant avant d’afficher « introuvable ».

Quand faut-il un indexeur plutôt que le RPC ?

Il vous faut un indexeur dès que votre question porte sur de nombreux comptes ou de longues périodes. Le RPC répond bien à « quel est l’état de ce compte maintenant ? » et « qu’a fait cette transaction ? ». Il répond mal à « tous les transferts d’USDC de ce portefeuille depuis 2023, avec leur valeur en USD », car il faudrait parcourir des milliers de signatures et analyser chacune.

Les signes que vous avez dépassé le RPC brut :

• Vous appelez getTransaction des centaines de fois par affichage de page.
• Vous avez besoin du nombre ou du classement des détenteurs d’un token (les nœuds publics bloquent souvent getTokenLargestAccounts et getProgramAccounts).
• Vous avez besoin d’étiquettes lisibles (exchanges, programmes, portefeuilles connus) ou de prix historiques en USD.
• Vous avez besoin d’un historique plus ancien que ce que conserve votre nœud.

À ce stade, Helius, Solscan Pro ou votre propre indexeur (un plugin Geyser qui alimente une base de données) sont vite rentabilisés. Si vous en êtes encore au prototype, testez d’abord sur les endpoints devnet, et lisez le guide de l’explorateur de programmes pour décoder des instructions à l’aide d’un IDL. Pour une comparaison côté utilisateur des explorateurs bâtis sur ces API, consultez notre classement des meilleurs explorateurs Solana.