Alchemy Alternative: What Switching Really Costs

Switching from Alchemy pays off when most of your traffic is standard JSON-RPC at volume and you want a bill you can compute before the month starts. It does not pay off if you rely on Alchemy-only APIs such as Notify webhooks, Smart Wallets or Gas Manager, if your usage fits inside Alchemy’s free 30M compute units (CU) a month, or if you need debug, trace or archive data on a chain where BoltRPC does not offer it. The shared Ethereum endpoint offers none of the three, so check that first.

This guide is a switching checklist, not a sales pitch. It covers how Alchemy bills today, the same workload priced in request units (RU), what you lose, how to migrate with a URL swap and how to keep a fallback while you do. Every Alchemy figure was read from Alchemy’s own pages on 2026-10-24, and its pricing has changed twice in two years, so check them again before you decide.

How Alchemy bills today

Alchemy has three plans: Free, Pay As You Go (PAYG) and Enterprise. The Growth and Scale plans moved to PAYG on 2025-02-01, according to Alchemy’s PAYG FAQ.

• Free: 30M CU per month, 300 CU/s (15 requests per second). No Debug API or Trace API. eth_getLogs is limited to 10 blocks per request.
• Pay As You Go: $0.525 per 1M CU, no platform fee and no included CU. The base throughput is 10,000 CU/s (300 requests per second); each extra 5,000 CU/s block costs $160 per month and self-serve capacity ends at 30,000 CU/s.
• Enterprise: custom pricing through sales.

Alchemy’s own PAYG examples are simple: 120M CU is $63 and 460M CU is $241.50.

The volume discount is gone

Until September 2026, PAYG had a volume break: $0.45 per 1M CU up to 300M CU and $0.40 per 1M CU above. Alchemy’s docs pull request #1615 removed it and was merged on 2026-09-11 at 00:10 UTC. PAYG is now a single rate of $0.525 per 1M CU across all usage. The PR says the change applies to new PAYG subscriptions.

Alchemy’s own pages do not agree yet: the docs and the pricing page show the single $0.525 rate, while a support article still lists the $0.45 and $0.40 tiers and the PAYG launch post still mentions volume discounts (all read on 24 October 2026). The PR is the only dated source we found. If you are on PAYG, read your latest invoice before you assume which rate you pay.

What each method costs in CU

Alchemy’s compute unit table (Ethereum, standard JSON-RPC methods unless noted) lists these billed CU per call:

Method	Alchemy CU
eth_blockNumber	10
eth_call	26
eth_getBalance	20
eth_getLogs	60
eth_getTransactionReceipt	20
eth_getBlockByNumber	20
eth_estimateGas	20
eth_sendRawTransaction	40
debug_traceTransaction (Debug API)	40
trace_block (Trace API)	20

Two details matter when you forecast. First, Alchemy’s pages disagree on eth_getLogs: the compute unit table says 60 CU, while the “What are CUPS” example on the compute units concept page still uses 75 (10 + 2 x 75 + 2 x 26 = 212). This article uses the table, because that is the page that lists costs per method. Second, a JSON-RPC batch costs the CU of each method times the number of calls, so batching saves round trips but not CU.

Alchemy’s own estimate of an average request is 27 CU on its pricing page and about 25 CU in the PAYG FAQ. At $0.525 per 1M CU that is roughly $13 to $14 per million requests. Real mixes vary a lot, which is why the next section uses a mix instead of an average.

WebSocket is billed per byte

Alchemy bills WebSocket subscriptions and webhooks by bandwidth: 0.04 CU per byte delivered, with per-event prices only for Base Flashblocks subscriptions. Alchemy says a typical event is about 1,000 bytes, which is 40 CU. The eth_subscribe request itself costs 10 CU.

We measured five newHeads frames on a public Ethereum endpoint and they averaged 1,844 bytes, which is about 74 CU per event at 0.04 CU per byte. That is not an Alchemy measurement, since Alchemy does not say whether it counts the full frame or only the payload. Take it as a range: a newHeads feed for a month (216,000 blocks at 12 seconds) is roughly 8.6M to 15.9M CU on Alchemy, which is $4.54 to $8.36 at the PAYG rate. On BoltRPC every pushed message bills once at 3 RU, so the same month is 648,000 RU.

For how the two pricing models differ in principle, see Compute Units vs Request Units. This article only covers Alchemy against BoltRPC.

The same workload on request units

BoltRPC charges fixed request unit weights per method, published in How BoltRPC Request Units Work. Plans include a monthly RU allowance, and extra capacity is added in blocks of 15M RU at $25 per 15M request units. Overage is optional and capped by a spending limit you set. Without a plan you can buy blocks on demand.

Take 50M calls a month on Ethereum mainnet, with no caching or batching on either side:

Method	Calls (M)	Alchemy CU per call	Alchemy CU (M)	BoltRPC RU per call	BoltRPC RU (M)
eth_call	20	26	520	3	60
eth_blockNumber	10	10	100	3	30
eth_getLogs	5	60	300	4	20
eth_getTransactionReceipt	5	20	100	3	15
eth_getBlockByNumber	4	20	80	3	12
eth_getBalance	3	20	60	3	9
eth_estimateGas	2	20	40	3	6
eth_sendRawTransaction	1	40	40	5	5
Total	50	avg 24.8	1,240	avg 3.14	157

The monthly bill for that mix:

Option	Arithmetic	Monthly cost
Alchemy PAYG	1,240M CU x $0.525 per 1M	$651.00
Alchemy at its own 27 CU average	50M x 27 = 1,350M CU x $0.525	$708.75
BoltRPC Builder	$49 + 9 started blocks at $25 per 15M request units (157M RU against 30M included)	$274.00
BoltRPC Pro	$199 + 1 block at $25 per 15M request units (157M RU against 150M included)	$224.00
BoltRPC On-demand, no plan	11 started blocks at $25 per 15M request units (157M / 15M, rounded up)	$275.00

Business and Enterprise include more than 157M RU, so for this mix they cost their plan price, $699 and $1499 per month. The cheapest option here is Pro at $224.00. Overage has to be switched on in your account; by default nothing is billed beyond your plan. You can also trim the 7M RU over Pro’s allowance, for example by caching eth_blockNumber, and stay inside the plan.

The gap comes from the weights. A rate of 26 CU against 3 RU for eth_call, and 60 CU against 4 RU for eth_getLogs, compounds across 50M calls. Per million calls of a single method, Alchemy PAYG comes to $13.65 for eth_call and $31.50 for eth_getLogs, against $5.00 and $6.67 for BoltRPC at the most expensive RU rate, which is the overage or On-demand block. The gap narrows on heavy methods: trace_block is 20 CU on Alchemy against 6 RU on BoltRPC, and that applies only on chains where the node pool offers trace.

When Alchemy is cheaper

Scale the same mix down to 1M calls a month. That is 24.8M CU, so Alchemy’s Free plan covers it for $0 and PAYG would be $13.02. On BoltRPC the same month is 3.14M RU, which costs one On-demand block at $25 per 15M request units or the Builder plan at $49. If you stay inside Alchemy’s free tier and can live with 300 CU/s, no Debug or Trace API and a 10-block eth_getLogs range, stay.

Roughly, 30M CU holds about 1.2M calls of the mix above. Past that point the comparison starts to favour request units, and it moves further as your mix leans on eth_call and eth_getLogs. The BoltRPC free trial (5M RU over 14 days) is enough to replay a slice of your traffic and compare.

Compute your own bill

Change the mix to your own call counts. You can read them from Alchemy’s request logs. Its pricing page gives 7 days of history on PAYG and 1 hour on Free, while its Request Logs guide says up to 10 days:

const ALCHEMY_CU = { eth_call: 26, eth_blockNumber: 10, eth_getLogs: 60, eth_getTransactionReceipt: 20,
  eth_getBlockByNumber: 20, eth_getBalance: 20, eth_estimateGas: 20, eth_sendRawTransaction: 40 };
const ALCHEMY_USD_PER_M_CU = 0.525;
const RU = { eth_call: 3, eth_blockNumber: 3, eth_getLogs: 4, eth_getTransactionReceipt: 3,
  eth_getBlockByNumber: 3, eth_getBalance: 3, eth_estimateGas: 3, eth_sendRawTransaction: 5 };
// Check plan prices and allowances against https://boltrpc.io/pricing before you trust the output
const PLANS = [{ name: 'Builder', usd: 49, ru: 30e6 }, { name: 'Pro', usd: 199, ru: 150e6 },
  { name: 'Business', usd: 699, ru: 500e6 }, { name: 'Enterprise', usd: 1499, ru: 1e9 }];
const BLOCK_RU = 15e6, BLOCK_USD = 25;

const mix = { eth_call: 20e6, eth_blockNumber: 10e6, eth_getLogs: 5e6, eth_getTransactionReceipt: 5e6,
  eth_getBlockByNumber: 4e6, eth_getBalance: 3e6, eth_estimateGas: 2e6, eth_sendRawTransaction: 1e6 };

const cu = Object.entries(mix).reduce((s, [m, n]) => s + n * ALCHEMY_CU[m], 0);
const ru = Object.entries(mix).reduce((s, [m, n]) => s + n * RU[m], 0);
console.log('Alchemy PAYG $', (cu / 1e6 * ALCHEMY_USD_PER_M_CU).toFixed(2));
for (const p of PLANS) {
  const blocks = Math.ceil(Math.max(0, ru - p.ru) / BLOCK_RU);
  console.log('BoltRPC', p.name, '$', p.usd + blocks * BLOCK_USD, `(${blocks} overage blocks)`);
}
console.log('BoltRPC On-demand $', Math.ceil(ru / BLOCK_RU) * BLOCK_USD);

With the mix above it prints Alchemy PAYG $ 651.00, then Builder 274, Pro 224, Business 699, Enterprise 1499 and On-demand 275. It leaves out caching, batching and any negotiated or annual discount, and it does not model peaks. At 1,240M CU a month Alchemy averages about 478 CU/s, well under its 10,000 CU/s PAYG base, but your peaks decide whether you need more throughput.

What you give up

Standard JSON-RPC moves with a URL change. Anything with an alchemy_ prefix, Alchemy’s SDK namespaces and its hosted products do not. Go through your code for each of these. Where there is a standard route, the sample or note shows it; where there is none, we say so.

Debug, trace and archive on Ethereum

Alchemy lists Debug API and Trace API on PAYG and Enterprise (not Free) and full archive data on all plans. The shared Ethereum endpoint on BoltRPC has no archive, no trace and no debug. Archive access for Ethereum is available as a custom archive setup on request, and the shared endpoint serves recent state. If your Ethereum workload depends on historical state queries, trace_* or debug_*, talk to us before you plan a migration.

Debug, trace and archive depth are properties of each chain’s node pool, not of your plan. Some chains have them and Ethereum mainnet does not, so check the chain you use on /networks for its listed capabilities.

Alchemy-only APIs and their standard replacements

• alchemy_getTokenBalances: with a known token list, one eth_call to Multicall3 aggregate3 with a balanceOf per token does the same job. The sample below runs it. Without a list (“every token this wallet ever touched”) there is no standard method: keep a token list or index Transfer logs yourself. On Alchemy this call is 20 CU regardless of token count; on BoltRPC the Multicall3 call is one eth_call at 3 RU.
• alchemy_getTokenMetadata and alchemy_getTokenAllowance: eth_call of name(), symbol(), decimals() and allowance(owner, spender), batched in Multicall3. The logo URL is not on chain.
• alchemy_getAssetTransfers: for ERC-20, ERC-721 and ERC-1155 transfers, use eth_getLogs with the Transfer topic and a filter on sender or recipient. Native ETH transfers have no log. You need to scan blocks or use trace_filter, and internal transfers need trace_filter or debug_traceTransaction. On Ethereum that route is not available on the shared endpoint, so this is not an equal swap.
• alchemy_getTransactionReceipts: eth_getBlockReceipts returns the receipts for a block (20 CU on Alchemy, 3 RU on BoltRPC), where the node implements it.
• NFT API: ownership via ownerOf and balanceOf, enumeration from Transfer logs and metadata through tokenURI plus your own HTTP or IPFS fetch. See reading NFT data over RPC. Floor prices, sales data, spam classification and cached metadata are indexer products with no RPC equivalent.
• Transaction simulation: eth_call with state overrides, a standard Geth extension, covers “what would this call return”. The decoded “you will receive X token” summary of alchemy_simulateAssetChanges is Alchemy-only.
• Alchemy’s Smart WebSockets: alchemy_pendingTransactions and alchemy_minedTransactions are Alchemy-only. Plain newPendingTransactions and logs subscriptions over eth_subscribe are standard.
• alchemy-sdk: alchemy.core.* calls map to ethers or viem calls. Code that uses alchemy.nft.*, alchemy.transact.* or alchemy.notify.* has no drop-in replacement.

What has no replacement

• Notify and webhooks. Alchemy’s Address Activity, NFT Activity and custom webhooks push events to your HTTP endpoint. If you move, check whether your new provider offers webhooks for the events you use. The standard alternatives are an eth_subscribe WebSocket or polling eth_getLogs, and you run the listener. If webhooks carry your product, keep Alchemy for that part.
• Smart Wallets and Wallet APIs (Account Kit is deprecated in favour of Wallet APIs), including session keys and the embedded signer. ERC-4337 bundlers speak JSON-RPC, but ask us before you plan around bundler methods on BoltRPC.
• Gas Manager gas sponsorship.

If you need more than a few of these, a split setup is usually the honest answer: move the standard reads and writes, keep the Alchemy products you depend on, and use failover between providers for plain RPC.

Migrating step by step

1. Swap the URL

Alchemy’s Ethereum URL has the form below. The BoltRPC HTTPS and WebSocket URLs sit next to it, and both work on every plan:

Alchemy:      https://eth-mainnet.g.alchemy.com/v2/<KEY>
BoltRPC HTTP: https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum
BoltRPC WS:   wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/ethereum

Other chains change the last path segment (for example base, arbitrum, optimism, polygon, bsc, avax, linea, scroll or zksync); the full list is in the docs. For the Alchemy side, copy the URL from your dashboard instead of guessing slugs.

We ran these three snippets against a public Ethereum endpoint, changing only the URL, and they returned the same chain ID, a current block number and the same balance.

ethers v6:

import { JsonRpcProvider } from 'ethers';
// Alchemy: https://eth-mainnet.g.alchemy.com/v2/<KEY>
// BoltRPC: https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum
const RPC_URL = process.env.RPC_URL ?? 'https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum';
const provider = new JsonRpcProvider(RPC_URL);
const net = await provider.getNetwork();
console.log('chainId', net.chainId.toString());
console.log('block', await provider.getBlockNumber());
console.log('balance (wei)', (await provider.getBalance('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')).toString());

viem:

import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
const RPC_URL = process.env.RPC_URL ?? 'https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum';
const client = createPublicClient({ chain: mainnet, transport: http(RPC_URL) });
console.log('chainId', await client.getChainId());
console.log('block', (await client.getBlockNumber()).toString());
console.log('balance (wei)', (await client.getBalance({ address: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' })).toString());

web3.py:

import os
from web3 import Web3
RPC_URL = os.environ.get("RPC_URL", "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum")
w3 = Web3(Web3.HTTPProvider(RPC_URL))
print("chainId", w3.eth.chain_id)
print("block", w3.eth.block_number)
print("balance (wei)", w3.eth.get_balance("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))

Putting the URL in an environment variable also gives you the rollback: set RPC_URL back and redeploy. For more detail per library, see how to choose a provider and the library guides linked from it.

2. Replace alchemy_getTokenBalances

This sample reads five token balances for one address with a single eth_call to Multicall3 (deployed at the same address on Ethereum, Base, Arbitrum, Optimism, BNB Smart Chain and Avalanche C-Chain, which we confirmed with eth_getCode on public endpoints). It checks that the contract exists first, so it fails loudly on a chain without it:

import { JsonRpcProvider, Interface, formatUnits } from 'ethers';

const RPC_URL = process.env.RPC_URL ?? 'https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum';
const MULTICALL3 = '0xcA11bde05977b3631167028862bE2a173976CA11';
const OWNER = process.env.OWNER ?? '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
const TOKENS = {
  USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
  DAI:  '0x6B175474E89094C44Da98b954EedeAC495271d0F',
  WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
  WBTC: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
};
const erc20 = new Interface([
  'function balanceOf(address) view returns (uint256)',
  'function decimals() view returns (uint8)',
]);
const multicall = new Interface([
  'function aggregate3((address target, bool allowFailure, bytes callData)[] calls) payable returns ((bool success, bytes returnData)[] returnData)',
]);
const provider = new JsonRpcProvider(RPC_URL);

const code = await provider.getCode(MULTICALL3);
if (code === '0x') throw new Error('Multicall3 is not deployed on this chain');

const calls = Object.values(TOKENS).flatMap((t) => [
  { target: t, allowFailure: true, callData: erc20.encodeFunctionData('balanceOf', [OWNER]) },
  { target: t, allowFailure: true, callData: erc20.encodeFunctionData('decimals', []) },
]);
const raw = await provider.call({ to: MULTICALL3, data: multicall.encodeFunctionData('aggregate3', [calls]) });
const [results] = multicall.decodeFunctionResult('aggregate3', raw);

Object.keys(TOKENS).forEach((sym, i) => {
  const bal = results[i * 2], dec = results[i * 2 + 1];
  if (!bal.success || !dec.success) { console.log(sym, 'call failed'); return; }
  const [balance] = erc20.decodeFunctionResult('balanceOf', bal.returnData);
  const [decimals] = erc20.decodeFunctionResult('decimals', dec.returnData);
  console.log(sym.padEnd(5), 'raw', balance.toString().padStart(30), '| decimals', decimals.toString(), '|', formatUnits(balance, decimals));
});

On a public Ethereum endpoint this printed the five balances (for example USDC raw 38192124 with 6 decimals, which is 38.192124) and matched five separate balanceOf calls to the same endpoint value for value. We could not compare it with alchemy_getTokenBalances directly, because Alchemy’s public demo key refused our request. One call carries many sub-calls, but a provider can cap the size: the public endpoint we used answered 1,000 sub-calls in one request and returned a 503 for 3,000, so keep batches to a few hundred and measure the limit on your own endpoint.

3. Run both in parallel, then cut over

1. Export your real mix. Read call counts per method from Alchemy’s request logs (7 days on PAYG per its pricing page; Alchemy’s usage CSV export is Enterprise only), put them into the cost script and see the number before you move anything. BoltRPC exports request logs as CSV or NDJSON and usage summaries as CSV or JSON on every plan.
2. Shadow reads. Send a copy of your read traffic to BoltRPC and compare the results with Alchemy’s: block numbers within a block of each other, identical balances and logs. Run your widest eth_getLogs query, since range and result-size limits are where providers differ. On BoltRPC there is no block-range cap; the limits are the response size and a 60-second deadline. In our test on 24 October 2026, 2,000 blocks of USDC Transfer logs on Ethereum came back in one call (156,606 logs), while 100,000 blocks was refused with an error naming a narrower range. Confirm with your own widest query.
3. Move writes and subscriptions last. eth_sendRawTransaction and WebSocket subscriptions are the two paths where a mistake costs money or events, so switch them after reads have been stable for a few days.
4. Flip the priority, keep the old provider behind. With ethers v6 a FallbackProvider with quorum: 1 tries the lower priority number first and moves to the next after stallTimeout:

import { FallbackProvider, JsonRpcProvider } from 'ethers';

const NEW = 'https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum';
const OLD = 'https://eth-mainnet.g.alchemy.com/v2/<KEY>';

const fp = new FallbackProvider([
  { provider: new JsonRpcProvider(NEW, 1, { staticNetwork: true }), priority: 1, weight: 1, stallTimeout: 1500 },
  { provider: new JsonRpcProvider(OLD, 1, { staticNetwork: true }), priority: 2, weight: 1, stallTimeout: 1500 },
], 1, { quorum: 1 });
console.log('block', await fp.getBlockNumber());

Alchemy’s free plan can sit behind as that fallback while you stay under its 30M CU. Keep it for as long as it takes you to trust the new endpoint, and read RPC failover for reliable infrastructure before you drop it for good. Set usage alerts on BoltRPC and a spending limit if you enable overage, so a runaway loop shows up as an alert and not as an invoice.

BoltRPC has no request rate limit on monthly plans. Without a plan, On-demand usage is limited to 100 requests per second.

Other Alchemy alternatives

BoltRPC is not the only option, and which one fits depends on your mix. These are the billing models as the providers publish them on 2026-10-24. Prices change, so confirm on their pages. Our guide to choosing an RPC provider covers the non-price criteria.

• Infura: daily credits per plan, with Core free, Developer at $50 per month, Team at $225 per month and Enterprise custom. Debug and Trace API start on the Developer plan.
• QuickNode: monthly API-credit plans, with a free trial of 10M credits, Build at $49 per month for 80M credits and extra credits from $0.62 per 1M on Build. Credits per method depend on the method’s intensity.
• Chainstack: request units, 1 RU per full-node request and 2 RU per archive request, with Growth at $49 per month for 20M RU and a free Developer tier of 3M RU.
• Ankr: per-request credits on pay as you go, 1M credits for $0.10, and every EVM method costs 200 credits, which is $20 per 1M EVM requests.
• dRPC: CU pool plans plus pay as you go at $6 per 1M requests, with a free tier and a Pro plan at $49 per month.

FAQ

What is the best Alchemy alternative?

It depends on what you use Alchemy for. If your traffic is standard JSON-RPC, a provider with fixed per-method weights such as BoltRPC gives you a bill you can compute in advance. If you depend on webhooks, NFT or Wallet APIs, none of the pure RPC providers replace them. Compare your own method mix with each provider’s pricing page; the cost script in this article does that for Alchemy and BoltRPC.

How much does Alchemy cost per million compute units?

Pay As You Go is $0.525 per 1M CU, with no platform fee and no included CU. The Free plan includes 30M CU per month. Alchemy’s own average is about 25 to 27 CU per request, which works out to roughly $13 to $14 per million requests, but the real figure depends on your methods: eth_call is 26 CU and eth_getLogs is 60 CU in Alchemy’s table.

Does Alchemy still have a volume discount?

Not on Pay As You Go. Alchemy’s docs pull request merged on 2026-09-11 removed the old break of $0.45 per 1M CU up to 300M CU and $0.40 above it, leaving one rate of $0.525 per 1M CU. The PR says it applies to new PAYG subscriptions, so check your invoice if you subscribed earlier. Enterprise pricing is custom.

Can I switch from Alchemy without changing my code?

For standard JSON-RPC, yes: change the URL and keep your ethers, viem or web3.py code. Calls to alchemy_* methods, the alchemy-sdk NFT, Transact and Notify namespaces, Alchemy webhooks, Smart Wallets and Gas Manager need a replacement or stay on Alchemy. Run both providers in parallel first.

Will I lose archive, trace or debug access?

On Ethereum mainnet, the shared BoltRPC endpoint has none of the three, while Alchemy lists full archive data on every plan and Debug and Trace APIs on PAYG and Enterprise. Archive access for Ethereum is available as a custom setup on request. Other chains differ: debug, trace and archive depth are properties of each chain’s node pool, so check the chain you use on /networks.

Try the swap on your own traffic

Compare plans and weights on /pricing, pick a chain on /networks and replay a slice of your Alchemy traffic against BoltRPC. The free trial gives you 5M request units over 14 days at up to 100 requests per second.

Start your free 14-day trial: dashboard.boltrpc.io/signup