---
title: "AWS Managed Blockchain alternative: how to migrate AMB Access and AMB Query to Alchemy"
description: "AWS Managed Blockchain (AMB) shuts down September 29, 2027. Move AMB Access and AMB Query to Alchemy with the same JSON-RPC calls and a blockchain data API."
---

# AWS Managed Blockchain alternative: how to migrate AMB Access and AMB Query to Alchemy

<ImageBlock
  src="https://media.alchemy.com/blog/amazon-managed-blockchain-alternative-hero.png"
  alt="Migrate from AMB Access and AMB Query to Alchemy title card"
  width={1920}
  height={900}
  priority
/>

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](https://docs.aws.amazon.com/managed-blockchain/latest/hyperledger-fabric-dev/managed-blockchain-end-of-support.html), 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](https://docs.aws.amazon.com/managed-blockchain/latest/ethereum-dev/migrating-node-rpc-workloads.html) 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?

<ImageBlock
  src="https://media.alchemy.com/blog/amazon-managed-blockchain-alternative-migration-support.png"
  alt="AWS is shutting down Amazon Managed Blockchain, and Alchemy offers hands-on migration support"
  width={3200}
  height={1800}
/>

Sign up in the [Alchemy dashboard](https://dashboard.alchemy.com/), 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](/agents) signs you in, creates the app, and makes a first test call:

<CodeSnippet
  language="bash"
  code={`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 answers`}
/>

On 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](https://aws.amazon.com/marketplace/pp/prodview-vvdwfua4ksmkc), 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](/docs/alchemy-cli) runs the commands: creating apps, setting allowlists, and test calls against each network.
- [Alchemy Agent Skills](/docs/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](/docs/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/mcp` and signs in with your Alchemy account, so there is no API key to paste. Add it with `alchemy install mcp`, or in Claude Code:

<CodeSnippet
  language="bash"
  code={`claude mcp add alchemy --transport http https://mcp.alchemy.com/mcp`}
/>

On Claude Code, the [Alchemy plugin for Claude Code](/docs/alchemy-claude-plugin) installs the skills and the MCP server in one step, and [setting up Claude Code with Alchemy](/blog/setup-claude-code-with-alchemy) walks through it.

Then give the agent a prompt like this from the root of your repository:

<CodeSnippet
  language="text"
  code={`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.

<EmbeddedTable
  table={{
    columns: [
      {
        key: "1",
        width: 360,
        title: "On Amazon Managed Blockchain",
        dataType: "object",
      },
      { key: "2", width: 360, title: "On Alchemy", dataType: "object" },
    ],
    data: [
      {
        "1": {
          title: "<p>AMB Access Ethereum node on Mainnet</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Ethereum Mainnet endpoint over HTTP and WebSocket, with historical state on the same endpoint</p>",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        "1": {
          title: "<p>AMB Ethereum Consensus API</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>Ethereum Beacon endpoint</p>",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        "1": {
          title: "<p>AMB Access Bitcoin (Mainnet, Testnet)</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Bitcoin JSON-RPC endpoints, plus the UTXO API for address-level data</p>",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
      {
        "1": {
          title: "<p>AMB Access Polygon (Mainnet)</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Polygon Mainnet endpoint with WebSocket subscriptions and batch requests</p>",
          tooltip: "",
          icon: "",
        },
        id: 3,
      },
      {
        "1": { title: "<p>AMB Query</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>Data APIs for Ethereum, UTXO API for Bitcoin</p>",
          tooltip: "",
          icon: "",
        },
        id: 4,
      },
      {
        "1": {
          title: "<p>SigV4 signing or Accessor tokens</p>",
          tooltip: "",
          icon: "",
        },
        "2": { title: "<p>API key in the URL path</p>", tooltip: "", icon: "" },
        id: 5,
      },
      {
        "1": {
          title: "<p>IAM policies on managedblockchain actions</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>IP and origin allowlists on each app</p>",
          tooltip: "",
          icon: "",
        },
        id: 6,
      },
      {
        "1": {
          title: "<p>Dedicated Ethereum nodes</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Our RPC API, or Alchemy Dedicated Clusters for single-tenant capacity</p>",
          tooltip: "",
          icon: "",
        },
        id: 7,
      },
    ],
  }}
/>

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](/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](/docs/reference/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](/dedicated-clusters), and [choosing between Node RPC and Dedicated Clusters](/overviews/dedicated-vs-shared-nodes) explains when that is worth it.

Here is the endpoint swap as environment variables:

<CodeSnippet
  language="bash"
  code={`# 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:

<CodeSnippet
  language="bash"
  code={`# 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:

<CodeSnippet
  language="typescript"
  code={`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](https://docs.aws.amazon.com/managed-blockchain/latest/ambq-dg/migrating-query-workloads.html) 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.

<EmbeddedTable
  table={{
    columns: [
      {
        key: "1",
        width: 240,
        title: "AMB Query operation",
        dataType: "object",
      },
      {
        key: "2",
        width: 240,
        title: "Ethereum on Alchemy",
        dataType: "object",
      },
      { key: "3", width: 240, title: "Bitcoin on Alchemy", dataType: "object" },
    ],
    data: [
      {
        "1": { title: "<p>GetTokenBalance</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p><code>eth_getBalance</code> or <code>eth_call</code> at a block (<code>balanceOf</code> for ERC-20 and ERC-1155, <code>ownerOf</code> for ERC-721)</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title:
            "<p>UTXO API <code>address</code> endpoint (current balance)</p>",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        "1": { title: "<p>BatchGetTokenBalance</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p>Token Balances By Wallet for native and ERC-20 balances, plus per-token <code>eth_call</code> reads for ERC-721 and ERC-1155</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>UTXO API <code>address</code>, one call per address</p>",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        "1": { title: "<p>ListTokenBalances</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p>Token Balances By Wallet and <code>getNFTsForOwner</code>; <code>getOwnersForContract</code> for NFT holder lists</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title:
            "<p>UTXO API <code>address</code> and <code>utxo</code> endpoints</p>",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
      {
        "1": { title: "<p>GetTransaction</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p><code>eth_getTransactionByHash</code> and <code>eth_getTransactionReceipt</code></p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>UTXO API <code>tx</code> endpoint</p>",
          tooltip: "",
          icon: "",
        },
        id: 3,
      },
      {
        "1": { title: "<p>ListTransactions</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p><code>alchemy_getAssetTransfers</code> for transfer activity (or Transfers By Wallet)</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title:
            "<p>UTXO API <code>address</code> endpoint with transaction details</p>",
          tooltip: "",
          icon: "",
        },
        id: 4,
      },
      {
        "1": { title: "<p>ListTransactionEvents</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>Receipt logs, plus traces for internal ETH transfers</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title:
            "<p>UTXO API <code>tx</code> endpoint (inputs and outputs)</p>",
          tooltip: "",
          icon: "",
        },
        id: 5,
      },
      {
        "1": { title: "<p>GetAssetContract</p>", tooltip: "", icon: "" },
        "2": {
          title:
            "<p><code>alchemy_getTokenMetadata</code> and NFT <code>getContractMetadata</code></p>",
          tooltip: "",
          icon: "",
        },
        "3": { title: "<p>Not applicable</p>", tooltip: "", icon: "" },
        id: 6,
      },
      {
        "1": { title: "<p>ListAssetContracts</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>No single call; keep a contract registry</p>",
          tooltip: "",
          icon: "",
        },
        "3": { title: "<p>Not applicable</p>", tooltip: "", icon: "" },
        id: 7,
      },
      {
        "1": {
          title: "<p>ListFilteredTransactionEvents</p>",
          tooltip: "",
          icon: "",
        },
        "2": { title: "<p>Not applicable</p>", tooltip: "", icon: "" },
        "3": {
          title:
            "<p>UTXO API <code>address</code> and <code>utxo</code> endpoints</p>",
          tooltip: "",
          icon: "",
        },
        id: 8,
      },
    ],
  }}
/>

### Ethereum: indexed transaction history and token data

The Ethereum side runs on our [Data API](/docs/data). The [Token API](/token-api) covers ERC-20 balances and metadata, the [NFT API](/nft-api) covers ERC-721 and ERC-1155 holdings, and the [Transfers API](/docs/reference/transfers-api-quickstart) 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:

<CodeSnippet
  language="bash"
  code={`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](/docs/bitcoin/utxo-migration-guide), 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:

<CodeSnippet
  language="bash"
  code={`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.** `ListAssetContracts` filters 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 `nextToken` becomes our `pageKey` (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:

<CodeSnippet
  language="bash"
  code={`#!/usr/bin/env bash
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; fi`}
/>

Run 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](/blog/migrate-between-rpc-providers-zero-downtime) covers the staged cutover in detail, including keeping a [backup RPC endpoint](/overviews/alternative-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.

<EmbeddedTable
  table={{
    columns: [
      { key: "1", width: 240, title: "", dataType: "object" },
      {
        key: "2",
        width: 240,
        title: "Amazon Managed Blockchain",
        dataType: "object",
      },
      { key: "3", width: 240, title: "Alchemy", dataType: "object" },
    ],
    data: [
      {
        "1": { title: "<p>Ethereum nodes</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>Per node, billed per second while running</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>No nodes to run, billed per request in CUs</p>",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        "1": { title: "<p>Bitcoin and data APIs</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>Per request, priced in method tiers</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>Per request in CUs, same rate for every chain</p>",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        "1": { title: "<p>Getting started</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>AWS account and IAM setup</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>Free plan with 30M CUs a month</p>",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
      {
        "1": { title: "<p>Paid usage</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Region-dependent rates</p>", tooltip: "", icon: "" },
        "3": {
          title: "<p>Pay As You Go at $0.525 per million CUs</p>",
          tooltip: "",
          icon: "",
        },
        id: 3,
      },
      {
        "1": { title: "<p>Buying through AWS</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Native AWS billing</p>", tooltip: "", icon: "" },
        "3": {
          title: "<p>Available on AWS Marketplace</p>",
          tooltip: "",
          icon: "",
        },
        id: 4,
      },
    ],
  }}
/>

As one concrete comparison, AWS's [AMB pricing page](https://aws.amazon.com/managed-blockchain/pricing/) 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](/pricing) 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](https://dashboard.alchemy.com/) 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](/contact-sales). 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](/overviews/google-cloud-blockchain-node-engine-alternative) 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.