The Alchemy Alternative That Doesn’t Punish You for Growing
Alchemy bills per compute unit, with each method weighted differently and WebSocket traffic billed by the byte. SwiftNodes charges one flat monthly rate, accepts card or crypto, requires no KYC and serves 133 chains on one key.
The short version: SwiftNodes is a multi-chain blockchain RPC provider with flat-rate monthly pricing, no KYC, card or crypto payments, and 133 supported chains on one key. If you’re on Alchemy today and your usage is unpredictable, KYC is friction, or you want one provider for both EVM and non-EVM networks, SwiftNodes is built for that. Try the free tier →
Feature-by-feature: SwiftNodes vs Alchemy
| Feature | Alchemy | SwiftNodes | Better for you |
|---|---|---|---|
| Pricing model | Compute units per method (eth_blockNumber 10, eth_call 26, eth_getLogs 60), $0.525 per million CU pay-as-you-go | Flat monthly rate by requests per second; every method costs the same | SwiftNodes |
| Free tier | 30M CU/month (about 1.1M typical calls), 15 req/s | 20 req/s, 250,000 requests/month | Context |
| Throughput | 300 req/s (10,000 CU/s) on pay-as-you-go; $160 per extra 5,000 CU/s | 70 to 600 req/s by plan, included in the price | SwiftNodes |
| Chains | "70+ chains" (docs) | 133 chains, EVM plus Solana, Sui, Aptos, Cosmos, Polkadot, Bitcoin family | SwiftNodes |
| WebSocket billing | Bandwidth: 0.04 CU per byte (about 40 CU per typical event) | Messages count as requests within the plan's rate | SwiftNodes |
| Trace and debug | Not on Free; plan availability is stated differently on Alchemy's docs and pricing page | Same price as any call, on chains whose upstreams serve them | SwiftNodes |
| Payment | Card; agents can pay as they go in USDC on Base (x402) | Card or crypto (ETH, BNB, USDT, USDC) on every plan, no KYC | SwiftNodes |
| Enhanced APIs | Token, Transfers, NFT, Webhooks and more | sn_ batch helpers for balances, portfolios, allowances and decoded logs; no NFT API or webhooks | Context |
Feature data sourced from Alchemy’s public pricing page and SwiftNodes’ own published rates. Last reviewed 2026-10-13. Pricing changes frequently — verify on the source site before deciding.
What the same traffic costs
| Monthly traffic | Alchemy | SwiftNodes |
|---|---|---|
| 5 million requests | Pay-as-you-go ≈ 137M CU ≈ $72 | Starter: $49/mo (70 req/s, no monthly cap) |
| 25 million requests | Pay-as-you-go ≈ 683M CU ≈ $358 | Starter: $49/mo (70 req/s, no monthly cap) |
| 150 million requests | Pay-as-you-go ≈ 4.1B CU ≈ $2,150 | Growth: $89/mo (150 req/s, no monthly cap) |
| 500 million requests | Pay-as-you-go ≈ 13.7B CU ≈ $7,166, plus $160 for throughput above 10,000 CU/s ≈ $7,326 | Pro: $249/mo (600 req/s, no monthly cap) |
- List prices from each provider's public pricing page, checked 2026-10-13, billed monthly (annual discounts not applied).
- Ethereum mainnet, typical dApp mix: 30% eth_call, 20% eth_getBalance, 15% eth_blockNumber, 15% eth_getTransactionReceipt, 15% eth_getLogs, 5% eth_sendRawTransaction.
- SwiftNodes plans cap requests per second, not monthly volume; each row uses the cheapest plan that covers a peak of twice the average rate for that volume.
- Alchemy: compute-unit costs from alchemy.com/docs/reference/compute-unit-costs (eth_call 26, eth_getBalance 20, eth_blockNumber 10, eth_getTransactionReceipt 20, eth_getLogs 60, eth_sendRawTransaction 40), about 27.3 CU per request in this mix, at $0.525 per million CU, before any free allowance.
Switching from Alchemy: what changes in your code
Standard JSON-RPC and WebSocket calls need only a new URL. Your Alchemy endpoint:
https://eth-mainnet.g.alchemy.com/v2/<API_KEY>
wss://eth-mainnet.g.alchemy.com/v2/<API_KEY>becomes:
https://rpc.swiftnodes.io/rpc/<chain>?key=YOUR_API_KEY
wss://rpc.swiftnodes.io/ws/<chain>?key=YOUR_API_KEY
(over HTTP the key can go in an x-api-key header instead; <chain> is eth, base, arbitrum, solana, ... see /docs/supported-chains)Before
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
const client = createPublicClient({
chain: mainnet,
transport: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_ALCHEMY_KEY"),
});After
import { createPublicClient, http, webSocket } from "viem";
import { mainnet } from "viem/chains";
const client = createPublicClient({
chain: mainnet,
transport: http("https://rpc.swiftnodes.io/rpc/eth?key=YOUR_API_KEY"),
});
// Subscriptions: same key over WebSocket
const ws = createPublicClient({
chain: mainnet,
transport: webSocket("wss://rpc.swiftnodes.io/ws/eth?key=YOUR_API_KEY"),
});Alchemy-specific methods and what to call instead
| Alchemy method | On SwiftNodes |
|---|---|
| alchemy_getTokenBalances | sn_getTokenBalances(address, tokens[]) (paid plans). You pass the token list; there is no automatic token discovery. |
| alchemy_getTokenMetadata | sn_getTokenMetadata(tokens[]) (paid plans): name, symbol, decimals and total supply for up to 100 tokens in one call. |
| alchemy_getAssetTransfers | eth_getLogs with the ERC-20/721 Transfer topic and the address as topic 1 or 2, paged by block range; sn_getLogsDecoded (paid plans) returns them decoded, up to 2,000 blocks per call. Native-value internal transfers need trace_* on chains that serve it. |
| NFT API (getNFTsForOwner, ...) | No equivalent. Use an NFT indexer or read the contracts with eth_call. |
| Webhooks / Notify | No equivalent. Subscribe with eth_subscribe (logs, newHeads) over WebSocket. |
Point a staging deployment at SwiftNodes first and compare a few hundred real calls against Alchemy; standard JSON-RPC methods return the same chain data from any provider, so differences point at a real problem worth knowing about before you cut over.
Plans are month to month: you can run both providers side by side during the switch and cancel Alchemy when you are satisfied.
Measured, not claimed
Every week we call each method on every EVM chain through the same endpoint customers use, and publish the result. From the run on 2026-11-01:
- 106EVM chains probed weekly through the customer path
- 87serve debug_traceCall
- 41serve trace_block (Parity traces)
- 91serve archive state with &archive=1
- 105accept JSON-RPC batch requests
Per-chain detail is on the method support matrix and in the method reference, including what each chain actually returns for everyday calls such as eth_estimateGas and eth_subscribe.
Why developers switch from Alchemy to SwiftNodes
Compute units make every feature a pricing decision
Alchemy weights each method: eth_getLogs costs 60 CU, six times eth_blockNumber, and WebSocket traffic is billed by the byte. A new indexer or a busier subscription changes the bill in ways that are hard to forecast. SwiftNodes prices by requests per second, so a log-heavy feature costs the same as a balance check.
The same traffic for a fraction of the price
At 25 million requests a month in a typical dApp mix, Alchemy's pay-as-you-go comes to about $358. SwiftNodes' Starter plan covers it for $49. The gap widens with volume; the table above shows four common levels.
Beyond Alchemy's chain list
Alchemy is strongest on Ethereum and major EVM networks. SwiftNodes serves 133 chains on one key, including Solana, Sui, Aptos, Cosmos chains, Polkadot and the Bitcoin family.
When Alchemy is still the right call
If you rely on Alchemy's NFT API, Transfers API, webhooks or Account Abstraction tooling, SwiftNodes does not replace them. Teams often keep those where they are and move high-volume RPC, which is where compute units accumulate.
Frequently asked questions
How much cheaper is SwiftNodes than Alchemy?
With list prices checked 2026-10-13 and a typical dApp mix (about 27 CU per request): 5 million requests a month cost about $72 on Alchemy and $49 on SwiftNodes; 150 million cost about $2,150 on Alchemy and $89 on SwiftNodes, provided your peak stays within 150 requests per second.
Can I move from Alchemy without rewriting code?
Yes for standard JSON-RPC and WebSocket: replace https://eth-mainnet.g.alchemy.com/v2/<key> with https://rpc.swiftnodes.io/rpc/eth?key=YOUR_API_KEY. If you use the Alchemy SDK's enhanced methods (alchemy_getTokenBalances, alchemy_getAssetTransfers, NFT API), those need replacing; see the method table on this page.
Does SwiftNodes have an equivalent of alchemy_getTokenBalances?
sn_getTokenBalances returns the native balance and ERC-20 balances with symbol and decimals in one call, on paid plans. Unlike Alchemy's version you pass the list of token contracts; it does not discover tokens for you.
Are trace and archive calls extra?
No. They cost the same as any request. Which chains serve them is measured weekly on our method support page; add &archive=1 to route a request to archive nodes.
What is the refund and cancellation policy?
Plans are month to month and you can cancel any time. Card payments may be refunded at our discretion; crypto payments are non-refundable once confirmed on-chain. Upgrading a card plan mid-term credits the unused part of the old plan to your next invoice.
Try SwiftNodes free — no card, no KYC
Flat-rate pricing, 133 chains, pay with crypto or card. Live in 30 seconds.
Get your API key