Quicknode

17 février 2026 — 11 min de lecture

Quicknode prend désormais en charge l'accès « pay-per-request » x402, offrant ainsi aux développeurs et aux agents IA un accès instantané, authentifié via leur portefeuille, aux points de terminaison blockchain sur plus de 130 réseaux. Cela inclut les interfaces RPC, WebSocket, REST et gRPC. Payez en USDC sur Base, Solana ou Polygon et commencez à effectuer des appels en quelques minutes.

x402 est une méthode d'accès complémentaire qui vient compléter les formules existantes de Quicknode. Les équipes gérant des charges de travail en production bénéficient des formules standard de Quicknode, qui incluent des accords de niveau de service (SLA), une assistance dédiée et une facturation au crédit. x402 offre une nouvelle option pour les cas d'utilisation où la priorité est donnée à un accès léger et sans autorisation préalable.

Cet article explique ce qu'est x402, comment il fonctionne avec Quicknode, ce que vous pouvez créer grâce à lui et comment vous lancer.

Qu'est-ce que le x402 ?

x402 est un protocole de paiement ouvert développé par Coinbase qui intègre les paiements de manière native au protocole HTTP. Il réutilise le code d'état HTTP 402 « Paiement requis », longtemps resté inutilisé, et le transforme en une couche de paiement fonctionnelle pour Internet.

Le principe est simple : lorsqu'un client envoie une requête à un point de terminaison compatible x402 sans paiement, le serveur répond par un statut 402 et fournit des instructions de paiement (prix, jetons acceptés, réseau et adresse de portefeuille). Le client signe une autorisation de paiement en USDC, l'ajoute à l'en-tête de la requête, puis réessaie. Le serveur vérifie le paiement via un facilitateur, le règle sur la blockchain et renvoie les données demandées.

Cela revêt une importance particulière pour les agents IA. Les systèmes de paiement traditionnels nécessitent des inscriptions, une gestion des identifiants et des cycles de facturation gérés par des humains. La norme x402 élimine tout cela. Un agent disposant d’un portefeuille peut découvrir, payer et utiliser de manière autonome des services API sans aucune intervention humaine.

Pourquoi Quicknode prend en charge la norme x402 ?

Quicknode fournit une infrastructure blockchain aux développeurs et aux entreprises sur plus de 80 chaînes et plus de 130 réseaux. Pour accéder à cette infrastructure, il faut généralement créer un compte et gérer des clés API, ce qui convient parfaitement aux équipes qui développent des applications en production.

x402 offre une voie d'accès complémentaire à une catégorie d'utilisateurs en pleine expansion : les agents d'IA, les créateurs de prototypes rapides et les développeurs qui souhaitent tester une idée avant de s'engager dans un projet. Lorsque x402 est activé sur les terminaux Quicknode, toute personne (ou tout système) disposant d'un portefeuille peut :

• Accédez aux points de terminaison RPC, WebSocket, REST et gRPC sur plus de 130 réseaux blockchain

• Paiement à la demande avec USDC via un modèle de crédit à prélèvement progressif. Approvisionnez votre solde une seule fois : chaque demande est automatiquement débitée de vos crédits, ce qui évite tout délai de paiement à chaque appel.

• Authentification via un portefeuille (Sign-In with X / SIWx), prenant en charge à la fois les portefeuilles EVM et Solana

• Commencez avec jusqu’à 10 000 requêtes gratuites grâce à devnet USDC

Le réseau de paiement est dissocié des points de terminaison que vous interrogez. Cela signifie que vous pouvez payer en USDC sur Base et effectuer des appels vers Solana, ou payer en USDC sur Solana et interroger Ethereum, ou encore payer en USDC sur Polygon. La chaîne sur laquelle vous effectuez le paiement n'a pas besoin de correspondre à celle que vous interrogez.

x402 vs formules Quicknode standard

x402 est un service complémentaire. Il ne remplace pas les formules standard de Quicknode. Les équipes gérant des charges de travail de production doivent continuer à utiliser les formules SLA standard, l'assistance dédiée et les limites de débit plus élevées.

Réseaux de paiement pris en charge

L'implémentation x402 de Quicknode prend actuellement en charge les paiements en USDC sur :

• Base (réseau principal et réseau de test Sepolia)

• Solana (réseau principal et réseau de développement)

• Polygon (réseau principal et réseau de test Amoy)

D'autres réseaux de paiement sont actuellement ajoutés. Le protocole x402 est, par conception, indépendant de toute blockchain ; l'extension de sa prise en charge est donc aisée à mesure que de nouveaux facilitateurs se connectent.

À des fins de test, les développeurs peuvent utiliser le réseau de développement USDC sur Base Sepolia, le réseau de développement Solana ou Polygon Amoy pour effectuer jusqu’à 10 000 requêtes gratuites vers n’importe quel point de terminaison de production de Quicknode.

Fonctionnement : le déroulement technique

Voici ce qui se passe en arrière-plan lorsqu'un agent ou un développeur envoie une requête compatible x402 à Quicknode :

1. Requête initiale : le client envoie une requête HTTP au point de terminaison Quicknode x402 sans en-têtes de paiement.

2. Réponse 402 : Le serveur renvoie un code HTTP 402 accompagné d'un en-tête PAYMENT-REQUIRED contenant les détails du paiement : le prix par requête, les jetons acceptés (USDC), les réseaux pris en charge (Base, Solana, Polygon) et l'adresse du portefeuille vers laquelle effectuer le paiement.

3. Authentification via le portefeuille : le client s'authentifie à l'aide de SIWx (Sign-In with X). L'implémentation de Quicknode utilise SIWx pour émettre des jetons JWT, optimisant ainsi les performances en évitant la surcharge liée à la vérification de la signature à chaque requête (ce qui ajouterait 10 à 20 ms par appel).

4. Autorisation de paiement : le client signe une autorisation de transfert USDC à l'aide de la norme EIP-3009 (pour EVM) ou d'une méthode de signature Solana équivalente. Il s'agit d'une opération sans frais de gaz pour le client.

5. Nouvelle tentative de paiement : le client réitère la requête initiale en incluant le paiement signé dans l'en-tête X-PAYMENT.

6. Vérification et règlement : le facilitateur vérifie l'autorisation signée, effectue le transfert d'USDC sur la blockchain et confirme le paiement.

7. Réponse : Quicknode renvoie les données demandées.

Les bibliothèques client x402 gèrent automatiquement les étapes 2 à 6. Du point de vue du développeur, le code ressemble à une requête HTTP standard.

Ce que vous pouvez créer

Agents IA dotés d'un accès autonome à la blockchain

Le cas d'utilisation le plus immédiat consiste à permettre à des agents IA d'interagir avec des données de blockchain sans clés API préconfigurées. Un agent peut :

• Consulter les cours des jetons et les soldes des portefeuilles sur différentes chaînes

• Suivre l'activité du portefeuille et l'historique des transactions

• Effectuer des lectures sur la blockchain pour les protocoles DeFi

• Accéder aux données historiques par bloc à des fins d'analyse

Tout cela sans qu'un utilisateur ait à créer un compte au préalable.

Serveur MCP pour la gestion des infrastructures assistée par l'IA

Le serveur MCP officiel de Quicknode (@quicknode/mcp) intègre directement la gestion de l'infrastructure blockchain dans des assistants IA tels que Claude et Cursor. Grâce au serveur MCP, un assistant IA peut déployer et configurer des points de terminaison Quicknode sur plusieurs réseaux, surveiller l'utilisation et la facturation, et gérer l'infrastructure via le langage naturel. Cette solution s'associe parfaitement à x402 : utilisez le serveur MCP pour provisionner et gérer votre infrastructure Quicknode, et utilisez x402 pour un accès léger aux points de terminaison, authentifié via un portefeuille.

Installation via npx :

npx -y @quicknode/mcp

Consultez le package sur npm : npmjs.com/package/@quicknode/mcp

Compétences en blockchain pour les agents de programmation IA

Quicknode propose également « Blockchain Skills », un ensemble de références léger qui fournit aux agents de codage IA des connaissances précises et à jour sur l'ensemble de la gamme de produits Quicknode. Une simple commande suffit pour l'ajouter à Claude Code, Cursor, Codex, Windsurf ou à tout autre agent compatible avec les compétences :

npx skills add quicknode-labs/blockchain-skills

Avec environ 240 tokens, il fournit à votre agent les points de terminaison appropriés, les paramètres corrects et les meilleures pratiques actuelles, sans surcharger la fenêtre de contexte. Entièrement open source sur github.com/quicknode-labs/blockchain-skills. Découvrez-le dans le registre des compétences à l'adresse skills.sh/quicknode-labs/blockchain-skills.

Développement et prototypage à la demande

Les développeurs qui souhaitent tester une idée sur plusieurs chaînes peuvent utiliser x402 pour accéder à n'importe quel réseau pris en charge par Quicknode sans s'engager dans un forfait. Créez un prototype, payez quelques centimes en USDC pour les appels RPC que vous effectuez réellement, puis passez à autre chose.

L'API d'administration de Quicknode offre un contrôle programmatique complet sur la configuration de votre compte et de votre infrastructure, permettant ainsi aux agents et aux développeurs de créer des points de terminaison, de gérer la sécurité et de surveiller l'utilisation via de simples appels REST.

HyperCore CLI avec x402

L'outil CLI open source HyperCore de Quicknode prend également en charge l'accès x402 avec facturation à la requête. Les développeurs peuvent récupérer en flux continu et rétrospectivement des ensembles de données Hyperliquid (transactions, ordres, exécutions, TWAP, mises à jour du carnet d'ordres, événements, blocs) directement depuis le terminal, en payant à la requête via un portefeuille, sans avoir besoin d'un compte Quicknode.

Installez-le globalement :

npm install -g @quicknode/hypercore-cli

L'interface CLI prend en charge la diffusion en temps réel via WebSocket et gRPC, la reconnexion automatique avec récupération des données manquantes, le remplissage historique des données, ainsi que l'exportation au format JSON, CSV ou SQLite.

Monétisation du contenu et des API

Outre l'utilisation de services compatibles x402, les développeurs peuvent également créer leurs propres API basées sur x402 à l'aide des outils open source de Quicknode :

• x402-rails: Un gem Ruby permettant d'ajouter des systèmes d'accès payant x402 aux applications Rails

• x402-payments: Une gem Ruby permettant de générer des en-têtes de paiement signés

• qn-x402-exemples: Exemples d'implémentations pour les flux de paiement EVM et Solana

Les paquets npm @quicknode/x402 et @quicknode/x402-solana

Le @quicknode/x402 Le package npm constitue la méthode recommandée pour interagir avec la passerelle x402 de Quicknode. Il regroupe l'ensemble du processus d'authentification et de paiement en une seule installation : authentification via le portefeuille SIWX, gestion de session JWT et traitement des paiements x402.

Auparavant, l'intégration avec x402 sur Quicknode nécessitait de gérer manuellement la signature SIWX, le cycle de vie du jeton JWT et la construction de l'en-tête de paiement. Ce package se charge de tout cela. Les agents et les développeurs peuvent installer le package, connecter un portefeuille et commencer à effectuer des requêtes authentifiées et payantes en quelques minutes.

npm i @quicknode/x402

Ce module prend en charge à la fois les portefeuilles EVM et Solana et fonctionne sur tous les réseaux de paiement pris en charge (Base, Solana, Polygon).

@quicknode/x402 sur npm : npmjs.com/package/@quicknode/x402

Source : github.com/quicknode-labs/quicknode-x402

À l'attention des utilisateurs de Solana : le @quicknode/x402-solana npm encapsule @quicknode-x402 et permet désormais d'utiliser Kit Solana grâce aux services RPC de Quicknode, et ce, en un clin d'œil.

@quicknode/x402-solana sur npm : npmjs.com/package/@quicknode/x402-solana

Source : github.com/quicknode-labs/x402-solana

L'API d'administration

L'API d'administration de Quicknode offre aux développeurs et aux agents un contrôle programmatique total sur les opérations liées aux comptes et à l'infrastructure, depuis la création de points de terminaison et la configuration de la sécurité jusqu'au suivi de l'utilisation et à la gestion des équipes, le tout via des appels REST standard. Associée à x402 et au serveur MCP, cette API permet à un agent non seulement d'interroger les données de la blockchain, mais aussi de provisionner et de gérer l'infrastructure dont elle dépend.

Démarrer

Prérequis

• Un portefeuille crypto (tout portefeuille compatible EVM ou portefeuille Solana)

• USDC sur Base, Polygon ou Solana (ou USDC sur le réseau de développement pour des tests gratuits)

• Node.js 18+ et le package @quicknode/x402 (npm i @quicknode/x402)

Guide de démarrage rapide avec Devnet USDC (gratuit)

À des fins de test, vous pouvez utiliser l'USDC du réseau de développement pour effectuer jusqu'à 10 000 requêtes gratuites :

1. Obtenez des USDC Base Sepolia grâce au « faucet » USDC de Circle

2. Ou bien, procurez-vous des USDC du réseau de développement Solana via le « faucet » Solana

3. Ou bien obtenez des Polygon Amoy USDC via le « faucet » Circle USDC

4. Suivez le guide de démarrage

Configuration de la production

Pour une utilisation en production avec de véritables USDC :

1. Rechargez votre portefeuille avec des USDC sur Base, Solana ou Polygon

2. Installez le paquet @quicknode/x402 (npm i @quicknode/x402)

3. Adressez vos requêtes au point de terminaison Quicknode x402

Le coût par requête est minime, ce qui rend cette solution viable aussi bien pour les charges de travail importantes des agents que pour les tests de développement.

Logiciel libre et écosystème

Quicknode a réalisé d'importants investissements dans l'écosystème x402, qui vont bien au-delà de la simple mise en place de paiements sur ses propres terminaux :

• x402 Explorer: une application d'exemple permettant de tester les flux de paiement x402

• Démonstration du système de accès payant pour les vidéos x402: Exemple illustrant comment mettre en place un système de paiement pour du contenu vidéo avec x402

• Intégration de x402 dans Rails: Guide pour l'ajout de x402 aux API Ruby on Rails

• Guide sur le système de accès payant x402: Un guide complet sur la mise en œuvre de la norme x402

• llms.txt: Documentation lisible par machine concernant la découvrabilité des LLM et des agents. Le protocole lui-même est open source et maintenu par Coinbase sur github.com/coinbase/x402

• Package @quicknode/x402 :

Foire aux questions

Qu'est-ce que « x402 » sur Quicknode ?

La fonctionnalité x402 sur Quicknode est une fonctionnalité en version alpha qui permet un accès aux points de terminaison Quicknode (RPC, WebSocket, REST et gRPC) authentifié via un portefeuille et facturé à la requête, en utilisant l'USDC. Elle utilise la norme HTTP 402 « Payment Required » et s'appuie sur le protocole ouvert x402 de Coinbase.

Le service x402 remplace-t-il les comptes ou les formules Quicknode ?

Le forfait n° x402 est complémentaire. Il offre une solution d'accès supplémentaire aux forfaits standard de Quicknode. Les équipes gérant des charges de travail en production doivent continuer à utiliser les forfaits standard pour bénéficier des SLA, d'une assistance dédiée et de limites de débit plus élevées. Le forfait x402 est conçu pour les agents d'IA, le prototypage rapide et l'accès sans autorisation.

Faut-il disposer d'un compte Quicknode pour utiliser x402 ?

L'accès au n° x402 s'effectue via l'authentification par portefeuille. Vous devez disposer d'un portefeuille crypto et d'USDC ; vous n'avez pas besoin d'un compte Quicknode ni d'une clé API.

Quels sont les réseaux de paiement pris en charge ?

Les paiements en USDC sont actuellement pris en charge sur Base (réseau principal et réseau de test Sepolia), Solana (réseau principal et réseau de développement) et Polygon (réseau principal et réseau de test Amoy). D'autres réseaux de paiement sont en cours d'ajout. Il n'est pas nécessaire que le réseau de paiement corresponde à la chaîne sur laquelle vous effectuez votre requête.

Les agents IA peuvent-ils utiliser x402 de manière autonome ?

Oui. x402 est conçu pour permettre l'accès par des agents autonomes. Un agent disposant d'un portefeuille approvisionné peut détecter, authentifier, payer et utiliser les points de terminaison Quicknode sans aucune intervention humaine.

La norme x402 est-elle prête à être mise en production ?

Le service x402 sur Quicknode est actuellement en version alpha. Il est opérationnel et disponible, mais ne bénéficie pas des mêmes garanties de niveau de service (SLA) que les formules Quicknode standard. Pour les charges de travail en production nécessitant des garanties de disponibilité et une assistance dédiée, optez pour une formule Quicknode standard.

Combien coûte chaque demande ?

La tarification à la requête est minime et libellée en USDC. Les développeurs peuvent effectuer des tests gratuitement en utilisant l'USDC du réseau de développement (devnet), qui offre jusqu'à 10 000 requêtes gratuites vers les points de terminaison RPC de production.

Quels sont les portefeuilles pris en charge pour l'authentification ?

Tout portefeuille compatible EVM ou tout portefeuille Solana. L'authentification s'effectue via SIWx (Sign-In with X), qui prend en charge la signature à la fois avec les portefeuilles EVM et Solana.

Résumé technique

Ressources

• Guide : Accéder aux points de terminaison Quicknode avec les paiements x402

• Exemples : github.com/quicknode-labs/qn-guide-examples

• Tutoriel vidéo : Comment démarrer avec x402 sur Quicknode

• Le protocole x402 expliqué : Qu'est-ce que le protocole de paiement x402 ?

• Exemples d'applications : Bibliothèque d'exemples d'applications Quicknode

• HyperCore CLI : npmjs.com/package/@quicknode/hypercore-cli

• llms.txt : x402.quicknode.com/llms.txt

• Écosystème x402 :

Quicknode fournit une infrastructure blockchain aux développeurs et aux entreprises sur plus de 80 chaînes et plus de 130 réseaux. Commencez avec une formule standard ou accédez instantanément aux points de terminaison grâce à l'accès x402 à la demande.