If you build on Sui, you’re already on a clock. JSON-RPC — the interface nearly every blockchain app has relied on for years — is being switched off, and gRPC is what takes its place. That’s bigger than one chain, and it just landed on NOWNodes.
gRPC is now live across more than twenty networks, on both Shared and Dedicated plans. So what is gRPC? In plain terms, it’s a fast way for your app to ask a node for data and get an answer back — smaller messages, one open connection, and real streaming instead of polling on a timer.
Here’s the short version: if your app lives or dies by how fast it sees on-chain data, this is the gRPC upgrade worth paying attention to. Below — what shipped, how to wire it up, and how gRPC stacks up against the interfaces you already use.
What’s New: gRPC Is Live on NOWNodes
Nothing you’ve already built breaks. Your JSON-RPC and WebSocket endpoints keep working exactly like they did yesterday. gRPC just sits next to them, a faster lane for the data-heavy, latency-sensitive jobs where the older interfaces start to sweat.
Why is gRPC quicker? Two reasons, mostly. Messages go out as compact binary instead of text, so they’re smaller. And one connection juggles many requests at once instead of opening a fresh one every time you ask for something. Pull blocks, balances, and events at any real volume and you’ll feel it: less overhead, fresher data.
Which Blockchains Support gRPC
For now NOWNodes is supporting only 5 networks: TRON, SUI, Kaspa, IOTA and XRP.
In new future, The rollout will cover 20+ networks, heavy on the Cosmos side plus a handful of big Layer 1s.
Cosmos and app-chains: Cosmos Hub (ATOM), Osmosis (OSMO), Celestia, Injective (INJ), Akash, Axelar, Kava, Band Protocol (BAND), Stride (STRD), Agoric (BLD), Coreum, Fetch.ai (FET), Babylon, Sei, Terra (LUNA), Terra Classic (LUNC), and ZetaChain.
Other major networks: Solana (SOL), Aptos (APT), TRON (TRX), XRP, and Hedera (HBAR).
Every one of those now speaks gRPC for low-latency, real-time reads. Running across several chains? One consistent gRPC setup beats stitching together a different approach per network — that’s a lot less code to babysit.
Shared or Dedicated
You don’t need a big plan to try this. A Shared node is the cheap way in: there are rate limits, since you’re sharing it, but latency stays under 200 ms across the main US and Europe regions. Fine for testing, and fine for plenty of production traffic too.
Outgrow that, and a Dedicated node is yours alone — no shared limits, full method access, throughput capped only by the hardware it runs on. Most teams start on Shared and graduate to Dedicated when traffic picks up.
Why Now: Sui Is Retiring JSON-RPC
Here’s the part with a clock on it. Sui is shutting JSON-RPC down, and they’re not being shy about the date. Straight from Sui’s migration guide: “JSON-RPC is deprecated and is planned for deactivation in July 2026.”
And they mean soon. Testnet endpoints go dark the week of July 6, mainnet the week of July 20, with gRPC named as the replacement for full node access. If you’re on Sui, this stopped being optional. Whether the switch is painless or a fire drill mostly comes down to one question: does your provider already support gRPC?
How to Get Started: A Short gRPC Tutorial
You don’t need much to kick this off. gRPC is contract-first, which sounds fancier than it is — you describe a gRPC Service in a file, generate code from that file, then call it like any normal function in your project. Here’s the path most people take to a first working call. Think of it as a short gRPC tutorial, not a full manual.
- Grab your endpoint and API key from NOWNodes for the network you want.
- Install the toolchain — the Protocol Buffer compiler (protoc) and the gRPC plugin for your language. TypeScript, Java, take your pick.
- Drop in the .proto file for your target network. This is the contract: the methods you can call and the shape of every message.
- Run the compiler to generate the client stub. Now you’ve got typed functions, and your editor will autocomplete them and catch typos before you ever hit run.
- Open a channel to the NOWNodes gRPC endpoint, authenticate with your key, and call a method.
- Want live data? Use a streaming method and read responses as they land, instead of waiting on a single reply.
Do yourself a favor and start with one plain unary call — one request, one response — just to prove the connection and your key actually work. Once that’s green, point a streaming method at something live, like block or checkpoint subscriptions.
One small trick pays off right away: pass a FieldMask so the server only sends back the fields you’ll actually use. Smaller responses, less latency on every call, about a minute to set up. The copy-paste examples for each language live in the NOWNodes documentation.
What Is the gRPC Protocol?
Let’s back up for anyone meeting gRPC for the first time. gRPC (it stands for gRPC Remote Procedure Calls) is an open-source framework Google built and released in 2015 to make programs talk to each other fast, even when they sit on different machines.
In blockchain terms, it’s dead simple. You call something like getBalance in your code, and gRPC quietly handles the network request, the encoding, and the reply. You get on-chain data back without ever hand-writing an HTTP request.
What Actually Makes It Fast
Two pieces do the work. Protocol Buffers (protobuf.dev) pack your data into compact binary instead of text — smaller, quicker to read. HTTP/2 (RFC 9113) then lets a pile of those messages share one connection at the same time, instead of opening a new one for every single call.
That’s the whole trick, really — small messages, and one connection doing the work of many. Pretty much everything people mean by “gRPC is fast” traces back to those two.
Protocol Buffers: Google’s language-neutral way of turning structured data into compact binary, defined once in a .proto file that the client and server both share.
Built for Streaming
gRPC handles four kinds of calls: unary (one request, one response), server streaming, client streaming, and both directions at once.
For blockchain, gRPC streaming is the headline. A node can push new blocks, checkpoints, and events straight to your gRPC client the second they happen — no more hammering the same endpoint over and over just to ask “anything new yet?”
gRPC vs JSON-RPC for Blockchain Data
Almost every chain hands you data over JSON-RPC today — plain text, dead easy, supported by every Web3 library out there (Ethereum JSON-RPC spec). On EVM chains it’s not going anywhere, and for a quick read or firing off a transaction, it’s still the path of least resistance.
So what does gRPC actually change? Two things: binary instead of text, and streaming baked in. In practice, Protocol Buffers messages come out around three times smaller than the JSON version and parse faster (Gravitee benchmark).
On one balance check, you’ll never notice. On an indexer crunching every block, that gap turns into real money — less bandwidth, lower latency, fewer headaches.
| Feature | JSON-RPC | gRPC |
| Data format | JSON (text) | Protocol Buffers (binary) |
| Transport | HTTP / WebSocket | HTTP/2 |
| Streaming | Via WebSockets | Native (4 modes) |
| Payload size | Larger | ~3x smaller (typical) |
| Best for | Wallets, dApps, quick reads | Indexers, bots, data pipelines |
WebSockets vs gRPC for Real-Time Data
For live data, the matchup that matters is WebSockets vs gRPC. A WebSocket is a raw two-way pipe: messages flow both ways, but it doesn’t care what they look like, so your code parses whatever JSON shows up and prays the format never changes.
gRPC streaming sends strongly typed Protocol Buffer messages over HTTP/2 instead. Your client knows exactly what each update looks like before it arrives, the frames are smaller, and the parsing code basically writes itself.
On some chains, this already stopped being a debate. Sui’s own guide says it flat out — “WebSocket subscriptions are replaced by gRPC streaming” — and hands you a checkpoint subscription that streams finalized data in order. Once a network drops WebSocket subscriptions, the WebSockets vs gRPC question answers itself.
Who Actually Needs gRPC?
gRPC earns its place when volume and timing are the hard part. Block indexers, bots watching the mempool, live dashboards, exchange backends reconciling balances — anything that reads a ton of data, fast. All of them win with binary payloads and push-based streaming.
Sui spells out the same idea, pointing to gRPC for “backend services, indexers, and exchange pipelines” and “workloads where protocol overhead, message size, and tail latency matter.” Sound like your project? Then gRPC is aimed squarely at it.
And no, this isn’t some unproven experiment. CockroachDB and plenty of other large systems have run gRPC in production for years. That same reliability now sits behind on-chain data on NOWNodes.
A Couple of Things You’ll Thank Yourself For Later
Two things you won’t think about on day one but will be glad for down the line.
First, security. gRPC runs over TLS by default and supports mutual authentication, so the client and server check each other before a single byte moves. For anything touching money, that’s not negotiable.
Second, it ages well. Protocol Buffers only ever add fields, they never repurpose them, so when a provider extends a gRPC Service, older clients just skip what they don’t recognize instead of falling over. Your integration keeps humming as networks change and as NOWNodes adds coverage — you upgrade when it suits you, not when someone forces your hand.
The Bottom Line
gRPC isn’t here to bury JSON-RPC. For wallets and small dApps, JSON-RPC is still the obvious pick, and that won’t change. What’s new is that data-hungry, streaming-first apps finally have a faster option in gRPC when they need one.
But the ground is shifting. Sui kills JSON-RPC in July 2026, WebSocket subscriptions are handing off to gRPC streaming, and the gap between a calm migration and a chaotic one mostly comes down to whether your provider is ready.
FAQ
What is the gRPC Protocol, in plain English?
gRPC lets your app call functions on a remote node as if they were sitting in your own code. Under the hood it’s Protocol Buffers for compact binary messages and HTTP/2 for transport, which is what makes it quicker than text-based interfaces. For blockchain, that’s a fast way to read on-chain data and subscribe to live updates.
Which blockchains support gRPC on NOWNodes?
For now NOWNodes supports only 5 networks: Tron, Kaspa, IOTA, XRP and SUI. In Future NOWNodes plans support more than twenty, including Cosmos Hub, Osmosis, Celestia, Injective, Akash, Axelar, Kava, Band Protocol, Stride and more.
Is gRPC actually faster than JSON-RPC?
On payload size and parsing, yes — Protocol Buffers are several times smaller and quicker to decode than JSON. For heavy streaming and big pipelines, that lead is real. For a single read it matters less, since the call still waits on the node to do its thing.
WebSockets vs gRPC — what’s the real difference?
Both give you live, continuous data, but a WebSocket is an untyped pipe where you parse everything yourself, while gRPC streaming sends typed messages over HTTP/2. gRPC throws in type safety, smaller frames, and generated client code on top. A few networks, Sui included, are swapping WebSocket subscriptions for gRPC streaming.
Where’s the gRPC documentation?
For the NOWNodes side — endpoints, keys, sample code — check the NOWNodes gRPC documentation. For the framework itself, the official gRPC documentation and protobuf.dev are the ones to bookmark.
