AWS Managed Blockchain alternative: how to migrate AMB Access and AMB Query to Alchemy
Written by Uttam Singh
Amazon Web Services is ending Amazon Managed Blockchain (AMB), its managed blockchain service. Existing customers can keep using it until September 29, 2027, and after that date AMB Access and AMB Query stop responding. If you run AMB Access on Ethereum, Bitcoin, or Polygon, switching to Alchemy is an endpoint change. Your JSON-RPC calls stay the same, and an API key replaces SigV4 request signing or AMB Accessor tokens.
AMB Query takes more than a URL change, because it is an indexed data API rather than a node. Our Data APIs cover the same Ethereum reads (balances, transfers, token and NFT metadata), and our UTXO API covers Bitcoin addresses, balances, and transactions. This guide covers both paths: getting an endpoint, handing the code changes to a coding agent, replacing SigV4, mapping each AMB Query operation, checking that the new endpoint returns the same data, and how billing compares.
When does AWS Managed Blockchain shut down?
Per AWS's Amazon Managed Blockchain end-of-support notice, existing customers lose access to every AMB product after September 29, 2027. That covers five services:
- AMB Access Ethereum. Dedicated full nodes on Ethereum Mainnet, with JSON-RPC over HTTP and WebSocket, plus the Consensus API.
- AMB Access Bitcoin. Shared Bitcoin Mainnet and Testnet endpoints.
- AMB Access Polygon. A shared Polygon Mainnet endpoint.
- AMB Query. An indexed API for balances, transactions, and token data on Ethereum (Mainnet and Sepolia) and Bitcoin (Mainnet and Testnet).
- AMB Access Hyperledger Fabric. Private, permissioned networks.
We already support every public chain on that list, Ethereum, Bitcoin, and Polygon, along with more than 100 other chains on the same API key. Hyperledger Fabric runs private ledgers rather than a public chain, so it falls outside this guide, and AWS's notice lists the options for it.
AWS's node and RPC migration guide names Alchemy as a third-party provider for AMB Access Ethereum, Bitcoin, and Polygon. Once all your traffic runs on Alchemy, delete your AMB Ethereum nodes, your Accessor tokens, and the IAM permissions that grant AMB access. AWS bills AMB Ethereum nodes per second until you delete them.
How do you switch AMB Access to a new RPC provider?
Sign up in the Alchemy dashboard, create an app, and turn on the networks you used on AMB. Each network gets its own URL, and one app's API key works on all of them.
If you prefer the terminal, the Alchemy CLI signs you in, creates the app, and makes a first test call:
npm i -g @alchemy/cli@latest
alchemy auth # browser sign-in
alchemy app create --name amb-migration --networks ETH_MAINNET
alchemy app select <app-id> # use the new app's key
alchemy evm block latest -n eth-mainnet # confirm the endpoint answersOn a remote server without a browser, use alchemy auth login --device-code. alchemy app chains lists the identifiers for every other network you can add, including Bitcoin and Polygon.
If your team buys software through AWS, we are also on AWS Marketplace, so an Alchemy subscription can be billed through your AWS account.
Can an AI coding agent migrate off AMB for you?
Yes, and it saves the most time on AMB, where signing code often sits in several places: application clients, Lambda functions, and API Gateway proxies. We ship three tools that give a coding agent (Claude Code, Cursor, Codex, or similar) what it needs:
- The Alchemy CLI runs the commands: creating apps, setting allowlists, and test calls against each network.
- Alchemy Agent Skills teach the agent our endpoint formats, Data API methods, and CLI usage. Install them with
alchemy install skills. - The Alchemy MCP server gives the agent direct access to chain data across 100+ networks, so it can compare results while it works. It is hosted at
https://mcp.alchemy.com/mcpand signs in with your Alchemy account, so there is no API key to paste. Add it withalchemy install mcp, or in Claude Code:
claude mcp add alchemy --transport http https://mcp.alchemy.com/mcpOn Claude Code, the Alchemy plugin for Claude Code installs the skills and the MCP server in one step, and setting up Claude Code with Alchemy walks through it.
Then give the agent a prompt like this from the root of your repository:
Move this project off Amazon Managed Blockchain (AMB Access and AMB Query) before the September 29, 2027 shutdown. The new provider is Alchemy. Use the Alchemy MCP server, the Alchemy CLI, and Alchemy skills. If the MCP tools aren't available, walk me through setup and sign-in first.
Plan first. Don't change files or Alchemy settings until I approve. Never print or commit credentials.
Before changing anything, ask me:
- which AMB products and networks we use (Ethereum, Bitcoin, Polygon, AMB Query)
- where our secrets live (env files, AWS Secrets Manager, CI variables)
- whether the new Alchemy app needs IP or origin allowlists
Then find every AMB dependency: managedblockchain.amazonaws.com endpoints, SigV4 signing code (signature-v4, aws4, awscurl, botocore signers), billingtoken query parameters, IAM policies granting managedblockchain actions, and every AMB Query SDK call (ManagedBlockchainQuery clients and operations). Show me the list with file paths and wait.
After I approve, replace each RPC endpoint with an environment variable holding the Alchemy URL, remove the signing code, and add placeholders to .env.example. For AMB Query, propose an adapter that maps each operation we use to Alchemy Data API or UTXO API calls, and list any fields that don't map one-to-one.
Finally, verify each migrated network with the Alchemy CLI and report the results.To migrate without an agent, search your code and config for managedblockchain hostnames and SigV4 signing helpers, swap in the Alchemy URL for each network, and delete the signing step.
What replaces each part of your AWS blockchain setup?
Most of the mapping is one-to-one, and a few AMB limits go away.
Several AMB limits go away in the move. AMB Ethereum nodes are full nodes, so AWS points teams to AMB Query for historical data, while our RPC API answers eth_getBalance and eth_call at any past block on the same endpoint. AMB Ethereum and Polygon don't accept JSON-RPC batch requests, and we support batch requests on both. AMB Polygon has no WebSocket endpoint, and ours does. AMB Ethereum also covers Mainnet only, while we serve Sepolia and Hoodi for testing.
Teams that chose AMB for single-tenant nodes can run on Alchemy Dedicated Clusters, and choosing between Node RPC and Dedicated Clusters explains when that is worth it.
Here is the endpoint swap as environment variables:
# Before: Amazon Managed Blockchain
ETH_RPC_URL=https://<node-id>.ethereum.managedblockchain.<region>.amazonaws.com/
ETH_WS_URL=wss://<node-id>.wss.ethereum.managedblockchain.<region>.amazonaws.com/
# Accessor-token variant: https://<node-id>.t.ethereum.managedblockchain.<region>.amazonaws.com?billingtoken=<token>
BTC_RPC_URL=https://mainnet.bitcoin.managedblockchain.<region>.amazonaws.com/
POLYGON_RPC_URL=https://mainnet.polygon.managedblockchain.<region>.amazonaws.com/
# After: Alchemy
ETH_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/<your-key>
ETH_WS_URL=wss://eth-mainnet.g.alchemy.com/v2/<your-key>
ETH_BEACON_URL=https://eth-mainnetbeacon.g.alchemy.com/v2/<your-key>
BTC_RPC_URL=https://bitcoin-mainnet.g.alchemy.com/v2/<your-key>
POLYGON_RPC_URL=https://polygon-mainnet.g.alchemy.com/v2/<your-key>
POLYGON_WS_URL=wss://polygon-mainnet.g.alchemy.com/v2/<your-key>For Bitcoin testing, we serve bitcoin-testnet and bitcoin-signet endpoints in the same URL format.
How do you remove AWS SigV4 signing from blockchain requests?
On AMB, every request is signed with AWS Signature Version 4 (SigV4), the scheme that attaches your IAM credentials to each call, or carries an Accessor token in the URL. On Alchemy, the API key in the URL is the credential, so you delete the signing step instead of replacing it.
For Bitcoin, the request body doesn't change. Only the tool and URL do:
# Before: AMB Access Bitcoin, signed with awscurl
awscurl -X POST --service managedblockchain --region us-east-1 \
-d '{"jsonrpc":"1.0","id":"1","method":"getblockcount","params":[]}' \
https://mainnet.bitcoin.managedblockchain.us-east-1.amazonaws.com
# After: Alchemy, plain curl
curl -X POST -H "Content-Type: application/json" \
-d '{"jsonrpc":"1.0","id":"1","method":"getblockcount","params":[]}' \
"https://bitcoin-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"In application code, the AWS SDK signer, credential provider, and request wrapper all go away. For EVM chains, a standard client is enough:
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
const { ETH_RPC_URL } = process.env;
// Fail fast: viem's http() silently falls back to a public RPC when the URL is undefined.
if (!ETH_RPC_URL) {
throw new Error("Set ETH_RPC_URL to your Alchemy Ethereum Mainnet URL");
}
// No SignatureV4, credential provider, or signed fetch wrapper.
const client = createPublicClient({ chain: mainnet, transport: http(ETH_RPC_URL) });
async function main() {
console.log(await client.getBlockNumber());
}
main();The same applies to ethers, web3.py, and any JSON-RPC client. Once nothing calls AMB, delete the signing dependencies along with the AMB IAM permissions.
Which blockchain data API replaces AMB Query?
Our Data API is a blockchain data API with indexed transaction history and token data for Ethereum and other EVM chains, and our UTXO API is the Bitcoin API for addresses, balances, and transactions. Together they cover the reads AMB Query served.
AMB Query returns normalized, indexed data from a set of SigV4-signed operations. AWS's AMB Query migration guide is direct that no provider is a one-to-one replacement, so the practical approach is an adapter layer. Your application keeps calling one interface, and the adapter maps each AMB operation onto our APIs and normalizes the fields you actually use.
Ethereum: indexed transaction history and token data
The Ethereum side runs on our Data API. The Token API covers ERC-20 balances and metadata, the NFT API covers ERC-721 and ERC-1155 holdings, and the Transfers API covers address history. For a wallet's complete incoming and outgoing transaction history, call alchemy_getAssetTransfers once with fromAddress and once with toAddress, or use Transfers By Wallet to cover several chains in one request. NFT balances, including historical ones, come from eth_call against the token contract at the block you need (ownerOf for ERC-721, balanceOf for ERC-1155), since getNFTsForOwner returns current holdings only. Token Balances By Wallet replaces batched native and ERC-20 balance reads, since one request covers several addresses across Ethereum and Polygon:
curl -X POST "https://api.g.alchemy.com/data/v1/$ALCHEMY_API_KEY/assets/tokens/balances/by-address" \
-H "Content-Type: application/json" \
-d '{"addresses":[{"address":"0xYourAddress","networks":["eth-mainnet","matic-mainnet"]}]}'Bitcoin API: addresses, balances, and UTXOs
The Bitcoin side runs on our UTXO API, a REST interface with Blockbook-style endpoints for addresses, balances, balance history, transactions, and unspent outputs. Enable it as an add-on in the dashboard. Balance history returns the amounts received and sent per time interval over a range you set, which covers reporting views:
curl "https://bitcoin-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY/api/v2/balancehistory/<btc-address>?from=1700000000&to=1710000000"It returns activity per interval, not a balance at a single moment. If you used AMB's GetTokenBalance with a timestamp on Bitcoin, rebuild that balance from the address's outputs and spends, or keep your own snapshots.
What should the adapter handle?
A few details are worth handling in the adapter:
- Finality. AMB Query's balance and contract operations return only final data, which AWS defines as 64 blocks on Ethereum and six blocks on Bitcoin. Read at a block that deep, not at
latest, when you need the same answers. - Timestamps. AMB Query accepts a point in time (
atBlockchainInstant) for historical balances. Our Ethereum balance methods take a block number, so resolve the timestamp to a block first, then query at that block. - Transaction coverage. The Transfers API covers transfer activity, not every transaction. If you need every top-level transaction an address sent, including failed ones, read the blocks in that range and check each receipt's status.
- Contract lists.
ListAssetContractsfilters contracts by deployer, which no single call reproduces. If you depend on it, export that list from AMB Query while it is still available and keep it in your own store. - Pagination. AMB's
nextTokenbecomes ourpageKey(or the UTXO API's page parameters). Keep that difference inside the adapter.
Validate the adapter against responses you capture from AMB Query today, at finalized blocks, for the operations and fields your application actually reads.
How do you verify the migration and cut over without downtime?
Compare both providers at a fixed, finalized block before any production traffic moves. This script uses the awscurl tool you already use for AMB Bitcoin and checks that both sides return the same block hash at the same height:
set -euo pipefail
: "${ALCHEMY_API_KEY:?Set ALCHEMY_API_KEY}"
: "${AWS_REGION:?Set AWS_REGION}"
HEIGHT="${1:-850000}"
BODY="{\"jsonrpc\":\"1.0\",\"id\":\"parity\",\"method\":\"getblockhash\",\"params\":[$HEIGHT]}"
AMB=$(awscurl -X POST --service managedblockchain --region "$AWS_REGION" -d "$BODY" \
"https://mainnet.bitcoin.managedblockchain.$AWS_REGION.amazonaws.com" | jq -r .result)
ALC=$(curl -s -X POST -H "Content-Type: application/json" -d "$BODY" \
"https://bitcoin-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY" | jq -r .result)
if [ "$AMB" = "$ALC" ]; then echo "block $HEIGHT match: $ALC"; else echo "MISMATCH at $HEIGHT: AMB=$AMB Alchemy=$ALC"; exit 1; fiRun the same comparison for Ethereum and Polygon with eth_getBlockByNumber at a block well past finality, and for any historical eth_call your application depends on. If your AMB Ethereum node uses Accessor tokens, its token endpoint works in any plain JSON-RPC client, so this comparison needs no signing code. A mismatch at a finalized block almost always means the wrong network URL.
Once the checks pass, shift traffic in stages behind a feature flag or weighted routing, and keep AMB as a rollback path until you are confident. How to migrate between RPC providers with zero downtime covers the staged cutover in detail, including keeping a backup RPC endpoint after the move.
How does Alchemy pricing compare with AWS Managed Blockchain?
AMB bills differently for each product. AMB Access Ethereum nodes bill per second for as long as they run, plus storage and requests. AMB Access Bitcoin and AMB Query bill per request, in tiers that depend on the method. We bill every chain and API the same way, in compute units (CUs), where a light call costs fewer units than a heavy one.
As one concrete comparison, AWS's AMB pricing page uses $16 per million getblock calls in its Bitcoin example. On our endpoint, getblock costs 10 CUs, which works out to about $5.25 per million calls on Pay As You Go. Our pricing page has the full plan details. High-volume teams can talk to our sales team about Enterprise plans, which are also available as private offers on AWS Marketplace.
Need help planning the move?
You can create a free Alchemy account and have working Ethereum, Bitcoin, and Polygon endpoints today, with no contract and no node to sync. That is enough to run the parity check against your AMB setup this week.
For production workloads, AMB Query migrations, or teams that relied on dedicated nodes, talk to our sales team. We will help you map your AMB setup, size the right plan, and schedule the cutover well ahead of September 2027. If you are also moving workloads off Google Cloud, our Google Cloud Blockchain Node Engine migration guide covers that switch.
Frequently asked questions
When does AWS Managed Blockchain (AMB) shut down?
Amazon Managed Blockchain reaches end of support on September 29, 2027. After that date, existing customers can no longer access AMB Access Ethereum, Bitcoin, Polygon, Hyperledger Fabric, or AMB Query. Plan the migration well before the deadline so you can run both providers side by side.
What is the best alternative to Amazon Managed Blockchain?
For AMB Access on Ethereum, Bitcoin, and Polygon, Alchemy is a direct replacement, and AWS's own node and RPC migration guide lists Alchemy as a third-party provider. Alchemy keeps the same JSON-RPC methods and replaces SigV4 signing with an API key. For AMB Query, Alchemy's Data API and UTXO API cover the indexed reads.
Do I have to rewrite my application to leave Amazon Managed Blockchain?
Not for AMB Access. Alchemy speaks standard JSON-RPC on Ethereum, Bitcoin, and Polygon, so you change the endpoint URL and remove SigV4 signing or Accessor tokens. AMB Query is an indexed API, so you replace its SDK calls with Alchemy Data API and UTXO API calls behind an adapter.
Which blockchain API offers indexed transaction history and token data like AMB Query?
Alchemy's Data API offers indexed transaction history and token data. On Ethereum it covers AMB Query's balance, transaction, transfer, token, and NFT reads, and Token Balances By Wallet replaces batched native and ERC-20 balance lookups. For Bitcoin, Alchemy's UTXO API covers addresses, balances, balance history, transactions, and unspent outputs. Map each AMB Query operation you use through an adapter and validate against captured AMB responses.
Can I pay for Alchemy through AWS?
Yes. Alchemy is listed on AWS Marketplace, so a subscription can be billed through your AWS account, and Enterprise plans are available as private offers. You can also start on Alchemy's Free plan, with 30 million compute units a month, and move to Pay As You Go at $0.525 per million compute units.
Which chains can I use after moving to Alchemy?
Every public chain AMB supported is available: Ethereum (Mainnet plus Sepolia and Hoodi), Bitcoin (Mainnet, Testnet, and Signet), and Polygon (Mainnet and Amoy). Beyond those, Alchemy supports more than 100 chains, including Base, Arbitrum, Optimism, and Solana, all with the same API key.
What about AMB Access Hyperledger Fabric?
Hyperledger Fabric runs private, permissioned ledgers, which is a different migration from moving public-chain RPC traffic. AWS's end-of-support notice lists the Fabric options: another managed Fabric network, self-managed Fabric on AWS, or an AWS database. If you are considering moving a Fabric workload onto a public chain, talk to Alchemy's sales team.
Related Overviews
InfraOctober 13, 2026
Google Cloud Blockchain Node Engine alternative: how to switch to Alchemy
Google Cloud Blockchain Node Engine shuts down December 15, 2026. Switch to Alchemy with a URL change, keep your code, and get 100+ chains on one key.
InfraMarch 30, 2026
Node RPC vs. Dedicated Clusters: choosing the right infrastructure for your workload
Learn how Alchemy's two infrastructure models work, when each one is the right fit, and how to decide for your team.
SolanaOctober 15, 2026
The 9 best Solana RPC providers in 2026: a decision guide
Compare the 9 best Solana RPC providers in 2026 for mission-critical apps, including dated latency by region, archival depth, multi-chain reach, gRPC pricing, free tiers, and a checklist to pick the right endpoint.
Build blockchain magic
Alchemy combines the most powerful web3 developer products and tools with resources, community and legendary support.