Trade on Preconfirmations

Preconfirmations stream transactions the instant a validator’s scheduler commits to executing them, before they are shredded. This guide builds a listener that watches a target account, decodes each scheduled transaction, and reacts using Sender Max.

Preconfirmations require a Professional plan or higher and cost 10 credits per message.

Scope the stream before you connect

An unfiltered preconfSubscribe delivers every scheduled transaction at 10 credits each, so filter server-side and pay only for what you trade on.

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "preconfSubscribe",
  "params": [
    {
      "failed": false,
      "regionInclude": ["ewr"],
      "accountInclude": ["TARGET_WALLET_OR_PROGRAM"]
    }
  ]
}

Three filters cover most trading listeners:

failed: false drops transactions already known to have reverted, which you have no reason to race.
regionInclude pins the stream to the region closest to your infrastructure, so a cross-region hop doesn’t eat the head start.
accountInclude matches any tx referencing your target: a wallet, AMM pool, program, etc. Helius resolves address lookup tables server-side, so the filter matches even when the account is loaded through an ALT.

preconfSubscribe is served from the Gatekeeper endpoint (wss://beta.helius-rpc.com), and notifications arrive as binary frames, not JSON. Each frame is a fixed 18-byte prefix followed by the bincode-serialized transaction:

listener.js

const WebSocket = require('ws');
const { VersionedTransaction } = require('@solana/web3.js');

const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key=YOUR_API_KEY');

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'preconfSubscribe',
    params: [{
      failed: false,
      regionInclude: ['ewr'],
      accountInclude: ['TARGET_WALLET_OR_PROGRAM']
    }]
  }));
  setInterval(() => ws.ping(), 30_000); // keep the connection alive
});

ws.on('message', (data, isBinary) => {
  if (!isBinary) {
    const msg = JSON.parse(data.toString());
    if (msg.id === 1) console.log('Subscribed, ID:', msg.result);
    return;
  }

  // version (u8) | slot (u64 LE) | tx_index (u64 LE) | status (u8) | bincode(VersionedTransaction)
  const buf = Buffer.from(data);
  if (buf.readUInt8(0) !== 1) return; // unknown schema version; update your decoder
  const slot = buf.readBigUInt64LE(1);
  const status = buf.readUInt8(17); // 0 = failed, 1 = success, 2 = unknown
  const tx = VersionedTransaction.deserialize(buf.subarray(18));

  onScheduledTransaction({ slot, status, tx });
});

ws.on('error', console.error);
ws.on('close', () => process.exit(1)); // let your supervisor restart and resubscribe

Check the version byte first. If Helius updates the payload format, the version increments, and branching on it keeps your decoder working. The deserialized transaction gives you the instructions, accounts, and signature.

Act with Sender Max

A preconfirmation only pays off if your response lands first. Send your reaction through Sender Max: the 0.001 SOL tip enters the priority tip buffer and routes across every high-speed pathway:

async function onScheduledTransaction({ slot, status, tx }) {
  if (!strategy.shouldReact(tx)) return;

  // strategy is your own code: it decides whether to react and returns a
  // signed, base64-encoded transaction that includes the tip and priority fee
  const reaction = await strategy.buildTransaction(tx);
  await fetch('http://ewr-sender.helius-rpc.com/fast', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: Date.now().toString(),
      method: 'sendTransaction',
      params: [reaction, { encoding: 'base64', skipPreflight: true, maxRetries: 0 }]
    })
  });
}

Keep this handler short. Decide and send, and move logging, accounting, and reconciliation off the receive path. See Land Trades with Sender for the full send loop, including connection warming and fee estimation.

Confirm landing and expect gaps

A preconfirmation is an early look. The transaction has not landed yet and can still fail or be dropped, so two rules apply:

Confirm through standard commitment checks (getSignatureStatuses, or a processed-commitment stream) before treating either the observed transaction or your reaction as final.
Expect gaps. Coverage scales with the share of stake forwarding to Helius, so some slots produce no messages. That is expected behavior rather than a dead connection, and the keepalive ping tells the two apart. Resubscribe on close.

preconfSubscribe API reference

Full filter semantics, region codes, and the binary payload layout

Trade on Preprocessed Transactions

Pre-execution coverage at 0.1 credits per message, on all paid plans

Start Here

Real-Time Data

Low-Latency Trading

Historical & Wallet Data

RPC Method Guides

Production Readiness

Using Orb

Other How-Tos

Trade on Preconfirmations

Scope the stream before you connect

Act with Sender Max

Confirm landing and expect gaps

preconfSubscribe API reference

Trade on Preprocessed Transactions

​Scope the stream before you connect

​Connect, subscribe, and decode

​Act with Sender Max

​Confirm landing and expect gaps

​Related guides

preconfSubscribe API reference

Trade on Preprocessed Transactions

Scope the stream before you connect

Connect, subscribe, and decode

Act with Sender Max

Confirm landing and expect gaps

Related guides