NOWNodes and GetBlock solve the same underlying problem — giving an application access to blockchain data without anyone on the team running a node — but they get there through different pricing logic and a different bundle of extras. NOWNodes covers 120+ networks under a flat request quota, with WebSockets, Blockbook, gRPC streaming, and market data folded into the same account. GetBlock covers a slightly wider 130+ networks and leans into compute-unit billing plus compliance tooling like SOC 2 Type II and wallet-risk screening. For most teams past the prototyping stage, the practical difference comes down to cost predictability and how much you’d otherwise have to stitch together yourself.
What Are NOWNodes and GetBlock, Exactly?
NOWNodes is a blockchain infrastructure provider that gives developers API-based access to shared and dedicated nodes across 120+ networks, from Bitcoin and Ethereum to Solana, Polygon, and privacy coins like Monero. You get an endpoint and an API key; NOWNodes runs, syncs, and maintains the node behind it.
GetBlock is a node-as-a-service platform founded in 2019 that now lists support for 130+ blockchain networks and says it serves over 1,000 active companies, according to GetBlock’s own leadership announcement. It exposes hosted nodes through RPC, REST, and WebSocket connections, and layers on separate compliance and analytics products.
RPC (remote procedure call) is the mechanism underneath both services: a way of asking a remote server to run a function — say, “return this address’s balance” — and getting the result back over the network. Every blockchain client exposes its data this way, and that shared standard is why swapping providers rarely means rewriting an app’s core logic.
Why Do You Need a Provider Like NOWNodes or GetBlock?
Running a node yourself is a real operational commitment, not a weekend project. A synced Ethereum full node needs roughly 650–700 GB of disk and keeps growing, and an archive node — one that retains complete historical state — can run into multiple terabytes depending on the client, according to Ethereum’s own explanation of node types.
That’s before counting uptime. A node that goes down mid-deposit-check or during a transaction broadcast becomes your outage, not a background inconvenience that someone else patches overnight. A provider absorbs that job: it keeps the client software current, scales hardware under load, and hands you an authenticated endpoint instead of a server to babysit.
Here’s why that distinction matters day to day: a payment backend doesn’t need to know how Erigon prunes state. It needs eth_getBalance to return the correct number, on every call, without an engineer getting paged at 2 a.m.
Who Actually Uses NOWNodes vs. GetBlock?
NOWNodes tends to attract teams whose product spans several blockchains at once — wallets, exchanges, and payment platforms that want Bitcoin, Ethereum, and a dozen other chains under one account rather than a separate vendor per network. Trading tools and monitoring systems that lean on WebSocket or gRPC streaming fit the same profile.
GetBlock’s stated customer base spans similar categories, but a few stress different parts of its platform: DeFi protocols making repeated contract reads, NFT marketplaces querying metadata across chains, and compliance-focused teams using its separate AML and wallet-risk-screening products.
| Use case | Better fit with NOWNodes | Better fit with GetBlock |
|---|---|---|
| Multi-chain wallet or exchange (BTC + ETH + others) | Yes — one account, flat quota | Works, but pricing scales with method mix |
| Compliance-heavy product needing AML/risk screening | Not a built-in product | Yes — dedicated risk and screening tools |
| Trading bot needing predictable monthly cost | Yes — flat request quota | Depends on compute-unit consumption |
| Backend that mostly checks balances and broadcasts transactions | Yes — lighter, cheaper fit for light calls | Works, but shared-tier entry price is steeper |
| Team that already needs SOC 2 Type II attestation | Not currently published | Yes — GetBlock holds this attestation |
A backend built around a handful of light RPC methods rarely touches most of what either platform’s add-on layer offers — which is exactly why the entry-tier price, not the feature list, tends to decide the comparison for that kind of team.
How Does the Pricing Actually Compare?
This is where the two providers diverge the most, and it’s worth walking through slowly because the billing logic itself — not just the sticker price — changes what a given month costs.
NOWNodes: Flat Request Quotas
NOWNodes’ shared plans bill on a flat request-quota model: pick a monthly tier, get a fixed number of requests, and every call counts the same against that number regardless of how much server work it took to answer.
| Plan | Price | Requests/month | API keys |
|---|---|---|---|
| Start | Free | 100,000 | 1 |
| Pro | €20/month | 1,000,000 | 3 |
| Business | €200/month | 30,000,000 | 25 |
| Enterprise | €500/month | 100,000,000 | 100 |
GetBlock: Compute Units
GetBlock bills through Compute Units (CUs), a weight assigned to each method based on server-side cost. A light call like checking a balance costs far fewer CUs than a heavy one like scanning event logs, so two accounts making the same number of requests can burn through very different budgets.
| Plan | Price | Limits |
|---|---|---|
| Free | $0 | 50,000 CUs/day, indefinite |
| Pro (Shared) | $399/month (billed yearly) | Configurable CU tiers, 800 RPS, ~150 endpoints |
| Limitless Node | Custom, flat-rate | Guaranteed RPS, no CU tracking |
| Dedicated Node | From $1,000/month | Unlimited RPS, hardware-bound, 99.99% uptime SLA |
That jump from GetBlock’s $399 shared tier to a $1,000-plus dedicated node is steep for a team that has simply outgrown the free plan. NOWNodes’ Pro plan, by contrast, runs €20 a month for a million monthly requests — a meaningfully lower cost of entry for a team past the prototyping stage but nowhere near enterprise volume yet.
Pricing on both platforms changes often, so treat these figures as a snapshot to verify against NOWNodes’ current pricing page and GetBlock’s pricing page before budgeting.
Network and Feature Coverage
GetBlock’s 130+ networks edge out NOWNodes’ 120+, but raw chain count rarely decides a real integration on its own. What matters more is which interfaces exist on the specific chain you need, and which extras come bundled instead of billed separately.
| Feature | NOWNodes | GetBlock |
|---|---|---|
| Network coverage | 120+ blockchains | 130+ blockchains |
| RPC / WebSocket | Yes, on supported networks | Yes, on supported networks |
| Blockbook (indexed queries) | Yes, 30+ networks | Not a named product |
| gRPC streaming | Yes, 25+ blockchains | Not a named product |
| Market Data API | Yes, 9,000+ cryptocurrencies | Separate market-data product |
| Compliance / AML tooling | Not currently published | Yes — wallet risk checks, contract screening |
| Security attestation | Not currently published | SOC 2 Type II |
| MCP Server for AI coding tools | Yes | Not a named product |
NOWNodes bundles WebSocket, Blockbook, gRPC streaming, and market data under one account, so a multi-chain wallet or exchange gets node access, streaming updates, and price data without stitching together separate vendors. GetBlock’s edge sits on the compliance side: SOC 2 Type II attestation and built-in wallet-risk screening are the kind of checkbox a regulated fintech customer may ask for before signing a vendor contract.
Does GetBlock’s Compliance Tooling Matter for Most Teams?
Only if you’re already required to show it. SOC 2 Type II is a security-controls audit, and some enterprise procurement processes won’t move forward without one attached to a vendor.
For a team building a wallet, a trading bot, or a payment backend without that procurement requirement, the attestation itself changes nothing about how the API behaves day to day. It’s a genuine differentiator for GetBlock, but a narrow one — worth weighing against NOWNodes’ broader bundled interface set only if compliance sign-off is actually part of your buying process.
How Locked In Are You to Either Provider?
Because JSON-RPC is a standardized protocol, moving core RPC traffic between providers is usually a configuration change, not a rewrite. Auston Bunsen, co-founder of QuickNode, described the same dynamic in an interview with Sacra: “I can go from Alchemy to Infura to QuickNode relatively quickly, unless I’m using one of their sort of custom APIs.”
That caveat carries over here. An app built purely against eth_getBalance and eth_sendRawTransaction can point at a new endpoint with a URL and key change. An app leaning on GetBlock’s compliance dashboards or NOWNodes’ gRPC subscriptions has real migration work to do if it ever needs to leave, because those specific products don’t have drop-in equivalents elsewhere.
Which One Should You Choose?
Is NOWNodes cheaper than GetBlock for a growing app? Generally, yes, once you’re past the free tier — €20 a month for a million requests is a lower entry point than GetBlock’s $399 shared plan, and the flat quota means the bill doesn’t shift with which methods you happen to call most.
Is GetBlock better than NOWNodes for a compliance-driven fintech product? For that specific case, GetBlock’s SOC 2 Type II attestation and built-in AML tooling save real vendor-vetting and engineering time, provided your workload fits inside a compute-unit budget.
The honest framing: these are two different bets on where a team’s time is worth spending. NOWNodes bets that broad chain coverage, bundled streaming and market-data tools, and predictable flat pricing beat a slightly longer network list. GetBlock bets that its compliance layer and per-method documentation are worth a steeper entry price for teams that need them. Map your actual method mix, chain list, and compliance requirements against both before committing — a short staging test against each endpoint answers the question faster than any pricing page.
Limitations Worth Knowing Before You Commit
GetBlock’s compute-unit model rewards light, simple calls and penalizes heavier ones — a workload leaning on event-log scans or deep contract calls can burn through a monthly CU allowance far faster than the headline price suggests. Budgeting for it means modeling your actual method mix, not the cheapest example on a pricing page.
NOWNodes’ flat quota removes that particular guesswork but comes with its own ceiling: once you exceed a plan’s request allowance, you either upgrade or pay per-100k overage rates, regardless of whether those extra requests were cheap or expensive to serve. And unlike GetBlock, NOWNodes doesn’t currently publish a security attestation such as SOC 2, which can matter for a specific class of enterprise buyer even if it changes nothing about API reliability.
Relying on a single RPC provider of any kind creates a dependency: if that provider has an outage, your application inherits it. Running a second provider as failover — NOWNodes’ node directory covers 120+ networks under one account if you’re consolidating rather than splitting — is the standard mitigation for anything handling real user funds.
Conclusion
GetBlock and NOWNodes both give you API access to blockchain nodes instead of a server to maintain, but they’re built for different priorities. GetBlock’s compliance attestation and per-method documentation suit a team that specifically needs AML tooling or SOC 2 sign-off and can plan around compute-unit billing. NOWNodes’ broader bundled feature set — RPC, WebSockets, Blockbook, gRPC streaming, and market data under one flat-quota account — tends to fit more teams by default, especially multi-chain wallets, exchanges, and trading tools that want predictable billing without assembling several vendors. Since standard JSON-RPC calls migrate between providers with little more than a URL change, testing NOWNodes’ dedicated node infrastructure or shared plan against your real traffic for a week is cheaper than guessing from a pricing page.
FAQ
Is NOWNodes cheaper than GetBlock?
For most workloads past the free tier, yes. NOWNodes’ Pro plan starts at €20/month for 1,000,000 requests, while GetBlock’s shared Pro plan starts at $399/month, and its jump to a dedicated node runs from $1,000/month.
Does NOWNodes have a SOC 2 attestation like GetBlock?
Not currently published. GetBlock holds SOC 2 Type II attestation; if that specific certification is a procurement requirement for your organization, it’s worth confirming directly with each provider before choosing.
Which provider supports more blockchain networks?
GetBlock lists 130+ networks against NOWNodes’ 120+, a narrow gap that matters most if your specific chain sits in the small set GetBlock covers and NOWNodes doesn’t, or vice versa — worth checking chain-by-chain rather than by headline count.
Can I use NOWNodes and GetBlock together?
Yes. Running two RPC providers side by side — one as primary, one as failover, or split by chain — is a common production pattern that limits how much a single provider’s outage or rate-limit spike can affect your app.
Does GetBlock’s compute-unit billing make it more expensive than NOWNodes?
It depends on your method mix. Light, simple calls can cost less on a CU basis, but heavier methods like event-log scans consume CUs fast, while NOWNodes’ flat quota charges the same for every request regardless of weight.
