API Reference

BSC RPC Docs

Standard Ethereum JSON-RPC with BSC semantics. Use any JSON-RPC client — ethers, web3.py, viem, alloy, go-ethereum, whatever you have. No custom SDK required.

Quick start

Endpoints

HTTP

https://va-bsc-01.streamsuite.io/?key=YOUR_API_KEY

Standard JSON-RPC POST. Methods go in the body. Key can also be sent as a bearer header (Authorization: Bearer ...).

WebSocket

wss://va-bsc-01.streamsuite.io/ws?key=YOUR_API_KEY

Persistent connection for subscriptions. Use eth_subscribe with one of the supported channels below.

Methods by tier

What's included

Method	Description	Real-Time	Mempool	Full Node
eth_blockNumber	Latest block number	✓	✓	✓
eth_getBlockByNumber / Hash	Block data	✓	✓	✓
eth_getTransactionByHash	Transaction lookup	✓	✓	✓
eth_getTransactionReceipt	Receipt (~5d history)	✓	✓	✓
eth_getBalance	Account balance	✓	✓	✓
eth_getCode	Contract bytecode	✓	✓	✓
eth_getStorageAt	Storage slot read	✓	✓	✓
eth_call	Read-only contract call	✓	✓	✓
eth_estimateGas	Gas estimation	✓	✓	✓
eth_sendRawTransaction	Submit signed tx	✓	✓	✓
eth_getLogs	Event logs (~32d history)	✓	✓	✓
eth_gasPrice / maxPriorityFeePerGas	Gas pricing	✓	✓	✓
net_version / web3_clientVersion	Node identity	✓	✓	✓
txpool_content	Full mempool contents	—	✓	✓
txpool_inspect	Mempool summary	—	✓	✓
txpool_status	Pending / queued counts	—	✓	✓
debug_traceTransaction	Execution trace (recent blocks)	—	—	✓

WebSocket subscriptions

eth_subscribe channels

Channel	Description	Real-Time	Mempool	Full Node
newHeads	New block headers	✓	✓	✓
logs	Filtered event logs	✓	✓	✓
pendingTransactions	Tx hashes entering mempool	—	✓	✓
newPendingTransactions (full)	Full tx objects as they enter mempool	—	✓	✓

// Raw eth_subscribe over WebSocket
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_subscribe",
  "params": ["newHeads"]
}

// Logs with topic filter
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "eth_subscribe",
  "params": ["logs", {
    "address": "0x...",
    "topics": ["0xddf252ad..."]
  }]
}

// Pending transactions (Mempool and Full Node tiers)
{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "eth_subscribe",
  "params": ["newPendingTransactions"]
}

Code examples

Connect from anywhere

JavaScript · ethers v6node / browser

import { JsonRpcProvider, WebSocketProvider } from 'ethers';

const HTTP_URL = 'https://va-bsc-01.streamsuite.io/?key=YOUR_API_KEY';
const WS_URL   = 'wss://va-bsc-01.streamsuite.io/ws?key=YOUR_API_KEY';

// HTTP
const http = new JsonRpcProvider(HTTP_URL);
const block = await http.getBlockNumber();
console.log('Head block:', block);

// WebSocket: subscribe to new blocks
const ws = new WebSocketProvider(WS_URL);
ws.on('block', (n) => console.log('newHeads', n));

// Mempool tier+: pending transactions
ws.on('pending', async (txHash) => {
  const tx = await ws.getTransaction(txHash);
  if (!tx) return;
  console.log('pending', tx.hash, tx.to, tx.value.toString());
});

Python · web3.py + websocketspython 3.10+

from web3 import Web3
import asyncio, json, websockets

HTTP_URL = "https://va-bsc-01.streamsuite.io/?key=YOUR_API_KEY"
WS_URL   = "wss://va-bsc-01.streamsuite.io/ws?key=YOUR_API_KEY"

# HTTP
w3 = Web3(Web3.HTTPProvider(HTTP_URL))
print("Head block:", w3.eth.block_number)

# Mempool tier+: raw WS subscription
async def watch_mempool():
    async with websockets.connect(WS_URL) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0", "id": 1,
            "method": "eth_subscribe",
            "params": ["newPendingTransactions"]
        }))
        async for msg in ws:
            evt = json.loads(msg)
            if "params" in evt:
                print("pending:", evt["params"]["result"])

asyncio.run(watch_mempool())

Rust · alloytokio runtime

use alloy::providers::{Provider, ProviderBuilder, WsConnect};
use alloy::rpc::types::Filter;
use futures_util::StreamExt;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let ws = WsConnect::new("wss://va-bsc-01.streamsuite.io/ws?key=YOUR_API_KEY");
    let provider = ProviderBuilder::new().on_ws(ws).await?;

    // Subscribe to newHeads
    let mut heads = provider.subscribe_blocks().await?.into_stream();
    while let Some(block) = heads.next().await {
        println!("newHead #{}", block.header.number);
    }
    Ok(())
}

Rate limits

None.

Unlimited requests on all plans. Unlimited WebSocket subscriptions. We cap clients per node instead, so you never compete with someone else's polling loop. If you hit a hardware ceiling on a single node, we'll move you to a less-loaded one — or provision a new one for you.

Node details

What you're connecting to

Chain: BNB Smart Chain mainnet (chainId 56)
Client: BSC full node, pruning mode
Block time: ~440ms (fast finality)
Location: Ashburn, VA — Tier-IV datacenter
Hardware: Bare-metal dedicated server, NVMe storage
Network: Dedicated uplink
Block history: ~32 days
Receipt history: ~5 days
Log history: ~32 days
Trace history: Recent blocks only (Full Node tier)

Ready for an API key?

Tell us what you're building and we'll get you connected within 24 hours.

Request Access See pricing