Google Cloud Blockchain Node Engine alternative: how to switch to Alchemy

Q: Can an AI coding agent migrate my endpoints?

Yes. Install the Alchemy CLI, run alchemy install skills, and add the Alchemy MCP server, then ask an agent such as Claude Code or Cursor to find every Google Cloud endpoint and API key in your repository, propose the replacements, and wait for approval. The agent can then verify each new endpoint with the CLI.

Written by Uttam Singh

Published on October 13, 20269 min read

Migrate from Google Cloud Blockchain Node Engine to Alchemy title card

Google Cloud is retiring Blockchain Node Engine and its shared Blockchain RPC service on December 15, 2026. Switching to Alchemy is a URL change, not a rewrite. You replace the endpoint and API key, and the same JSON-RPC calls return the same data.

The switch also changes what you are responsible for. Blockchain Node Engine gave you nodes on three chains, billed by the hour. We give you one API key that works across more than 100 chains, with no nodes to provision or upgrade. This guide covers getting an endpoint, handing the find-and-replace to a coding agent, what each part of your Google Cloud setup becomes, how to prove the new endpoint returns identical data, and how the costs compare.

What changes on December 15?

On December 15, 2026, Google deletes every remaining Blockchain Node Engine node and Blockchain RPC endpoint, and any request to them fails, per Google's Blockchain Node Engine shutdown notice. Until then, you can't create new nodes or endpoints. If a node falls behind or your traffic grows, the fix has to happen on another provider.

Blockchain Node Engine ran nodes for Ethereum (Mainnet, plus the Sepolia, Holesky, and Goerli testnets), Polygon PoS, and Solana, and Blockchain RPC served Ethereum. We already support every one of those chains, so each workload you run on Google Cloud today has a matching endpoint on Alchemy, listed in the mapping section below.

One billing detail matters on the way out. Google removes Blockchain RPC endpoints itself, but you have to delete Blockchain Node Engine nodes in the Google Cloud console, and they keep billing until you do.

Treat December 15 as the day the URLs stop working, and aim to have production traffic off them weeks before.

How do you get an Alchemy endpoint?

Sign up in the Alchemy dashboard, create an app, and turn on the networks you used on Google Cloud. Each network gets its own URL, and one app's API key works on all of them.

If you would rather stay in the terminal, the Alchemy CLI signs you in, creates the app, and makes a first test call in a few commands:

bashCopied
npm i -g @alchemy/cli@latest
alchemy auth                                  # browser sign-in
alchemy app create --name gcp-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 instead. alchemy app chains lists the identifiers for every other network you can add to the app, such as Polygon and Solana.

Can a coding agent do the migration for you?

Yes, and it is the quickest route when endpoint URLs are spread across several services and config files. 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, 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 query the networks you are migrating 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:

bash

Copied

claude mcp add alchemy --transport http https://mcp.alchemy.com/mcp

On 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 the setup.

Then give the agent a prompt like this from the root of your repository. It collects your details first and waits for approval before touching files:

text

Copied

I'm moving this project off Google Cloud Blockchain Node Engine and Blockchain RPC, which shut down on December 15, 2026. The new provider is Alchemy. Use the Alchemy CLI, Alchemy skills, and the Alchemy MCP server.
Before changing anything, ask me:
- which networks we run on, and whether any Google Cloud node was an archive node
- where our secrets live (env files, a secrets manager, CI variables)
- whether the new Alchemy app needs IP or origin allowlists
Then find every Google Cloud blockchain endpoint and every use of the Google API key (X-goog-api-key headers or ?key= parameters) across code, config, CI, Docker, and infrastructure files. Show me the list with file paths and wait.
After I approve, replace each endpoint with an environment variable that holds the Alchemy URL for that network, remove the Google key handling, and add placeholder entries to .env.example. Never commit a real API key.
Finally, run eth_chainId and eth_blockNumber against every migrated network with the Alchemy CLI and report the results.

You end up reviewing a list and a diff instead of searching every repository by hand. If you prefer to make the change manually, the work is the same. Search for the Google endpoint hostnames and the API key, swap in the Alchemy URL for each network, and remove the key header or query parameter, since our key sits in the URL path. Check the places endpoints tend to hide, like CI variables, Terraform, and scheduled jobs.

What does each part of your Google Cloud setup become?

Most of the mapping is one-to-one, and a few pieces of work go away entirely.

On Google Cloud	On Alchemy
Blockchain RPC shared endpoint (Ethereum only)	RPC API endpoint on any of 100+ chains
Blockchain Node Engine full node	Standard endpoint for the same network, no node to run
Blockchain Node Engine archive node	The same standard endpoint, which also serves historical state
Dedicated node for single-tenant isolation	Alchemy Dedicated Clusters
Google Cloud API key in a header or query parameter	API key in the URL path
API key restrictions and VPC Service Controls	IP and origin allowlists on each app
Goerli and Holesky testnets	Sepolia and Hoodi
Node upgrades before each hard fork	Handled by us

Our RPC API covers the shared endpoint and the full and archive node cases. If you chose Blockchain Node Engine for single-tenant isolation, Alchemy Dedicated Clusters give you capacity reserved for your workload, and choosing between Node RPC and Dedicated Clusters explains when that is worth it. Allowlists can be set in the dashboard or from the CLI with alchemy app ip-allowlist and alchemy app origin-allowlist.

Here are the endpoints for every network Blockchain Node Engine supported, written as environment variables:

bashCopied
# Ethereum
ETH_MAINNET_URL=https://eth-mainnet.g.alchemy.com/v2/<your-key>
ETH_SEPOLIA_URL=https://eth-sepolia.g.alchemy.com/v2/<your-key>
ETH_HOODI_URL=https://eth-hoodi.g.alchemy.com/v2/<your-key>
ETH_MAINNET_BEACON_URL=https://eth-mainnetbeacon.g.alchemy.com/v2/<your-key>
# Polygon PoS
POLYGON_MAINNET_URL=https://polygon-mainnet.g.alchemy.com/v2/<your-key>
POLYGON_AMOY_URL=https://polygon-amoy.g.alchemy.com/v2/<your-key>
# Solana
SOLANA_MAINNET_URL=https://solana-mainnet.g.alchemy.com/v2/<your-key>

For WebSockets, swap https:// for wss://. The Beacon endpoint covers teams that queried the consensus layer on their Ethereum node.

A few network details are worth checking. Goerli traffic moves to Sepolia, and Holesky traffic moves to Hoodi (we also still serve Holesky). On Polygon, if you called debug methods with a specific tracer on an archive node, confirm that tracer in our Debug API docs. On Solana, the standard JSON-RPC methods work unchanged on our endpoint, and for real-time data, Solana gRPC streaming replaces polling.

How do you prove the new endpoint returns the same data?

Run a parity check before any production traffic moves. The script below reads the same finalized block and the same historical balance from both providers and compares the results. It uses viem, but any JSON-RPC client works.

typescriptCopied
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
const { GCP_ETH_RPC_URL, GCP_API_KEY, ETH_MAINNET_URL, CHECK_ADDRESS } = process.env;
// Fail fast: viem's http() silently falls back to a public RPC when the URL is undefined.
if (!GCP_ETH_RPC_URL || !ETH_MAINNET_URL || !CHECK_ADDRESS) {
throw new Error("Set GCP_ETH_RPC_URL, ETH_MAINNET_URL, and CHECK_ADDRESS first");
}
const address = CHECK_ADDRESS as `0x${string}`;
const google = createPublicClient({
chain: mainnet,
transport: http(GCP_ETH_RPC_URL, {
  fetchOptions: { headers: { "X-goog-api-key": GCP_API_KEY ?? "" } },
}),
});
const alchemy = createPublicClient({
chain: mainnet,
transport: http(ETH_MAINNET_URL),
});
async function main() {
// 64 blocks back is past Ethereum finality, so both sides must agree.
const head = await alchemy.getBlockNumber();
const blockNumber = head - 64n;
const [a, b] = await Promise.all([
  google.getBlock({ blockNumber }),
  alchemy.getBlock({ blockNumber }),
]);
console.log(`block ${blockNumber} hash match:`, a.hash === b.hash);
// Archive check. Skip this part if your Google Cloud node was a full node.
const oldBlock = 15_000_000n;
const [balA, balB] = await Promise.all([
  google.getBalance({ address, blockNumber: oldBlock }),
  alchemy.getBalance({ address, blockNumber: oldBlock }),
]);
console.log(`balance at block ${oldBlock} match:`, balA === balB);
}
main();

Run it for each network you migrate, with an address your app actually queries. A hash mismatch at a finalized block means something is misconfigured, usually the wrong network URL, so fix that before going further.

Once the checks pass, move traffic over in stages behind a feature flag or weighted routing, and keep the Google Cloud endpoint as a fallback until December. How to migrate between RPC providers with zero downtime covers the staged cutover in detail, including keeping a backup RPC endpoint after the move. When traffic is fully switched, delete your Blockchain Node Engine nodes in the Google Cloud console so they stop billing.

What can you remove from your stack after switching?

Blockchain Node Engine gave you a raw node, so anything above JSON-RPC was code your team wrote and maintained. Switching providers is a good moment to retire some of it.

Transaction history indexers. If you scan blocks or logs to rebuild an address's history, the Transfers API returns that history in one call, without indexing the chain yourself.
Polling loops for deposits. Code that polls new blocks to catch incoming transfers can be replaced by Address Activity webhooks, which push transfer events for up to 100,000 addresses per webhook.
Per-chain provisioning. Adding Base, Arbitrum, or Optimism was never an option on Blockchain Node Engine. On Alchemy, it is a network you enable on the same app, with the same key.

The same key also works with our Data API for token balances, prices, and NFT data, so the endpoint you migrate to today covers features you would otherwise build later.

How do the costs compare?

The two products bill in different ways. Blockchain Node Engine charges per node, per hour, whether the node serves traffic or sits idle. We charge for the requests you send, measured in compute units (CUs), where a light call like eth_blockNumber costs fewer units than a heavy trace.

	Google Cloud Blockchain Node Engine	Alchemy
Billing model	Per node, per hour	Per request, in compute units
Ethereum full node workload	$0.69 per hour, about $504 a month	Free plan with 30M CUs a month, or Pay As You Go at $0.525 per million CUs
Ethereum archive workload	$2.74 per hour, about $2,000 a month	Same endpoint and same rate
Idle hours	Billed	Not billed
Adding another chain	Another node, if the chain is supported	Same key, same rate

For scale, the roughly $2,000 a month that one Ethereum archive node costs on Google Cloud buys about 3.8 billion CUs on our Pay As You Go plan, spread across every chain on your account. Teams that ran a second node for redundancy paid that hourly rate twice. Our endpoints are served by a fleet of nodes behind the URL, so redundancy is not a second line item. High-volume teams can talk to our sales team about Enterprise plans and committed throughput.

Need help planning the move?

Google Cloud is shutting down Blockchain Node Engine, and Alchemy offers hands-on migration support

You can create a free Alchemy account and have a working endpoint today, with no contract and no node to sync. That is enough to run the parity check against your current setup this week.

For production workloads, multi-chain deployments, or teams that relied on dedicated nodes, talk to our sales team. We will help you map your Blockchain Node Engine setup, size the right plan, and schedule the cutover well ahead of December 15.

Frequently asked questions

When does Google Cloud Blockchain Node Engine shut down?

Google Cloud Blockchain Node Engine and Blockchain RPC shut down on December 15, 2026. On that date, Google deletes the remaining nodes and endpoints, and any application still calling them fails, so plan to switch weeks ahead.

What is a good alternative to Google Cloud Blockchain Node Engine?

Alchemy is a direct replacement. It supports every network Blockchain Node Engine offered (Ethereum, Polygon, and Solana) through the same standard JSON-RPC methods, plus more than 100 other chains on one API key. Teams that need single-tenant capacity can use Alchemy Dedicated Clusters instead of dedicated nodes.

Do I have to rewrite my application to leave Blockchain Node Engine?

No. Alchemy uses standard JSON-RPC, so clients like ethers, viem, and web3.py keep working. You change the endpoint URL for each network and remove the Google Cloud API key header or query parameter, because the Alchemy API key is part of the URL.

What replaces a dedicated Blockchain Node Engine node on Alchemy?

For most workloads, the standard Alchemy RPC endpoint replaces both full and archive nodes, with no node to run or upgrade. Teams that need capacity reserved for their workload alone can move to Alchemy Dedicated Clusters, which provide single-tenant infrastructure behind one endpoint.

Which chains can I use after moving to Alchemy?

Every network Blockchain Node Engine supported is available, including Ethereum Mainnet, Sepolia, Hoodi, Polygon Mainnet, Amoy, and Solana. Beyond those, Alchemy supports more than 100 chains, including Base, Arbitrum, Optimism, and BNB Chain, all reachable with the same API key.

Can an AI coding agent migrate my endpoints?

Yes. Install the Alchemy CLI, run alchemy install skills, and add the Alchemy MCP server, then ask an agent such as Claude Code or Cursor to find every Google Cloud endpoint and API key in your repository, propose the replacements, and wait for approval. The agent can then verify each new endpoint with the CLI.

Is Alchemy cheaper than Google Cloud Blockchain Node Engine?

For most workloads, yes. Blockchain Node Engine bills per node, per hour, about $504 a month for an Ethereum full node and $2,000 for an archive node, even when idle. Alchemy bills per request. The Free plan includes 30 million compute units a month, and Pay As You Go costs $0.525 per million compute units.