Alchemy - Blockchain APIs Without the Node Management Hell

If you've ever tried running your own Ethereum node, you know it's a special kind of hell. Initial sync takes 2-3 days minimum, storage requirements are somewhere north of 1TB+ for a full node (could be more by now), and it'll randomly fall out of sync during high network activity. Our staging environment went down because the WebSocket connection dropped and we didn't have retry logic - classic fucking mistake. Plus I think it was Geth 1.13.0 or maybe 1.12-something that had this weird bug where valid transactions would just get rejected during high gas periods. Still not sure if that was a node issue or just the network being fucked.

Alchemy handles the node infrastructure so you don't have to deal with that nightmare. It's basically managed blockchain access - you get JSON-RPC endpoints that actually work reliably instead of randomly deciding to hate you.

What You Get Instead of Node Headaches

The basic deal is simple: instead of running geth or erigon on your own servers (and dealing with 1TB+ storage requirements that somehow always fill up your disk at 3am on weekends), you point your app to Alchemy's endpoints. Your web3.js or ethers.js calls work exactly the same, just way more reliable.

Free tier gets you 30M compute units monthly, which covers most development work. Production apps burn through CUs faster - enhanced APIs like NFT data cost more but save you from building your own indexer.

Networks That Actually Matter

Supports the chains people actually use in production:

• Ethereum mainnet - obviously, plus Sepolia testnet for testing
• Layer 2s - Arbitrum, Optimism, Base, Polygon
• Alt L1s - Solana (different pricing model), Avalanche, BSC

Real apps like OpenSea and Uniswap run on this stuff - assuming they're still around when you read this. When Uniswap needs 99.99% uptime for billions in trading volume, they're not running their own nodes that randomly corrupt their state database and spend weekends resyncing from genesis.

Most NFT sites are just React apps calling Alchemy APIs. Frontend hits the APIs, APIs hit Alchemy, Alchemy hits the blockchain. Pretty straightforward setup that keeps the complexity buried where users don't have to deal with it.

The Hidden Costs They Don't Mention

Enhanced APIs are powerful but expensive. Basic RPC is cheap - eth_blockNumber costs 10 CUs. But alchemy_getTokenBalances can cost 100+ CUs per call. Those NFT APIs that save you months of indexing work? They'll eat your budget if you're not careful.

Free tier sounds generous until you hit real traffic. Enhanced APIs blow through CUs fast. Budget a couple hundred a month once you scale.

The status page shows occasional outages, usually under 15 minutes. Still way better than maintaining nodes yourself, but build retry logic anyway.

Once you understand these basics, the real question becomes how Alchemy stacks up against the competition and what you'll actually pay in production.

The main thing Alchemy does is replace the pain of running blockchain nodes with APIs that actually work. But the product lineup can get confusing, and some stuff costs way more than others.

Basic Node Access (The Cheap Stuff)

Standard RPC endpoints work exactly like your own node, just more reliable. Your existing web3.js code doesn't change:

const web3 = new Web3(\"https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY\");

Basic calls are dirt cheap - eth_blockNumber costs 10 CU, eth_call is 26 CU. You can burn through millions of basic requests on the free tier.

WebSocket subscriptions work great for listening to new blocks or logs. Way more reliable than maintaining your own geth WebSocket connection.

Enhanced APIs (Where They Make Money)

The enhanced APIs are where costs can explode but also where you save months of work:

NFT API - Gets you NFT metadata, ownership, transfers without building your own indexer. Took me 3 hours to get token balances working vs 2 months building indexing from scratch. Costs 100+ CUs per call, but the math is obvious. The NFT API saved us probably 2+ months of indexing work but we burned through like $750 or maybe more the first week because we were polling instead of using webhooks like idiots. Still haven't figured out exactly what drove the costs so high.

Token API - Token balances, metadata, prices. Essential for DeFi apps but expensive at scale.

Transfers API - Complete transaction history including internal transfers. The kind of data that's a nightmare to index yourself.

We burned through our monthly CUs way faster than expected testing the NFT API. Those enhanced APIs are expensive as hell.

Smart Wallets (ERC-4337 Stuff)

Account Kit handles the ERC-4337 account abstraction complexity. Users can sign in with Google instead of dealing with seed phrases, which is huge for user experience.

Gas Manager sponsors user transactions - they pay the gas fees so your users don't have to. Costs 8% admin fee on top of gas, so it adds up fast with active users.

Smart wallets are powerful but adoption is still early. Great for new apps, harder to retrofit existing wallet integrations.

ERC-4337 is basically a way to let users sign in with Google instead of managing seed phrases. The smart contract does all the wallet stuff behind the scenes - creates accounts, pays gas, bundles transactions. Works great when it works, but debugging auth flows is still a pain in the ass.

Developer Tools That Actually Help

Dashboard is genuinely useful for debugging. Request explorer lets you search through API calls, see what failed, check response times. Beats grepping through logs.

Mempool visualizer shows pending transactions in real-time. Helpful for understanding why transactions are stuck.

Webhooks notify your app about on-chain events. Reliable delivery, automatic retries, way better than polling for changes.

Rate limiting works like you'd expect - you get a certain number of requests per second and enhanced APIs eat through your quota faster than basic calls. Hit the limits and you get 429 errors until the bucket refills.

Real Pricing Gotchas

Free tier (30M CU) sounds generous until you hit enhanced APIs. A busy NFT marketplace can burn through it in days.

Pay-as-you-go starts at something like $5 for 11M CU (around $0.45/1M), drops to $0.40-ish/1M after 300M CU monthly. But enhanced API calls cost 10x basic RPC.

Enterprise gets you unlimited throughput and dedicated support, but pricing starts at fuck-you money levels. Only worth it if you're doing serious volume or need SLAs. The sales guys won't even give you a quote unless you're burning through $10K+ monthly. We learned the hard way that 'enterprise-grade' just means 'expensive enough that you take it seriously'.

Budget at least a couple hundred bucks a month once you're handling real users with enhanced APIs. The compute unit system makes costs hard to predict until you're running in production.

If these pricing gotchas have you worried, you're asking the right questions. Here's what people actually want to know.