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. This is very good for users e.g traders who want to get data earlier e.g new released token With a 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

Code Sample

Here, you will be checking if you are connected to streams

Endpoint

wss://go.getblock.asia/<ACCESS_TOKEN>

Code

Response

How to Subscribe to Streams

To subscribe to streams, there are four parameters you can make use of as seen below:

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

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

import WebSocket from "ws";
import "dotenv/config";

const ws = new WebSocket(`wss://go.getblock.io/${process.env.ACCESS_TOKEN}`);

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", "hash"] }],
    }),
  );
});

ws.on("message", (data) => {
  const message = JSON.parse(data);

  // Subscription confirmation
  if (message.id === 1 && message.result) {
    console.log("Subscribed! ID:", parseInt(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

pendingTxs code

monitor-pancakeswap.js

import WebSocket from "ws";
import { ethers } from "ethers";
import "dotenv/config";

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://go.getblock.io/${process.env.ACCESS_TOKEN}`);

  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

newTx code

Response

3. Transaction Receipts (txReceipts)

Subscribe to transaction confirmations.

Include Options

Field	Description
receipt	Full transaction receipt
logs	Event logs emitted

Example:

Code

import WebSocket from 'ws';
import 'dotenv/config';

const ws = new WebSocket(`wss://go.getblock.io/${process.env.ACCESS_TOKEN}`);

ws.on("open", () => {
  console.log("Connected");

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

ws.on("message", (data) => {
  const message = JSON.parse(data);
  console.log(message)})

Response

Unsubscribing

To stop receiving notifications, unsubscribe using the subscription ID:

code sample

unsubscribe.js

import WebSocket from "ws";
import "dotenv/config";
const ws = new WebSocket(`wss://go.getblock.io/${process.env.ACCESS_TOKEN}`);
ws.on("open", () => {
  console.log("Connected");

ws.send(
  JSON.stringify({
    jsonrpc: "2.0",
    id: 10,
    method: "unsubscribe",
    params: ["23"], // Subscription ID
  }),
);})

ws.on("message", (data) => {
  const message = JSON.parse(data);
  console.log(JSON.stringify(message, null, 2));
});

Response

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

Next Step

1. Submitting transactions to public mempool with accelerated propagation

2. Using private transactions for MEV protection or without MEV Protection