> ## Documentation Index > Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt > Use this file to discover all available pages before exploring further. # Como Usar preprocessedSubscribe > Transmita transações Solana antes da execução via WebSocket com o método preprocessedSubscribe. Inscreva-se, filtre por conta e decodifique cargas binárias antes do compromisso processado. **Beta Pública.** `preprocessedSubscribe` está disponível em **todos os planos pagos** e é contabilizada em **0,1 créditos por mensagem** (uma mensagem por transação entregue). ## O que é `preprocessedSubscribe`? `preprocessedSubscribe` é um método WebSocket Helius que transmite transações preprocessadas — transações Solana antes da execução entregues **antes de atingirem o nível de compromisso `processed`**. O Helius agrega várias fontes de pré-execução — principalmente shreds decodificadas diretamente à medida que chegam ao validador, complementadas por sinais de transações agendadas ([pré-confirmação](/docs/pt-BR/pre-confirmations/overview)) — e as entrega como um único fluxo deduplicado de mensagens binárias compactas, sem necessidade de infraestrutura de desfragmentação do seu lado. As transações provenientes de sinais de pré-confirmação chegam mais tarde neste feed do que no produto dedicado [Pré-confirmações](/docs/pt-BR/pre-confirmations/overview), que continua sendo o acesso mais antecipado a elas. É o sucessor do produto LaserStream preprocessed anterior. Se você consome [transações preprocessadas via gRPC](/docs/pt-BR/preprocessed-transactions/grpc) atualmente, mude para este método — ele entrega a mesma classe de dados por uma conexão WebSocket simples com menor latência, e a entrega via gRPC será descontinuada. | Fluxo | Tempo relativo | Cobertura | Dados | | ----------------------------------------------------------------------------------- | ------------------------------------------------------- | -------------------------------------------------- | ------------------------------------- | | [Pré-confirmações](/docs/pt-BR/pre-confirmations/overview) | Mais cedo | Transações agendadas por validadores participantes | Status de transação e pré-confirmação | | `preprocessedSubscribe` | Tipicamente após Pré-confirmações, antes de `processed` | Ampla cobertura de transações Solana | Transação assinada antes da execução | | [`transactionSubscribe`](/docs/pt-BR/rpc/websocket/transaction-subscribe) em `processed` | Após execução | Transações processadas | Transação com metadados de execução | `preprocessedSubscribe` é um **sinal de pré-execução de melhor esforço**, não um nível de compromisso. Uma transação transmitida pode falhar, ser descartada ou cair em um fork diferente. Reconcilie com um fluxo processado ou confirmado antes de tratá-la como final. ## Endpoint `preprocessedSubscribe` é servido em `wss://beta.helius-rpc.com` — o endpoint do Helius Gatekeeper — em vez de `mainnet.helius-rpc.com`. Autentique-se com sua chave de API como um parâmetro de consulta: ``` wss://beta.helius-rpc.com/?api-key= ``` Cada chave de API é limitada a **10 conexões/inscrições simultâneas**. ## Inscrever-se Envie uma solicitação JSON-RPC com o método `preprocessedSubscribe`. `params` carrega os filtros de conta e é obrigatório — `accountInclude` e `accountRequired` devem especificar pelo menos uma conta entre eles (veja [Filtragem](#filtragem)): ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preprocessedSubscribe", "params": { "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"], "accountExclude": [], "accountRequired": [] } } ``` O servidor reconhece a inscrição com um quadro de texto JSON contendo o ID da inscrição: ```json theme={"system"} { "jsonrpc": "2.0", "result": 1, "id": 1 } ``` Após este reconhecimento, as atualizações de transação chegam como quadros WebSocket **binários** — veja [Carga útil de notificação](#carga-útil-de-notificação). ## Filtragem Toda inscrição é delimitada pelos filtros de conta em `params`. A filtragem acontece do lado do servidor, então você só recebe as transações que interessam: ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preprocessedSubscribe", "params": { "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"], "accountExclude": ["Vote111111111111111111111111111111111111111"], "accountRequired": [] } } ``` | Filtro | Comportamento de correspondência | | ----------------- | ------------------------------------------------------------------------------ | | `accountInclude` | Corresponde quando a transação referencia **qualquer** das contas listadas. | | `accountExclude` | Descarta a transação se ela referenciar **qualquer** das contas listadas. | | `accountRequired` | Corresponde apenas quando a transação referencia **todas** as contas listadas. | Regras de filtro: * Os três filtros são combinados com lógica AND. * `accountInclude` e `accountRequired` devem especificar **pelo menos uma conta** entre eles — não há fluxo completo sem filtro. * As contas são chaves públicas codificadas em base58. Cada lista aceita até **5.000** endereços. ### Resolução de tabela de pesquisa de endereços (ALT) Os filtros de conta correspondem a mais do que as chaves de conta estáticas da transação — Helius resolve [tabelas de pesquisa de endereços](/docs/pt-BR/glossary#tabela-de-pesquisa-de-endereços-alt) no lado do servidor, então `accountInclude`, `accountExclude` e `accountRequired` também correspondem a contas que uma transação carrega por meio de um ALT. Basta passar a chave pública da conta; não há necessidade de manter mapeamentos ALT ou resolver tabelas por conta própria. ## Carga útil de notificação Notificações são entregues como quadros WebSocket **binários** (não JSON). Cada quadro carrega uma única transação em um layout de byte compactado: | Bytes | Campo | Tipo | Descrição | | ----- | ------------- | ------------------------------- | ----------------------------------------------------- | | 0 | `version` | `u8` | Versão do esquema de carga útil. Atualmente `1`. | | 1–8 | `slot` | `u64` (little-endian) | O slot em que a transação foi observada. | | 9–72 | `signature` | 64 bytes | A primeira assinatura da transação, em forma binária. | | 73+ | `transaction` | `bincode(VersionedTransaction)` | A transação assinada, serializada em bincode. | Leia o prefixo fixo de 73 bytes na ordem, então [`bincode`](https://docs.rs/bincode)-desserialize os bytes restantes em um `VersionedTransaction` para ler instruções, contas e buscas em tabelas de endereços. A assinatura é incluída no prefixo para que você possa identificar e deduplicar uma transação sem decodificar o corpo completo da transação. Sempre leia e verifique primeiro o byte `version`. Se o Helius precisar atualizar o formato da carga útil, a versão será incrementada - bifurque nela para que seu decodificador continue funcionando em mudanças de esquema. ## Exemplo ```javascript theme={"system"} const WebSocket = require('ws'); const bs58module = require('bs58'); const bs58 = bs58module.default ?? bs58module; const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key='); ws.on('open', () => { ws.send(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'preprocessedSubscribe', // Only Jupiter v6 transactions — accountInclude/accountRequired must // specify at least one account between them. params: { accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'], accountExclude: [], accountRequired: [] } })); // Keep the connection alive setInterval(() => ws.ping(), 30_000); }); ws.on('message', (data, isBinary) => { // The subscribe acknowledgement arrives as a JSON text frame if (!isBinary) { const msg = JSON.parse(data.toString()); if (msg.id === 1) console.log('Subscribed, ID:', msg.result); return; } // Notifications arrive as binary frames: // version (u8) | slot (u64 LE) | signature ([u8; 64]) | bincode(VersionedTransaction) const buf = Buffer.from(data); const version = buf.readUInt8(0); // currently 1 — branch on this if it changes if (version !== 1) return; // unknown schema version; update your decoder const slot = buf.readBigUInt64LE(1); const signature = bs58.encode(buf.subarray(9, 73)); const txBytes = buf.subarray(73); // bincode-serialized VersionedTransaction console.log('Preprocessed transaction:', { slot, signature, bytes: txBytes.length }); // Deserialize txBytes (bincode) into a VersionedTransaction with your Solana tooling }); ws.on('error', console.error); ws.on('close', () => process.exit(1)); ``` ## Que dados estão disponíveis? Cada notificação carrega a transação assinada, sua primeira assinatura e seu slot. Como a entrega ocorre antes da execução, o fluxo **não** inclui: * Status de execução ou erros * Saldos pré/pós ou alterações de saldo de token * Mensagens de log ou instruções internas * Unidades de computação consumidas Pense nisso como receber a "proposta" sem o "resultado" — você vê o que o remetente tentou fazer, mas não o que realmente aconteceu. Atualizações de estado de conta e programa ainda não existem nesta fase; se você precisar de estado de conta em tempo real, use [LaserStream gRPC](/docs/pt-BR/laserstream) no compromisso `processed`. ## Retenção de dados O fluxo não faz buffer indefinido para consumidores lentos. Se o seu cliente ler muito devagar e mais de **4.000 mensagens** ficarem retidas no lado do servidor, Helius fecha a conexão — você recebe um quadro de fechamento limpo do WebSocket. Drene quadros mais rápido do que eles chegam: mantenha trabalhos pesados, como decodificação de transações e lógica de estratégia, fora do loop de recebimento, e reconecte-se e reinscreva-se após uma desconexão. ## Garantias de entrega A entrega é de melhor esforço, não garantida, e não há reprodução histórica. Os clientes devem: 1. Reconectar e reinscrever-se após uma conexão ser fechada. 2. Deduplicar por assinatura de transação. 3. Trate o slot como uma observação, não uma finalização. 4. Reconciliar com um fluxo processado ou confirmado quando os resultados da execução importarem. ## Preço `preprocessedSubscribe` está disponível em **todos os planos pagos** e é contabilizado em **0,1 créditos por mensagem** — uma mensagem por transação entregue, faturada a partir do seu plano. Veja [Créditos](/docs/pt-BR/billing/credits) para detalhes. ## Relacionados Os mesmos dados de pré-execução via gRPC. Será descontinuado em favor deste método. Transações agendadas transmitidas antes de se tornarem shreds — o sinal de transação mais precoce. Pacotes de shreds não processados via UDP. Você implementa a desfragmentação. Transações pós-execução com filtragem rica e metadados de execução.