FalconStream

Shred-stage transaction streaming for the earliest possible signal on Solana. FalconStream routes to Shyft RabbitStream, delivering transactions before they hit the RPC execution pipeline.

What is FalconStream?

FalconStream is a premium gRPC streaming tier that taps the Solana validator pipeline at the shred stage — before transactions are executed by the RPC node. This gives you a 15–100ms speed advantage over standard Yellowstone gRPC for sniping, MEV, and high-frequency trading. Like standard gRPC, it requires an All Access subscription and uses a dedicated key prefix.

Endpoint

grpc.falconq.xyz:50051

Auth

x-token

Key Prefix

fq_fs_live_...

FalconStream vs Standard gRPC

Feature	FalconStream	Standard gRPC
Extraction point	Raw UDP shreds (pre-RPC)	Post-execution Geyser hook
Latency	Ultra-low (~15-100ms faster)	Standard
Transaction meta	Missing (no logs, no CU, no status)	Full (logs, balances, inner instructions, status)
Account filters	Not supported	Supported
Slot / block filters	Not supported	Supported
Filter types	Transactions only	All filter types
Best for	Sniping, MEV, earliest detection	Indexing, analytics, reliable bots

Supported Filters

FalconStream supports only transaction filters. Account, slot, block, and blocksMeta filters are not available because data is captured before the RPC processes and confirms those structures.

Filter	Supported
transactions	Yes
accounts	No
slots	No
blocks	No
blocksMeta	No
accountsDataSlice	No

Connection

FalconStream uses the same gRPC client and proto file as standard Yellowstone gRPC. The only difference is your API key prefix and what data you receive.

const grpc = require('@grpc/grpc-js')
const protoLoader = require('@grpc/proto-loader')

const packageDefinition = protoLoader.loadSync('geyser.proto', {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
})
const geyser = grpc.loadPackageDefinition(packageDefinition)

const client = new geyser.Geyser(
  'grpc.falconq.xyz:50051',
  grpc.credentials.createInsecure()
)

const metadata = new grpc.Metadata()
metadata.set('x-token', 'fq_fs_live_YOUR_KEY')

Transaction Streaming Example

Stream all Pump.fun transactions for earliest detection. Because FalconStream captures data before execution, you will not receive logs, balance changes, or failure status — just the raw transaction intent.

const request = {
  slots: {},
  accounts: {},
  transactions: {
    pumpfun: {
      vote: false,
      failed: false,
      accountInclude: ['6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P'],
      accountExclude: [],
      accountRequired: [],
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: 'processed',
}

const stream = client.Subscribe(request, metadata)

stream.on('data', (update) => {
  if (update.transaction) {
    const tx = update.transaction.transaction
    console.log('Signature:', tx.transaction?.signatures[0])
    console.log('Slot:', tx.slot)
    // NOTE: tx.meta is undefined — no logs, no balances, no status
  }
})

stream.on('error', (err) => {
  console.error('Stream error:', err)
})

Response Structure

FalconStream returns the same transaction structure as standard gRPC, but the meta field is entirely absent. This is the trade-off for the speed advantage.

FalconStream Response

{ transaction: { signature: "5Pj5fCup...", isVote: false, transaction: { signatures: [...], message: { accountKeys: [...], instructions: [...], recentBlockhash: "..." } }, // meta is undefined — // no logs, no CU, no status }, slot: 375285929 }

Standard gRPC Response

{ transaction: { signature: "5Pj5fCup...", isVote: false, transaction: { ... }, meta: { err: null, fee: 5000, logMessages: [...], innerInstructions: [...], preBalances: [...], postBalances: [...], computeUnitsConsumed: 56098 } }, slot: 375285929 }

Dual-Stream Pattern

The recommended pattern is to subscribe to FalconStream for earliest detection, then use standard gRPC or WebSocket to receive the confirmed result with full execution context. The transaction signature is identical in both streams.

// 1. FalconStream — earliest detection
const fsStream = fsClient.Subscribe(fsRequest, fsMetadata)
fsStream.on('data', (update) => {
  if (update.transaction) {
    const sig = update.transaction.transaction.signatures[0]
    console.log('Detected via FalconStream:', sig)

    // 2. Subscribe to standard gRPC for confirmation
    const confirmRequest = {
      transactions: {
        confirm: {
          vote: false, failed: false,
          signature: sig,
        }
      },
      commitment: 'confirmed',
    }
    confirmClient.Subscribe(confirmRequest, confirmMetadata)
      .on('data', (c) => {
        console.log('Confirmed with meta:', c.transaction?.meta)
      })
  }
})

Important Considerations

Transactions may fail. FalconStream delivers transactions before execution. A transaction may fail signature verification, run out of compute, or land on a fork. Always validate.

No account filters. You cannot subscribe to account changes via FalconStream. Use standard gRPC or WebSocket for account monitoring.

No execution metadata. You will not receive program logs, inner instructions, pre/post balances, or compute unit consumption. Plan your application logic accordingly.

Use processed commitment. Since FalconStream data is pre-execution, commitment level has no practical effect, but processed is recommended for consistency.