Stream real-time transactions on Base

import asyncio
import itertools
import json

import websockets

WSS = "YOUR_CHAINSTACK_WSS_ENDPOINT"  # wss://base-mainnet.core.chainstack.com/<key>


async def stream_blocks():
    ids = itertools.count(2)
    pending = {}  # request id -> future

    async with websockets.connect(WSS, max_size=None) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0", "id": 1,
            "method": "eth_subscribe", "params": ["newHeads"],
        }))

        async def get_block(block_hash):
            request_id = next(ids)
            result = asyncio.get_running_loop().create_future()
            pending[request_id] = result
            await ws.send(json.dumps({
                "jsonrpc": "2.0", "id": request_id,
                "method": "eth_getBlockByHash", "params": [block_hash, False],
            }))
            return await result

        async def on_head(head):
            block = await get_block(head["hash"])
            print(int(block["number"], 16), len(block["transactions"]), block["transactions"][0])

        async for raw in ws:
            message = json.loads(raw)
            if message.get("method") == "eth_subscription":
                asyncio.create_task(on_head(message["params"]["result"]))
            elif message.get("id") in pending:
                pending.pop(message["id"]).set_result(message["result"])


asyncio.run(stream_blocks())

// Node.js 22+ has a built-in WebSocket — no dependencies required.
const WSS = "YOUR_CHAINSTACK_WSS_ENDPOINT"; // wss://base-mainnet.core.chainstack.com/<key>

const ws = new WebSocket(WSS);
const pending = new Map(); // request id -> resolve
let nextId = 2;

function getBlock(blockHash) {
  const id = nextId++;
  ws.send(JSON.stringify({ jsonrpc: "2.0", id, method: "eth_getBlockByHash", params: [blockHash, false] }));
  return new Promise((resolve) => pending.set(id, resolve));
}

ws.addEventListener("open", () => {
  ws.send(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_subscribe", params: ["newHeads"] }));
});

ws.addEventListener("message", async (event) => {
  const message = JSON.parse(event.data);
  if (message.method === "eth_subscription") {
    const block = await getBlock(message.params.result.hash);
    console.log(parseInt(block.number, 16), block.transactions.length, block.transactions[0]);
  } else if (pending.has(message.id)) {
    pending.get(message.id)(message.result);
    pending.delete(message.id);
  }
});

import asyncio
import json

import websockets

WSS = "YOUR_CHAINSTACK_WSS_ENDPOINT"
USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
TRANSFER = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"


async def stream_logs():
    async with websockets.connect(WSS) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0",
            "id": 1,
            "method": "eth_subscribe",
            "params": ["logs", {"address": USDC, "topics": [TRANSFER]}],
        }))
        await ws.recv()  # subscription id

        async for raw in ws:
            message = json.loads(raw)
            if message.get("method") == "eth_subscription":
                log = message["params"]["result"]
                print(int(log["blockNumber"], 16), log["transactionHash"], int(log["data"], 16))


asyncio.run(stream_logs())

// Node.js 22+ has a built-in WebSocket — no dependencies required.
const WSS = "YOUR_CHAINSTACK_WSS_ENDPOINT";
const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const TRANSFER = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";

const ws = new WebSocket(WSS);

ws.addEventListener("open", () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_subscribe",
    params: ["logs", { address: USDC, topics: [TRANSFER] }],
  }));
});

ws.addEventListener("message", (event) => {
  const message = JSON.parse(event.data);
  if (message.method === "eth_subscription") {
    const log = message.params.result;
    console.log(parseInt(log.blockNumber, 16), log.transactionHash, BigInt(log.data));
  }
});