Démarrage rapide des Flux Analysés

Nouveau dans les Flux Analysés ? Lisez d’abord le modèle mental — il explique pourquoi les filtres sont comme ils sont.

Démarrage rapide

Get Access

Parsed Streams est disponible avec tous les forfaits au tarif de 1 crédit par événement transmis. Obtenez votre clé API depuis le tableau de bord Helius et connectez-vous au point de terminaison Gatekeeper à l’adresse wss://beta.helius-rpc.com, sur le même hôte que le trafic RPC et WebSocket de Helius.Authentifiez-vous avec la clé API de votre projet, passée en tant que paramètre de requête api-key (ou en tant qu’en-tête x-api-key).

Connectez-vous

wscat

wscat -c "wss://beta.helius-rpc.com/?api-key=YOUR_API_KEY"

Une clé manquante ou invalide est rejetée avec HTTP 401. Un projet à sa limite de connexion obtient HTTP 429.

S'abonner avec un filtre

Envoyez parsedTransactionSubscribe avec un filtre et des options facultatives :

{"jsonrpc":"2.0","id":1,"method":"parsedTransactionSubscribe","params":[{"programs":["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"]}]}

La réponse result est un ID d’abonnement entier :

{ "jsonrpc": "2.0", "id": 1, "result": 23 }

Lire une notification

Chaque transaction correspondante arrive comme un parsedTransactionNotification, déjà décodé, avec matchedIndexes pointant vers les instructions que votre filtre a trouvées. Voir Notifications pour la forme complète.

Se désabonner

{ "jsonrpc": "2.0", "id": 2, "method": "parsedTransactionUnsubscribe", "params": [23] }

Ou fermez simplement la connexion — cela supprime tous ses abonnements.

Guides

Suivre les échanges Jupiter

Utilisez describeProgram pour construire un filtre fiable avant de vous abonner.

Suivre les Mints Pump.fun

Un écouteur sûr pour la reconnexion qui enregistre chaque nouveau déploiement de token Pump.fun.

Gérer les reconnexions

Survivez aux timeouts et déploiements inactifs, puis comblez précisément ce que vous avez manqué.

Référence du protocole

Les Flux Analysés utilisent JSON-RPC 2.0 sur une connexion WebSocket unique. Chaque requête reçoit une réponse avec le même id. Un abonnement pousse ensuite des messages parsedTransactionNotification jusqu’à ce que vous vous désabonniez ou déconnectiez.

Méthode	Objectif
`parsedTransactionSubscribe`	Démarrer un abonnement avec un filtre
`parsedTransactionUnsubscribe`	Arrêter un abonnement
`describeProgram`	Répertorier les instructions, les événements et les rôles de compte d’un programme

S’abonner

Envoyez parsedTransactionSubscribe avec un filtre et des options facultatives. La réponse result est un ID d’abonnement entier.

Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "parsedTransactionSubscribe",
  "params": [
    {
      "programs": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"],
      "instructionNames": ["route", "shared_accounts_route"],
      "accounts": {
        "include": ["So11111111111111111111111111111111111111112"],
        "roles": { "user_transfer_authority": "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin" }
      },
      "includeFailed": false,
      "includeCpi": true
    },
    { "commitment": "confirmed", "details": "full" }
  ]
}

Response

{ "jsonrpc": "2.0", "id": 1, "result": 23 }

Champs du filtre

Au moins l’un des programs ou accounts.include est requis. Les champs que vous définissez se combinent avec ET : une instruction doit remplir toutes les conditions pour correspondre.

string[]

IDs de programme à correspondre (adresses base58, pas des noms). Une instruction correspond si son programme est dans cette liste. OU dans la liste.

string[]

Noms d’instruction décodés, tels que route. Correspondance exacte d’abord, puis insensible à la casse et au séparateur, donc sharedAccountsRoute correspond également au nom sur le fil shared_accounts_route. OU dans la liste. Seules les instructions dont le nom a été identifié dans le catalogue peuvent correspondre, donc prenez les noms de describeProgram.

string[]

Adresses des comptes. Une instruction correspond si l’une d’elles apparaît dans sa liste de comptes. OU dans la liste. Fonctionne pour chaque instruction, décodée ou non. L’ID du programme lui-même ne compte pas ici comme un compte.

object

Une carte du nom de rôle de compte décodé à l’adresse, tel que { "user_transfer_authority": "<pubkey>" }. Chaque entrée doit être tenue (ET entre les entrées), et l’instruction doit être décodée pour que cela s’applique. Les noms de rôle correspondent exactement, sans conversion de casse, donc copiez-les de describeProgram plutôt que de deviner.

boolean

défaut:"false"

Inclure les instructions des transactions échouées.

boolean

défaut:"true"

Les instructions internes (CPI) peuvent correspondre. Réglez false pour correspondre uniquement aux instructions de premier niveau.

Les champs inconnus n’importe où dans le filtre ou les options sont rejetés avec -32602 plutôt que silencieusement ignorés, donc les fautes de frappe échouent bruyamment au lieu de ne rien correspondre.

Options

Le second paramètre est facultatif.

string

défaut:"confirmed"

Seul confirmed est pris en charge.

string

défaut:"full"

Ce que chaque notification contient. full : l’ensemble de la transaction, chaque instruction, plus matchedIndexes pointant vers les correspondances du filtre. matched : seulement les instructions qui ont correspondu, sans liste d’index. raw : instructions correspondantes uniquement, réduites à leur position, programId, et blob data en base58, sans champs décodés et sans tableau accountKeys. Utilisez matched quand la bande passante compte plus que le contexte (les charges utiles complètes sont en moyenne environ trois fois plus grandes), et raw lorsque vous décodez les données d’instruction vous-même et que vous avez seulement besoin des octets.

Le nombre de connexions simultanées par projet dépend de votre forfait : 5 avec Free, 10 avec Developer et 50 avec Business et Professional. Ces connexions sont partagées entre toutes les clés API du projet. Consultez la section Limites de débit.

Notifications

Une notification par transaction correspondante par abonnement. Avec le défaut details: "full" :

{
  "jsonrpc": "2.0",
  "method": "parsedTransactionNotification",
  "params": {
    "subscription": 23,
    "result": {
      "context": { "slot": 430172053 },
      "value": {
        "transaction": {
          "signature": "3riSYL4HTRxgQjLayt6L2JPaDR3oaEQg1H4v3fnjUxNU...",
          "slot": 430172053,
          "blockTime": null,
          "feePayer": "6jduWNCTQzG91JGBchfGGxd55Vi5FxJCCJEV18RkXzJX",
          "fee": 5000,
          "accountKeys": ["6jduWNCT...", "..."],
          "status": "ok",
          "error": null,
          "summary": {
            "type": "swap",
            "description": "6jduWNCTQzG91JGBchfGGxd55Vi5FxJCCJEV18RkXzJX swapped 0.001 SOL for 0.183985 EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v via Jupiter",
            "parsedData": {
              "type": "swap",
              "protocol": "jupiter",
              "kind": "swap",
              "in_amount": "1000000",
              "actual_out_amount": "183985",
              "input_mint": "So11111111111111111111111111111111111111112",
              "output_mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
            }
          },
          "nativeTransfers": [
            { "fromUserAccount": "6jduWNCT...", "toUserAccount": "DfXygSm4...", "amount": 1000000 }
          ],
          "tokenTransfers": [
            {
              "fromUserAccount": "6jduWNCT...",
              "toUserAccount": "AeUfFU6L...",
              "fromTokenAccount": "HLaEoW1s...",
              "toTokenAccount": "G13P9kSY...",
              "rawTokenAmount": 183985,
              "decimals": 6,
              "tokenStandard": "Fungible",
              "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
            }
          ]
        },
        "instructions": [
          {
            "instructionIndex": 4,
            "innerInstructionIndex": null,
            "stackHeight": 1,
            "programId": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
            "programName": "jupiter",
            "instructionName": "route",
            "summary": {
              "type": "swap",
              "description": "6jduWNCTQzG91JGBchfGGxd55Vi5FxJCCJEV18RkXzJX swapped 0.001 SOL for 0.183985 EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v via Jupiter",
              "parsedData": {
                "type": "swap",
                "protocol": "jupiter",
                "kind": "swap",
                "in_amount": "1000000",
                "actual_out_amount": "183985",
                "input_mint": "So11111111111111111111111111111111111111112",
                "output_mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
              }
            },
            "decoded": {
              "args": { "in_amount": "1000000", "slippage_bps": 50 },
              "accounts": [
                { "name": "user_transfer_authority", "pubkey": "9xQe...", "isSigner": true, "isWritable": false }
              ]
            }
          }
        ],
        "matchedIndexes": [8, 13]
      }
    }
  }
}

Lecture de celle-ci :

transaction fournit le contexte complet. fee est exprimé en lamports. accountKeys est la liste complète des clés, y compris celles chargées depuis les tables de recherche d’adresses, dans l’ordre où la chaîne les renvoie. feePayer vaut toujours accountKeys[0]. error contient l’erreur de transaction sous forme de JSON structuré, par exemple {"InstructionError": [2, {"Custom": 6001}]}, lorsque status vaut "error".
summary présente la même structure partout où il apparaît : un type (tel que swap ou transfer), un description lisible par l’humain et une charge utile parsedData structurée lorsque l’analyseur reconnaît l’action — pour un swap : le protocole, les montants et les mints. transaction.summary désigne l’action principale de la transaction ; chaque instruction reconnue possède son propre summary avec la même structure. Pour récupérer tous les swaps d’une transaction, parcourez instructions et lisez summary.parsedData lorsque summary.type vaut "swap".
Les montants des swaps sont ceux déclarés par la plateforme. in_amount, actual_out_amount et les montants des swaps internes dans parsedData correspondent aux valeurs déclarées par la plateforme, et non aux montants réellement envoyés ou reçus par le portefeuille de l’utilisateur. Ils ne tiennent pas compte des frais de transfert Token-2022 ni des autres déductions appliquées en dehors du swap. Pour connaître le montant exact reçu, comparez les soldes du compte de tokens de l’utilisateur avant et après la transaction.
nativeTransfers et tokenTransfers répertorient les mouvements de SOL et de tokens extraits de l’ensemble de la transaction par l’analyseur, selon la même structure que celle renvoyée par l’API Parsed Events. Les consommateurs du flux et de l’API peuvent ainsi partager le même code de traitement. Les deux champs sont toujours présents, mais peuvent être vides.
instructions contient toutes les instructions de la transaction dans leur ordre d’exécution : chaque instruction de premier niveau suivie de ses instructions internes. Chaque entrée indique sa propre position : instructionIndex désigne l’instruction de premier niveau à laquelle elle appartient (à partir de 0), innerInstructionIndex indique sa position parmi les appels internes de cette instruction (null signifie qu’il s’agit de l’instruction de premier niveau elle-même) et stackHeight correspond à la profondeur d’appel (1 pour le premier niveau). Utilisez ces valeurs, et non la position dans le tableau.
matchedIndexes contient des indices dans instructions qui indiquent les instructions correspondant réellement à votre filtre. Les autres sont fournies à titre contextuel. Avec details: "matched", le tableau contient uniquement les correspondances et matchedIndexes est absent.
Les noms de decoded utilisent le snake_case (in_amount, user_transfer_authority), conformément à leur publication dans l’IDL du programme. Les arguments entiers sont généralement des chaînes de caractères ("1000000"), car les valeurs u64 ne peuvent pas être représentées par les nombres JavaScript.
blockTime vaut actuellement toujours null. Ne vous appuyez pas dessus.
Attendez-vous à trouver un mélange d’instructions décodées et non décodées dans une même transaction : un swap entièrement décodé peut côtoyer un mémo non reconnu. Effectuez un branchement selon decoded : lorsqu’il vaut null, l’instruction contient à la place rawData (octets en base58) et rawAccounts (liste simple de clés publiques), afin que vous disposiez toujours de données exploitables.

Avec details: "raw" le value se rétrécit au méta de transaction et aux blobs. accountKeys, nativeTransfers, tokenTransfers, matchedIndexes, et tous les champs décodés disparaissent (la transaction summary est toujours incluse); chaque instruction correspondante est sa position, son programme, et ses octets data en base58, exactement comme ils apparaissent sur la chaîne (présent même pour les instructions que le catalogue aurait pu décoder):

"value": {
  "transaction": {
    "signature": "3riSYL4HTRxgQjLayt6L2JPaDR3oaEQg1H4v3fnjUxNU...",
    "slot": 430172053,
    "blockTime": null,
    "feePayer": "6jduWNCTQzG91JGBchfGGxd55Vi5FxJCCJEV18RkXzJX",
    "fee": 5000,
    "status": "ok",
    "error": null,
    "summary": {
      "type": "swap",
      "description": "6jduWNCTQzG91JGBchfGGxd55Vi5FxJCCJEV18RkXzJX swapped 0.001 SOL for 0.183985 EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v via Jupiter",
      "parsedData": {
        "type": "swap",
        "protocol": "jupiter",
        "kind": "swap",
        "in_amount": "1000000",
        "actual_out_amount": "183985",
        "input_mint": "So11111111111111111111111111111111111111112",
        "output_mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
      }
    }
  },
  "instructions": [
    { "instructionIndex": 4, "innerInstructionIndex": null, "stackHeight": 1, "programId": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4", "data": "3Bxs4h24hBtQy9rw" }
  ]
}

Se désabonner

{ "jsonrpc": "2.0", "id": 2, "method": "parsedTransactionUnsubscribe", "params": [23] }

Retourne true si l’abonnement existait et était le vôtre. Les notifications s’arrêtent immédiatement. La fermeture de la connexion supprime tous ses abonnements.

Découverte

L’échec le plus courant avec ce type d’API est l’utilisation d’un filtre valide qui ne trouve aucune correspondance, généralement à cause d’un nom d’instruction ou de rôle supposé. describeProgram évite ce problème en renvoyant les noms exacts utilisés par le moteur de correspondance. Cette méthode est actuellement disponible uniquement sur wss://fs-beta.helius-rpc.com/?api-key=<API_KEY>. Envoyez-la donc via une connexion distincte de celle de vos abonnements :

Request

{ "jsonrpc": "2.0", "id": 1, "method": "describeProgram", "params": [{ "program": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4" }] }

Response

{
  "jsonrpc": "2.0", "id": 1,
  "result": {
    "id": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
    "name": "jupiter",
    "instructions": ["route", "shared_accounts_route", "exact_out_route"],
    "events": ["SwapEvent"],
    "roles": ["user_transfer_authority", "destination_token_account"]
  }
}

Vous pouvez passer une adresse de programme ou un nom de catalogue, mais préférez l’adresse : les noms peuvent être ambigus selon les versions de programme (plus d’une entrée de catalogue est nommée jupiter, et une recherche de nom peut se résoudre à celle plus ancienne). Si vous effectuez une recherche par nom, vérifiez que result.id est le programme auquel vous avez l’intention de vous abonner. Flux recommandé : describeProgram pour obtenir les noms exacts d’instruction et de rôle, construisez le filtre avec ces noms, puis abonnez-vous. Le guide Suivre les échanges Jupiter explique cela de bout en bout.

Limites

Limite	Valeur
Connexions simultanées par projet	5 (Free), 10 (Developer), 50 (Business et Professional)
Abonnements par connexion	25
Messages du client	10 par seconde, avec des pics de 20
Taille des messages du client	64 Kio
`programs` par filtre	10
`instructionNames` par filtre	50, jusqu’à 64 caractères chacun
`accounts.include` par filtre	100
`accounts.roles` par filtre	20, avec un maximum de 64 caractères par nom
Tampon sortant par connexion	2 048 notifications, puis la connexion est fermée

Erreurs

Les erreurs suivent JSON-RPC 2.0 : { "error": { "code": <int>, "message": "<text>" }, "id": <id> }. Les messages indiquent exactement ce qui était incorrect et où.

Code	Signification
`-32700`	Erreur d’analyse (JSON invalide)
`-32600`	Requête invalide
`-32601`	Méthode non trouvée
`-32602`	Paramètres invalides : mauvais clé publique, champ inconnu, engagement ou valeur de détails non pris en charge
`-32000`	Limite de filtre dépassée
`-32001`	Serveur non prêt; réessayez avec une temporisation croissante
`-32002`	Limité par débit (10 messages par seconde)
`-32006`	Trop d’abonnements (25 par connexion)

Les connexions peuvent également se fermer avec un code de fermeture WebSocket — voir Gestion des reconnexions pour savoir ce que chacun signifie et comment récupérer.

Exemples de Client

wscat -c "wss://beta.helius-rpc.com/?api-key=<API_KEY>"
# then send:
{"jsonrpc":"2.0","id":1,"method":"parsedTransactionSubscribe","params":[{"programs":["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"]}]}

import WebSocket from "ws";

const ws = new WebSocket("wss://beta.helius-rpc.com/?api-key=<API_KEY>");

ws.on("open", () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "parsedTransactionSubscribe",
    params: [{ programs: ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"] }],
  }));
});

ws.on("message", (data) => {
  const msg = JSON.parse(data.toString());
  if (msg.method === "parsedTransactionNotification") {
    const { transaction, instructions, matchedIndexes } = msg.params.result.value;
    for (const i of matchedIndexes ?? instructions.keys()) {
      const ix = instructions[i];
      console.log(transaction.signature, ix.programName, ix.instructionName, ix.decoded?.args);
    }
  }
});

import asyncio, json, websockets

URL = "wss://beta.helius-rpc.com/?api-key=<API_KEY>"

async def main():
    async with websockets.connect(URL) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0", "id": 1, "method": "parsedTransactionSubscribe",
            "params": [{"programs": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"]}],
        }))
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("method") == "parsedTransactionNotification":
                value = msg["params"]["result"]["value"]
                for i in value.get("matchedIndexes") or range(len(value["instructions"])):
                    ix = value["instructions"][i]
                    print(ix.get("programName"), ix.get("instructionName"), (ix.get("decoded") or {}).get("args"))

asyncio.run(main())

Bien démarrer

Diffusion de données et écoute d’événements

API de données et RPC

Trading

Envoi de transactions

Portefeuille en tant que service

Confidentialité

Ressources

Démarrage rapide des Flux Analysés