Alchemy is a blockchain infrastructure company that gives developers programmatic access to more than 100 blockchain networks through hosted RPC nodes and a layer of application APIs built on top of them. Instead of running Ethereum or Solana nodes yourself, you send API requests to Alchemy’s endpoints and get back balances, transaction data, contract state, and NFT metadata. It’s one of several providers that solve the same underlying problem — including NOWNodes, Infura, and QuickNode — and the right one for a given project depends on what the app actually needs.
Why Do Developers Need a Provider Like Alchemy?
Running a blockchain node yourself is a genuine operational commitment, not a weekend project. A synced Ethereum full node currently needs roughly 650–700 GB of disk and grows by several gigabytes a week, and it has to be re-synced or patched through every protocol upgrade the network ships.
A provider absorbs that work. You get an authenticated endpoint, the provider keeps the client software current and the hardware scaled, and your team writes application logic instead of maintaining servers. This is the same trade-off covered in more detail in what RPC nodes and endpoints actually do — the node itself is infrastructure, not product, for almost every team that isn’t building infrastructure as the product.
Here’s why that distinction matters in practice: a wallet app doesn’t need to know how Geth handles state pruning. It needs eth_getBalance to return the right number, reliably, on every request.
Who Actually Uses Alchemy?
Alchemy’s own positioning — and its enhanced NFT and token APIs — points at a specific kind of team: one building a consumer-facing product where blockchain data has to become a user interface, not just a backend value.
- Wallet apps — pulling balances, transaction history, and token metadata into a readable account view.
- NFT platforms and marketplaces — using Alchemy’s NFT API to fetch ownership data and metadata without indexing it themselves.
- DeFi dashboards — reading contract state and displaying it as portfolios, positions, or yield figures.
- Consumer Web3 apps more broadly, where users never see a raw RPC response, only a finished screen.
A backend that only checks balances and broadcasts signed transactions is a different case. It may not touch most of what Alchemy’s API layer offers, and that unused surface area is worth weighing against what a plainer RPC endpoint from a provider such as NOWNodes would cost for the same job — a point covered further in the pricing section below.
How Alchemy’s Compute Unit Pricing Works
Alchemy doesn’t bill by the request. It bills by compute unit (CU), a weight assigned to each RPC method based on how much server-side work it takes to answer. A light call like eth_blockNumber costs 10 CUs; a heavier one like eth_getLogs can cost 75 CUs or more per call, and a batch of contract reads (eth_call) runs about 26 CUs each, according to Alchemy’s own compute unit documentation.
That model is more accurate than flat per-request billing in one sense — a cheap balance check and an expensive log scan shouldn’t cost the same. The trade-off is predictability. Two apps sending the same number of requests can land on very different bills depending on which methods they lean on, which makes forecasting monthly cost harder than it is with a flat per-million-request rate.
Current Alchemy Pricing Tiers
| Plan | Price | Compute units | Requests per second |
|---|---|---|---|
| Free | $0/month | 30 million CUs | 25 RPS |
| Pay as You Go | $0.45 per million CUs (first 300M) | Pay per use | From 300 RPS |
| Enterprise | Custom | Volume-based | From 1,000 RPS |
Figures are current as of publication and change over time — check Alchemy’s pricing page before budgeting against them. The free tier is genuinely usable for prototyping: 30 million CUs covers a meaningful volume of light calls, but a workload heavy on eth_getLogs burns through that allowance faster than the raw number suggests.
Alchemy vs. Other Providers
Alchemy is one option among several that solve the same core problem differently. The table below lines up the trade-offs rather than declaring a single winner.
| Provider | Pricing model | Network coverage | Best fit |
|---|---|---|---|
| Alchemy | Compute units (method-weighted) | 100+ chains | Consumer apps needing NFT/token APIs |
| NOWNodes | Flat request quota per plan | 120+ networks | Multi-chain products, predictable-cost teams |
| Infura | Request-based, tiered | Ethereum-focused, MetaMask ecosystem | MetaMask/Consensys-adjacent teams |
| QuickNode | Credit-based, method-weighted | 70+ chains | High-volume trading and analytics apps |
NOWNodes’ shared plans work on a request-quota model instead of variable method weighting — the current pricing page lists a free Start plan with 100,000 requests, and paid tiers scale from there with a flat monthly cost per request block. For a team whose main frustration with Alchemy is not knowing what next month’s invoice will look like, that’s a structurally different answer to the same underlying question, and it covers a wider set of chains — Bitcoin, Dogecoin, Monero, and dozens of others sit alongside Ethereum and Solana under the same NOWNodes API key.
Neither model is objectively better. Method-weighted billing rewards apps that mostly make cheap calls; flat quotas reward apps that make a predictable, steady mix of everything. The right fit depends on which calls actually dominate your traffic — something worth measuring before committing to either.
Switching Providers: How Much Work Is It?
Because JSON-RPC is a standardized protocol, moving between providers is rarely a rewrite. Auston Bunsen, co-founder of QuickNode, made this point plainly in an interview with Sacra, noting that “most of the libraries are open source and provider-agnostic, so switching cost is almost nonexistent.”
That’s the practical upside of the whole category: an app built against eth_getBalance and eth_sendRawTransaction through Alchemy’s endpoint can generally point at a NOWNodes or Infura endpoint instead with a URL and API-key change, not a redesign. Method-specific quirks — rate limits, response pagination, and which enhanced APIs exist only on one platform — are the parts that actually require review before a migration.
This is also why testing a second provider isn’t a big commitment. Running a staging environment against an alternative endpoint for a week is usually enough to see whether latency, rate limits, and cost line up better than the current setup, without touching production traffic.
Limitations Worth Knowing Before You Commit
Alchemy’s feature depth is a real advantage for the apps that use it, and a real cost for the ones that don’t. The enhanced NFT and token APIs, webhooks, and dashboard tooling are built into every plan’s pricing — you’re paying for that surface area whether your app calls getNftsForOwner or never touches it.
The compute-unit model is the second thing to plan around. A getLogs-heavy indexing job or an analytics backend scanning historical events can consume its CU allowance far faster than a lighter wallet-style workload, so the advertised free-tier number is a starting point for estimation, not a guarantee of runway.
Chain coverage is the third consideration. Alchemy lists 100+ networks, which is broad but not universal — a product that needs Bitcoin, Litecoin, or privacy coins like Monero alongside its EVM chains will need to check the current network list rather than assume coverage, since several multi-chain providers, NOWNodes among them, cover a wider non-EVM range under one account.
None of these are flaws exactly — they’re the shape of a platform optimized for consumer Web3 apps first. The mismatch only shows up when the app in question isn’t that kind of product.
Conclusion
Alchemy is a solid choice for teams building consumer-facing Web3 products where NFT metadata, token balances, and webhooks need to become a polished user interface without a team building that indexing layer from scratch. Its compute-unit pricing charges for what a request actually costs to run, which is fair in principle and harder to forecast in practice.
For a backend that mostly reads balances and broadcasts transactions across several chains, a flatter, request-quota provider like NOWNodes can be the more predictable and often more cost-effective option — especially once Bitcoin, Dogecoin, or other non-EVM networks enter the picture. Since switching between standards-compliant RPC providers is largely a configuration change, there’s little reason not to benchmark both against your actual traffic before deciding where to build.
FAQ
Is Alchemy free to use?
Alchemy’s free tier includes 30 million compute units a month at up to 25 requests per second, which is enough for prototyping and light production use. Heavier or high-volume workloads move to the pay-as-you-go or enterprise tiers.
What blockchains does Alchemy support?
Alchemy currently lists support for 100+ chains, including Ethereum, Solana, Polygon, Arbitrum, Optimism, Base, and BNB Smart Chain. Coverage changes over time, so check Alchemy’s current network list for a specific chain before building against it.
Is Alchemy the same as an RPC node?
Not exactly. Alchemy operates RPC nodes and exposes them through an API, but it also adds its own layer on top — enhanced NFT and token APIs, webhooks, and a dashboard — that a bare RPC node doesn’t include.
How is Alchemy different from NOWNodes?
Alchemy bills by compute unit, weighting each RPC method by its resource cost, and focuses its extra tooling on NFT and token data for consumer apps. NOWNodes uses flat request-quota pricing and covers a broader mix of EVM and non-EVM networks — including Bitcoin, Dogecoin, and Monero — under a single API key.
Can I use more than one RPC provider at once?
Yes, and it’s a common pattern for production apps. Running a second provider as failover means an outage or rate-limit spike on one endpoint doesn’t take the whole application down with it.
