There are four practical ways to get blockchain data without running a node: managed node access, indexers, analytics platforms, and explorer APIs. The right one depends on the type of data you need, not on personal preference. Current state, deep history, and aggregated analytics each point to a different tool.
That is the thread of this article: match the data to the access method, and the choice mostly makes itself. Two worked examples show it in practice, pulling Ethereum archive data without your own archive node and looking up a Bitcoin transaction without a full node.
What Kinds of Blockchain Data Do You Need?
Blockchain data falls into three groups: current state, history, and analytics. Each answers a different kind of question and demands a different kind of access.
Current state is what the chain looks like right now: a balance, the latest block, a pending transaction. History is what the chain looked like at some earlier point, or what happened over time. Analytics is aggregated insight built on top of history, such as daily active wallets or trading volume per protocol.
| Data type | Typical questions | What it requires |
|---|---|---|
| Current state | What is this address’s balance? Did my transaction confirm? | A synced node or hosted endpoint, low latency |
| History | What was this balance at block 15,000,000? What did this contract call do? | Archived state, or an index built over past blocks |
| Analytics | Which pools gained the most liquidity this month? | Pre-aggregated, queryable datasets |
Every method below suits one row and struggles with the others. Most access mistakes come from using a current-state tool for a history question.
What Are the Four Ways to Get Blockchain Data?
The four methods are managed node access, indexers, analytics platforms, and explorer APIs. They sit on a spectrum from raw and flexible to pre-processed and narrow.
| Method | Best for | Main limit |
|---|---|---|
| Managed node access | Current state, transaction submission, past-block queries via archive | Raw data only; you build any aggregation yourself |
| Indexers (subgraphs) | App-specific, queryable data from chosen contracts | Only covers what the subgraph was written to index |
| Analytics platforms | Aggregated and cross-chain analysis | Freshness and history depth depend on the plan or dataset |
| Explorer APIs | Address and transaction lookups | Rate limits, and you depend on the operator’s index |
What Is Managed Node Access?
Managed node access means connecting to a node that someone else runs, over JSON-RPC or WebSocket, instead of operating your own. You send the same calls you would send to a local node and get the same raw answers back.
It fits teams that need the chain’s native interface: submitting transactions, reading balances, subscribing to new blocks. The strength is fidelity, since data comes straight from a node. The limit is that raw data stays raw, so “which wallets held this token last March” means writing that aggregation yourself.
What Is an Indexer?
An indexer reads chain data, transforms it, and stores it in a shape that is fast to query. On The Graph, that unit is a subgraph, which the project’s documentation describes as a custom, open API that extracts data from a blockchain, processes it, and stores it so it can be queried via GraphQL.
Indexers suit applications that need structured data from specific contracts: a DeFi dashboard, an NFT marketplace, a governance interface. The Graph’s own guidance says the model works best for apps that need their own structured, queryable data. The trade-off is coverage. A subgraph only knows about the contracts and events its author wrote handlers for, so a question outside that scope needs a different subgraph or a different tool.
What Is an Analytics Platform?
An analytics platform exposes pre-indexed, enriched chain data for querying at scale, usually through SQL or GraphQL. Examples include Dune, Bitquery, and Google BigQuery’s public crypto datasets. For a comparison of platforms and pricing, see the dedicated analytics tools guide on this blog.
Bitquery’s documentation describes pre-indexed, enriched, analytics-ready data across 40+ blockchains. The catch is depth and freshness, which vary by product. Bitquery states that its self-service plans carry a live window of recent data, with deeper history through add-ons or Enterprise.
Google’s BigQuery crypto datasets were built around batch loading. A 2019 Google Cloud post said the Bitcoin-like datasets update every 24 hours. Check current refresh behavior before relying on any dataset for time-sensitive work.
What Is an Explorer API?
An explorer API serves address and transaction lookups from an index the operator maintains, and it is the lightest way to ask “what happened to this txid.” Blockbook, the open-source indexer behind Trezor Suite, is the standard example. Its repository lists an index of addresses and address balances, fast index search, and websocket and REST interfaces, and its API supports methods such as get transaction, get address, and get utxo.
Public explorer APIs work for prototypes and occasional lookups. The limits are rate caps and dependence on one operator’s index.
How Do You Query Historical Ethereum State With Hosted Access?
You send the same state query you would send to a node, but to a hosted endpoint that keeps historical state, and you pass a past block number instead of latest. The provider holds the archive so you do not have to.
The reason this matters comes down to what each kind of node keeps. As the Geth documentation on archive mode explains, a standard node keeps one full state near the chain head. A regular full node can regenerate older state only within a recent window, which is why a request for a balance from years ago fails on a pruned setup. (For node types in general, see the guide to types of blockchain nodes on this blog.)
When Do You Actually Need Archive Data?
You need archive data when a question depends on state at a specific past block. Three cases account for most requests:
- Reading a balance at an old block with
eth_getBalance. - Calling a contract as it behaved at an old block with
eth_call. - Replaying a transaction to see internal calls with
debug_traceTransaction.
If your question is about current state or recent events, you do not need an archive at all.
How Is a Historical Block Requested?
The block parameter in the call decides the height. Per the Ethereum JSON-RPC documentation, the parameter accepts a hexadecimal block number or a tag such as latest, earliest, safe, or finalized. Passing a number instead of latest asks for state at that block.
curl https://eth.nownodes.io/YOUR_API_KEY \
-X POST \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0xYOUR_ADDRESS","0xE4E1C0"],"id":1}'Here 0xE4E1C0 is block 15,000,000 in hexadecimal. Confirm the exact endpoint format for your account in the NOWNodes documentation, since the URL pattern above is a placeholder.
How Much Disk Does Full Historical State Take?
Sizes depend on the client, and they have shifted a lot. Erigon’s documentation reports fresh measurements from July 2026 on fully synced nodes: an Ethereum mainnet archive at 2.03 TB, a full node at 419 GB.
Geth’s numbers depend on the storage scheme. Its documentation says an archive with path-based state history needs around 2 TB, rising to about 6.5 TB with full flat state alongside trie data, while a legacy hash-based archive can exceed 20 TB. Péter Szilágyi, a Geth lead developer, flagged this direction when the new storage model shipped:
“For archive node operators, the new data model will be compatible with archive nodes (and will bring the same amazing database sizes as Erigon or Reth), but needs a bit more work before it can be enabled.”
— Péter Szilágyi, Geth v1.13.0 release post, Ethereum Foundation Blog, September 2023
In practice, archive storage has fallen from tens of terabytes to roughly two on current clients. Even so, Geth’s docs note that building the archive state index alone takes about 30 hours on mainnet.
When Is an Indexer or Analytics Platform Better?
Use an indexer or analytics platform when the question is about many blocks at once, not one block. “What was this address’s balance at block X” is an archive question. “How did total value locked change across every block last year” is an aggregation question, and answering it with thousands of archive calls wastes effort a pre-built dataset already spent. For event-specific queries, the guide to fetching smart contract events covers eth_getLogs and subscriptions.
How Do You Run a Bitcoin txid Lookup Without Hosting the Chain?
Query an indexed API that already maps every transaction ID to its block, rather than asking a bare Bitcoin Core node. The reason a plain node often cannot answer is by design.
Why Can’t Bitcoin Core Return Any Transaction by ID?
By default, Bitcoin Core only finds mempool transactions. The official getrawtransaction reference states that without a block hash the call returns the transaction only if it is in the mempool, or if -txindex is enabled and the transaction is in a block. With a block hash supplied, it can return the transaction if the node has that block available.
Two consequences follow. A node without -txindex cannot look up an arbitrary txid, because it keeps no map from IDs to blocks. And a pruned node may have discarded the block itself, so even a known block hash can fail. Bitcoin Core developers have discussed this friction openly, including a pending proposal to let the transaction index run on pruned nodes.
What Are Your Options for txid Lookup?
Three routes work, and they trade convenience against control:
- Indexed API such as Blockbook. It maintains its own address and transaction index, so a txid lookup is a single REST call.
- Hosted RPC with a transaction index. You keep the Bitcoin Core call format, but the node behind it runs with
-txindex. - Public explorer APIs. Fine for occasional checks, limited by rate caps.
Running Blockbook yourself is a real commitment: the project documents around 32 GB of RAM and over 180 GB of disk for the initial Bitcoin mainnet sync. That footprint is why hosted access exists. For how Bitcoin’s transaction model differs from account-based chains, see the UTXO vs account model guide on this blog.
What Does Managed Access With NOWNodes Look Like?
NOWNodes is a node infrastructure provider that covers several of the methods above through one account. Its network coverage is 120+ blockchains, according to its Ethereum node page, and several pieces map directly onto the framework in this article.
| Need | What NOWNodes offers | Where |
|---|---|---|
| Current state | Shared and dedicated nodes over RPC and WSS | Ethereum, Bitcoin |
| History | Archive nodes on 45+ networks, plus Trace and Debug API on supported EVM networks | Archive nodes |
| Indexed lookups | Blockbook API on 30+ networks, including Bitcoin and Ethereum | Blockbook |
Two counts affect method choice. Archive support spans 45+ networks and varies by chain, so check yours. Blockbook covers 30+ networks, a subset of the full 120+.
On pricing structure, the pricing page lists a free Start plan with 100,000 requests per month and one API key. Its WebSocket connection is not included on Start, while paid tiers add it. The Bitcoin and Ethereum pages state that there are no predefined RPS limits on paid plans. Read that narrowly: it describes per-second throttling, and monthly request allowances still apply.
For Bitcoin, the endpoint page lists RPC, Blockbook, archive mode, WSS, and a webhook service. The webhook service is limited: it currently covers address-balance changes on Bitcoin and Dogecoin only, with a maximum of five addresses per configuration, and it is in free beta.
How Do You Choose a Method?
Start from the data type, then check the constraint that matters most for your use case. No method is best without a condition attached.
| If you need… | Reach for… | Watch out for |
|---|---|---|
| Live balances, sending transactions | Managed node access | Monthly request allowance |
| State at a specific past block | Archive endpoint | Not every network offers archive |
| Structured data from your own contracts | Indexer (subgraph) | Coverage limited to what you indexed |
| Aggregated or cross-chain analysis | Analytics platform | Data window and refresh rate |
| Address or txid lookups | Blockbook-style indexed API | Operator’s index is your dependency |
Beyond the table, five trade-offs deserve attention:
- Freshness. Indexers and analytics datasets lag the chain by an amount that varies by product. Check it before using one for anything time-critical.
- Rate limits. Free tiers and public explorer APIs cap throughput. Production workloads usually need a paid plan.
- Cost. Historical queries at scale can cost more in requests than a pre-built dataset would.
- Lock-in. Custom subgraphs and proprietary schemas are harder to move than standard JSON-RPC calls.
- Trust. You rely on a third party’s data being correct. For high-stakes decisions, cross-check against a second source.
Conclusion
Every method here answers the same question: what kind of data do you need? Current state points to a node endpoint, a past block to archive state, aggregation to an indexer or analytics dataset, and a single transaction to an indexed API.
Pick the lightest tool that fits, and revisit the choice when the question changes. The common mistake is defaulting to one tool for everything, since each breaks down outside its own row of the table.
FAQ
Does a light client remove the need for a provider?
Not for most applications. A light client verifies block headers and fetches proofs on demand, which suits simple balance checks, but it does not serve historical state, aggregated queries, or transaction search. Apps needing those still depend on an external data source.
How fresh is indexer data compared with a node?
Indexer data trails the chain by the time it takes to process each block, and that gap varies by indexer and load. A node’s answer reflects its own sync state directly. For anything time-critical, check the indexer’s reported sync status.
Does historical data cost more on hosted plans?
It depends on the provider’s pricing model. Some providers meter archive requests separately or reserve them for higher tiers, while others include them in the standard allowance. Check the provider’s current pricing page before budgeting for history-heavy workloads.
What happens when a provider prunes old data?
Queries for pruned ranges fail or return errors, the same way they would on your own pruned node. Providers that offer archive access keep the full state for those networks. Confirm archive support for your specific chain, since it is not universal.
Are explorer APIs safe for production use?
They work for low-volume production use, but rate limits and dependence on a single operator’s index are the risks. For traffic that cannot tolerate throttling or outages, a paid indexed API with a published uptime commitment is the safer choice.
