Connect
Your client opens a gRPC connection to a NOWNodes endpoint and authenticates with a token.
Multichain gRPC streaming
Stream real-time on-chain data over gRPC from a single provider — transactions, accounts, blocks, and slots with low latency.
25+
Blockchains
99,95%
Blockchains
< 200 ms
Stream latency
Unlimited
RPS on paid plans
24/7
Support
What is gRPC streaming?
gRPC streaming is a high-performance way to receive blockchain data the moment it is produced — instead of repeatedly polling a node for updates.
You open one persistent connection, subscribe to the data you care about, and the node pushes every relevant event to you in real time.
stream.ts
// [code snippet — tech team will insert real example]
import { Client } from "@nownodes/grpc";
const client = new Client(
"<your-grpc-endpoint>",
"<your-token>"
);
const stream = await client.subscribe({
transactions: { accountInclude: ["..."] },
commitment: "confirmed"
});
stream.on("data", (update) => {
console.log(update);
});How gRPC streaming works
A single long-lived connection between your backend and a NOWNodes endpoint, running separately from standard RPC traffic.
Subscribe
Send a subscribe request with filters — specific accounts, programs, transactions, or slots.
Stream
Receive a continuous flow of protobuf-encoded updates as matching events occur on-chain.
Commitment
Choose processed, confirmed, or finalized delivery to balance speed against finality.
Stream with NOWNodes gRPC
Everything you need for production-grade real-time pipelines, across every supported network.
Low latency
Receive transactions, accounts, and blocks within milliseconds of them being produced. No polling delay.
Typed protobuf
Every update arrives as a compact, strongly typed message. Clean integration, small payloads even at scale.
Granular filtering
Subscribe to exactly what you need — accounts, programs, transaction types, or slots. Less noise, less bandwidth.
Auto-reconnect & replay
Recover gracefully from disconnects and replay recent slots so you don't miss critical events.
Multichain coverage
Stream from 25+ networks through one account. No separate vendors or per-chain contracts to manage.
gRPC vs WebSocket vs JSON-RPC
Different data needs call for different protocols. Here's where gRPC fits.
JSON-RPS
WebSocket
gRPS
Data model
Pull (polling)
Push (subscribe)
Push (subscribe)
Latency
Higher
Low
Lowest
Payload format
JSON
JSON
Typed protobuf
Throughput
Limited by polling
Good
High
Filtering
Basic
Moderate
Granular
Best for
Simple reads
Light real-time
High-volume pipelines
JSON-RPS
Data model
Pull (polling)
Latency
Higher
Payload format
JSON
Throughput
Limited by polling
Filtering
Basic
Best for
Simple reads
WebSocket
Data model
Push (subscribe)
Latency
Low
Payload format
JSON
Throughput
Good
Filtering
Moderate
Best for
Light real-time
gRPS
Data model
Push (subscribe)
Latency
Lowest
Payload format
Typed protobuf
Throughput
High
Filtering
Granular
Best for
High-volume pipelines
What you can build
Real-time data unlocks the latency-sensitive parts of your stack.
Trading bots, MEV & microservices
Latency is critical for on-chain trading and microservices. gRPC delivers instant account and transaction updates — the earliest signal to act on.
DeFi dashboards & DEXs
Show users live balances, prices, and positions. Continuous structured data keeps your interface in step with current on-chain state.
Real-time indexers & analytics
Keep indexes and dashboards in sync without hammering RPC endpoints. Stream blocks and transactions straight into your database with minimal lag.
Wallet & program monitoring
Track specific wallets, programs, or contracts in real time for alerts, compliance, or automation. Subscribe to exactly the accounts you care about.
Teams building on NOWNodes
FAQ
Why should I use gRPC instead of my current setup?
gRPC moves data as compact binary over HTTP/2 and streams updates in real time, so your app gets smaller responses, lower latency, and live on-chain events without repeated polling. In practice: an indexer syncs on payloads roughly 3x smaller than JSON, a trading bot catches a new pool the instant it's created instead of on its next poll, and a dashboard reflects on-chain changes as they happen.
Will adding gRPC break my existing integration?
No. gRPC is an additional interface, not a replacement. Your current HTTPS and WebSocket endpoints keep running unchanged, so you can adopt gRPC gradually — one service at a time — with zero downtime. The exception is Sui: the network is retiring JSON-RPC (public endpoints shut down in July 2026), so gRPC is the interface you'll need to migrate to.
How do I connect to a gRPC endpoint?
To connect through NOWNodes, create an account, generate an API key, and point your gRPC client at the endpoint for your chosen network. Add the network's .proto definition, generate a client with protoc, and make your first call.
Can I start on Shared, or do I need a Dedicated node?
If you need to connect to several networks, you can start with a Shared plan, which keeps latency under 200 ms across key US and Europe regions. Move to a Dedicated node when you want private infrastructure, no shared rate limits, and full method access.
What does gRPC cost?
On a Shared plan, it's metered like any other call: one gRPC request to the node counts as one request against your plan quota. Check the pricing page for current tiers and limits.
Stream blockchain data via gRPC quickly
Get real-time data from 25+ networks through one provider. Start on a Shared plan or deploy a Dedicated node built for your workload.
