How to Subscribe to Stream

Learn how to direct real-time access to transaction and block streams sourced from the BDN, bypassing RPC node-level execution and processing entirely.

Stream subscription provides you with direct access to blockchain data as it propagates through the BDN network. Unlike standard RPC subscriptions that must wait for node-level processing, streams deliver data directly from the high-speed distribution layer.

Why Use Streams

Streams bypass the node's internal processing pipeline:

This architecture saves up to 10 milliseconds compared to node-based subscriptions—critical for latency-sensitive systems. With stream subscription, you enjoy:

• Faster blocks — Receive new blocks before standard RPC propagation

• Mempool access — See pending transactions before they're mined

• Lower latency — Edge infrastructure minimizes network hops

Performance Characteristics

Metric	Value
Block latency	<50ms from validator
Message throughput	70,000+ msg/sec
Reconnect time	~3 seconds

Latency Comparison

Source	Typical Latency
Standard RPC	200-500ms
GetBlock MEV Streams	<50ms
Improvement	4-10x faster

Available Streams Methods

Stream	Description	Use Case
bdnBlocks	New blocks with headers and transactions	Block monitoring, analytics
newTxs	New transactions entering mempool	MEV detection, copy trading
pendingTxs	Pending transactions	Front-running protection
txReceipts	Transaction receipts after confirmation	Trade confirmation

Quickstart

Here you will be checking if you are connected to streams

Endpoint

wss://bsc.getblock.io/mev/ws?api_key=YOUR_API_KEY

Code

Response

Subscribing to Streams

Subscribe Request Format

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subscribe",
  "params": ["<stream_name>", { "include": [...], "filters": {...} }]
}

Subscribe Response

Stream Notification Format

1. Block Streams (bdnBlocks)

Subscribe to new blocks as they're produced.

Include Options

Field	Description
header	Block header (number, hash, timestamp, gasUsed, gasLimit)
transactions	Full transaction list
hash	Block hash only

Example: Subscribe to Blocks

Code

subscribe-blocks.js

const WebSocket = require('ws');

const API_KEY = 'YOUR_API_KEY';
const ws = new WebSocket(`wss://bsc.getblock.io/mev/ws?api_key=${API_KEY}`);

ws.on('open', () => {
  console.log('Connected');
  
  // Subscribe to new blocks
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'subscribe',
    params: ['bdnBlocks', { include: ['header', 'transactions'] }]
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  // Subscription confirmation
  if (message.id === 1 && message.result) {
    console.log('Subscribed! ID:', message.result);
    return;
  }
  
  // Block notification
  if (message.params?.result) {
    const block = message.params.result;
    console.log('New block:', {
      number: parseInt(block.header.number, 16),
      hash: block.header.hash,
      txCount: block.transactions?.length || 0
    });
  }
});

Response

2. Transaction Streams (newTxs / pendingTxs)

Subscribe to mempool transactions as they propagate through the network.

Include Options

Field	Description
tx_hash	Transaction hash
from	Sender address
to	Recipient address
value	Transaction value (hex)
gas_price	Gas price (hex)
input	Transaction calldata

Filters

Reduce bandwidth by filtering server-side:

Filter	Type	Description
to	array	Transaction recipient addresses
from	array	Transaction sender addresses
method_id	array	Function selectors (first 4 bytes of calldata)

Example: Monitor PancakeSwap Transactions

Code

monitor-pancakeswap.js

const WebSocket = require('ws');
const { ethers } = require('ethers');

const API_KEY = 'YOUR_API_KEY';
const PANCAKE_ROUTER = '0x10ED43C718714eb63d5aA57B78B54704E256024E';

const SWAP_METHODS = {
  '0x38ed1739': 'swapExactTokensForTokens',
  '0x7ff36ab5': 'swapExactETHForTokens',
  '0x18cbafe5': 'swapExactTokensForETH',
  '0xfb3bdb41': 'swapETHForExactTokens',
  '0x5c11d795': 'swapExactTokensForTokensSupportingFeeOnTransferTokens',
  '0xb6f9de95': 'swapExactETHForTokensSupportingFeeOnTransferTokens'
};

function monitorPancakeSwap() {
  const ws = new WebSocket(`wss://bsc.getblock.io/mev/ws?api_key=${API_KEY}`);
  
  ws.on('open', () => {
    console.log('🔌 Connected to BSC stream');
    console.log('📊 Monitoring PancakeSwap...\n');
    
    ws.send(JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'subscribe',
      params: ['pendingTxs', {
        include: ['tx_hash', 'from', 'to', 'value', 'input', 'gas_price'],
        filters: {
          to: [PANCAKE_ROUTER]
        }
      }]
    }));
  });
  
  ws.on('message', (data) => {
    const msg = JSON.parse(data);
    
    // Subscription confirmed
    if (msg.id === 1) {
      console.log('✅ Subscribed to PancakeSwap transactions\n');
      return;
    }
    
    // New transaction
    if (msg.params?.result) {
      const tx = msg.params.result;
      const methodId = tx.input?.slice(0, 10);
      const methodName = SWAP_METHODS[methodId] || 'unknown';
      
      if (SWAP_METHODS[methodId]) {
        const value = ethers.formatEther(tx.value || '0');
        const gasPrice = ethers.formatUnits(tx.gas_price || '0', 'gwei');
        
        console.log('🔄 Swap detected:');
        console.log(`   Hash: ${tx.tx_hash.slice(0, 18)}...`);
        console.log(`   Method: ${methodName}`);
        console.log(`   From: ${tx.from.slice(0, 10)}...`);
        console.log(`   Value: ${value} BNB`);
        console.log(`   Gas: ${gasPrice} gwei`);
        console.log('');
      }
    }
  });
  
  ws.on('close', () => {
    console.log('Disconnected, reconnecting in 5s...');
    setTimeout(monitorPancakeSwap, 5000);
  });
  
  ws.on('error', (err) => {
    console.error('WebSocket error:', err.message);
  });
}

monitorPancakeSwap();

Response

Filtering by Multiple Method IDs

3. Transaction Receipts (txReceipts)

Subscribe to transaction confirmations.

Include Options

Field	Description
receipt	Full transaction receipt
logs	Event logs emitted

Example

ws.send(JSON.stringify({
  jsonrpc: '2.0',
  id: 1,
  method: 'subscribe',
  params: ['txReceipts', {
    include: ['receipt', 'logs']
  }]
}));

Unsubscribing

To stop receiving notifications, unsubscribe using the subscription ID:

ws.send(JSON.stringify({
  "jsonrpc": "2.0",
  "id": 10,
  "method": "unsubscribe",
  "params": ["550e8400-e29b-41d4-a716-446655440000"]  // Subscription ID
}));

Best Practices

1. Request Only What You Need

Don't ❌

// ❌ Bad: Request everything
include: ['tx_contents']  // Large payloads, high bandwidth

Do ✅

1. Use Server-Side Filters

Don't ❌

// ❌ Bad: Filter client-side
params: ['newTxs', { include: ['tx_contents'] }]
// Then filter in your code... wasteful!

Do ✅

1. Handle Reconnection

function createConnection() {
  const ws = new WebSocket(`wss://bsc.getblock.io/mev/ws?api_key=${API_KEY}`);
  
  ws.on('close', () => {
    console.log('Disconnected, reconnecting...');
    setTimeout(createConnection, 5000);
  });
  
  ws.on('open', () => {
    // Re-subscribe after reconnect
    subscribeToFeeds(ws);
  });
  
  return ws;
}

1. Process Messages Asynchronously

ws.on('message', async (data) => {
  // Don't block the message loop
  setImmediate(() => {
    processMessage(JSON.parse(data));
  });
});

Rate Limits

Tier	Concurrent Subscriptions	Message Rate
Standard	5	1,000/sec
Pro	20	10,000/sec
Enterprise	Unlimited	Unlimited

Contact support to upgrade your tier.

Troubleshooting

Problem	Solution
No messages received	Check subscription response—did you receive a subscription ID? Verify filters aren't too restrictive Confirm your API key is valid and active
High latency	Reduce the number of include fields Add filters to reduce message volume Check your network connection
Missed messages	Process messages asynchronously Increase your message queue buffer Consider multiple connections for different streams
Connection Drop	Implement automatic reconnection (see example above) Re-subscribe after each reconnect—subscriptions don't persist Check your network stability