---
title: "Alternativa a Google Cloud Blockchain Node Engine: cómo cambiarte a Alchemy"
description: "Google Cloud Blockchain Node Engine cierra el 15 de diciembre de 2026. Cámbiate a Alchemy con un cambio de URL, conserva tu código y accede a más de 100 cadenas con una sola API key."
---

# Alternativa a Google Cloud Blockchain Node Engine: cómo cambiarte a Alchemy

<ImageBlock
  src="https://media.alchemy.com/blog/google-cloud-blockchain-node-engine-alternative-hero.png"
  alt="Tarjeta de título: migrar de Google Cloud Blockchain Node Engine a Alchemy"
  width={1920}
  height={900}
  priority
/>

Google Cloud va a retirar Blockchain Node Engine y su servicio compartido Blockchain RPC el 15 de diciembre de 2026. Cambiarte a Alchemy es un cambio de URL, no una reescritura. Reemplazas el endpoint y la API key, y las mismas llamadas JSON-RPC devuelven los mismos datos.

El cambio también modifica aquello de lo que eres responsable. Blockchain Node Engine te daba nodos en tres cadenas, facturados por hora. Nosotros te damos una API key que funciona en más de 100 cadenas, sin nodos que aprovisionar ni actualizar. Esta guía cubre cómo obtener un endpoint, cómo delegar la búsqueda y el reemplazo a un agente de código, en qué se convierte cada parte de tu configuración de Google Cloud, cómo comprobar que el nuevo endpoint devuelve datos idénticos y cómo se comparan los costos.

## ¿Qué cambia el 15 de diciembre?

El 15 de diciembre de 2026, Google elimina todos los nodos de Blockchain Node Engine y endpoints de Blockchain RPC que queden, y cualquier solicitud a ellos falla, según el [aviso de cierre de Blockchain Node Engine](https://docs.cloud.google.com/blockchain-node-engine/docs/release-notes) de Google. Hasta entonces, no puedes crear nodos ni endpoints nuevos. Si un nodo se queda atrás o tu tráfico crece, la solución tiene que pasar por otro proveedor.

Blockchain Node Engine ejecutaba nodos para Ethereum (Mainnet, además de las testnets Sepolia, Holesky y Goerli), Polygon PoS y Solana, y Blockchain RPC servía Ethereum. Ya soportamos cada una de esas cadenas, así que cada carga de trabajo que ejecutas hoy en Google Cloud tiene un endpoint equivalente en Alchemy, listado en la sección de equivalencias más abajo.

Un detalle de facturación importa al salir. Google elimina por su cuenta los endpoints de Blockchain RPC, pero tú tienes que eliminar los nodos de Blockchain Node Engine en la consola de Google Cloud, y se siguen facturando hasta que lo hagas.

Toma el 15 de diciembre como el día en que las URLs dejan de funcionar, y apunta a tener el tráfico de producción fuera de ellas semanas antes.

## ¿Cómo obtienes un endpoint de Alchemy?

Regístrate en el [dashboard de Alchemy](https://dashboard.alchemy.com/), crea una app y activa las redes que usabas en Google Cloud. Cada red tiene su propia URL, y la API key de una app funciona en todas ellas.

Si prefieres quedarte en la terminal, el [Alchemy CLI](/agents) inicia tu sesión, crea la app y hace una primera llamada de prueba en unos pocos comandos:

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

En un servidor remoto sin navegador, usa `alchemy auth login --device-code` en su lugar. `alchemy app chains` lista los identificadores de todas las demás redes que puedes agregar a la app, como Polygon y Solana.

## ¿Puede un agente de código hacer la migración por ti?

Sí, y es la ruta más rápida cuando las URLs de los endpoints están repartidas entre varios servicios y archivos de configuración. Ofrecemos tres herramientas que le dan a un agente de código (Claude Code, Cursor, Codex o similar) lo que necesita:

- El [Alchemy CLI](/docs/alchemy-cli) ejecuta los comandos: crear apps, configurar allowlists y hacer llamadas de prueba contra cada red.
- [Alchemy Agent Skills](/docs/alchemy-agent-skills) le enseñan al agente nuestros formatos de endpoint, métodos y uso del CLI. Instálalas con `alchemy install skills`.
- El [Alchemy MCP server](/docs/alchemy-mcp-server) le da al agente acceso directo a datos de cadena en más de 100 redes, para que pueda consultar las redes que estás migrando mientras trabaja. Está alojado en `https://mcp.alchemy.com/mcp` e inicia sesión con tu cuenta de Alchemy, así que no hay ninguna API key que pegar. Agrégalo con `alchemy install mcp`, o en Claude Code:

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

En Claude Code, el [plugin de Alchemy para Claude Code](/docs/alchemy-claude-plugin) instala las skills y el servidor MCP en un solo paso, y [configurar Claude Code con Alchemy](/blog/setup-claude-code-with-alchemy) explica la configuración paso a paso.

Luego dale al agente un prompt como este desde la raíz de tu repositorio. Primero recopila tus datos y espera tu aprobación antes de tocar archivos:

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

Terminas revisando una lista y un diff en lugar de buscar a mano en cada repositorio. Si prefieres hacer el cambio manualmente, el trabajo es el mismo. Busca los hostnames de los endpoints de Google y la API key, reemplázalos por la URL de Alchemy de cada red y elimina el header o el parámetro de consulta de la key, ya que nuestra key va en la ruta de la URL. Revisa los lugares donde los endpoints suelen esconderse, como las variables de CI, Terraform y los jobs programados.

## ¿En qué se convierte cada parte de tu configuración de Google Cloud?

La mayor parte de la equivalencia es uno a uno, y algunas tareas desaparecen por completo.

<EmbeddedTable
  table={{
    columns: [
      { key: "1", width: 320, title: "En Google Cloud", dataType: "object" },
      { key: "2", width: 320, title: "En Alchemy", dataType: "object" },
    ],
    data: [
      {
        "1": {
          title: "<p>Endpoint compartido de Blockchain RPC (solo Ethereum)</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Endpoint de RPC API en cualquiera de más de 100 cadenas</p>",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        "1": {
          title: "<p>Nodo completo de Blockchain Node Engine</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>Endpoint estándar para la misma red, sin nodo que operar</p>",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        "1": {
          title: "<p>Nodo de archivo de Blockchain Node Engine</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title:
            "<p>El mismo endpoint estándar, que también sirve estado histórico</p>",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
      {
        "1": {
          title: "<p>Nodo dedicado para aislamiento de un solo tenant</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>Alchemy Dedicated Clusters</p>",
          tooltip: "",
          icon: "",
        },
        id: 3,
      },
      {
        "1": {
          title:
            "<p>API key de Google Cloud en un header o parámetro de consulta</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>API key en la ruta de la URL</p>",
          tooltip: "",
          icon: "",
        },
        id: 4,
      },
      {
        "1": {
          title: "<p>Restricciones de API key y VPC Service Controls</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>Allowlists de IP y de origen en cada app</p>",
          tooltip: "",
          icon: "",
        },
        id: 5,
      },
      {
        "1": {
          title: "<p>Testnets Goerli y Holesky</p>",
          tooltip: "",
          icon: "",
        },
        "2": { title: "<p>Sepolia y Hoodi</p>", tooltip: "", icon: "" },
        id: 6,
      },
      {
        "1": {
          title: "<p>Actualizaciones de nodos antes de cada hard fork</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>Las gestionamos nosotros</p>",
          tooltip: "",
          icon: "",
        },
        id: 7,
      },
    ],
  }}
/>

Nuestra [RPC API](/rpc-api) cubre el endpoint compartido y los casos de nodo completo y de archivo. Si elegiste Blockchain Node Engine por el aislamiento de un solo tenant, [Alchemy Dedicated Clusters](/dedicated-clusters) te da capacidad reservada para tu carga de trabajo, y [cómo elegir entre Node RPC y Dedicated Clusters](/overviews/dedicated-vs-shared-nodes) explica cuándo vale la pena. Las allowlists se pueden configurar en el dashboard o desde el CLI con `alchemy app ip-allowlist` y `alchemy app origin-allowlist`.

Estos son los endpoints para cada red que soportaba Blockchain Node Engine, escritos como variables de entorno:

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

Para WebSockets, cambia `https://` por `wss://`. El endpoint Beacon cubre a los equipos que consultaban la capa de consenso en su nodo de Ethereum.

Vale la pena revisar algunos detalles de red. El tráfico de Goerli pasa a Sepolia, y el de Holesky pasa a Hoodi (también seguimos sirviendo Holesky). En Polygon, si llamabas métodos debug con un tracer específico en un nodo de archivo, confirma ese tracer en nuestra documentación de [Debug API](/docs/reference/debug-api-quickstart). En Solana, los métodos JSON-RPC estándar funcionan sin cambios en nuestro endpoint, y para datos en tiempo real, el [streaming gRPC de Solana](/solana-grpc) reemplaza el polling.

## ¿Cómo compruebas que el nuevo endpoint devuelve los mismos datos?

Ejecuta una verificación de paridad antes de mover cualquier tráfico de producción. El script de abajo lee el mismo bloque finalizado y el mismo balance histórico en ambos proveedores y compara los resultados. Usa [viem](https://viem.sh/), pero cualquier cliente JSON-RPC funciona.

<CodeSnippet
  language="typescript"
  code={`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();`}
/>

Ejecútalo para cada red que migres, con una dirección que tu app realmente consulte. Un hash que no coincide en un bloque finalizado significa que algo está mal configurado, normalmente la URL de red equivocada, así que corrígelo antes de seguir.

Una vez que las verificaciones pasen, mueve el tráfico por etapas detrás de un feature flag o de enrutamiento ponderado, y mantén el endpoint de Google Cloud como respaldo hasta diciembre. [Cómo migrar entre proveedores de RPC sin downtime](/blog/migrate-between-rpc-providers-zero-downtime) cubre la migración por etapas en detalle, incluido mantener un [endpoint RPC de respaldo](/overviews/alternative-rpc-endpoint) después del cambio. Cuando todo el tráfico se haya movido, elimina tus nodos de Blockchain Node Engine en la consola de Google Cloud para que dejen de facturarse.

## ¿Qué puedes quitar de tu stack después del cambio?

Blockchain Node Engine te daba un nodo en bruto, así que todo lo que estaba por encima de JSON-RPC era código que tu equipo escribía y mantenía. Cambiar de proveedor es un buen momento para retirar parte de eso.

- **Indexadores de historial de transacciones.** Si escaneas bloques o logs para reconstruir el historial de una dirección, la [Transfers API](/docs/reference/transfers-api-quickstart) devuelve ese historial en una sola llamada, sin que tengas que indexar la cadena tú mismo.
- **Loops de polling para depósitos.** El código que consulta bloques nuevos para detectar transferencias entrantes se puede reemplazar por [Address Activity webhooks](/docs/reference/address-activity-webhook), que envían eventos de transferencia para hasta 100,000 direcciones por webhook.
- **Aprovisionamiento por cadena.** Agregar Base, Arbitrum u Optimism nunca fue una opción en Blockchain Node Engine. En Alchemy, es una red que activas en la misma app, con la misma key.

La misma key también funciona con nuestra [Data API](/docs/data) para balances de tokens, precios y datos de NFT, así que el endpoint al que migras hoy cubre funciones que de otro modo construirías más adelante.

## ¿Cómo se comparan los costos?

Los dos productos facturan de formas distintas. Blockchain Node Engine cobra por nodo, por hora, ya sea que el nodo atienda tráfico o esté inactivo. Nosotros cobramos por las solicitudes que envías, medidas en unidades de cómputo (CUs), donde una llamada ligera como `eth_blockNumber` cuesta menos unidades que un trace pesado.

<EmbeddedTable
  table={{
    columns: [
      { key: "1", width: 220, title: "", dataType: "object" },
      {
        key: "2",
        width: 260,
        title: "Google Cloud Blockchain Node Engine",
        dataType: "object",
      },
      { key: "3", width: 260, title: "Alchemy", dataType: "object" },
    ],
    data: [
      {
        "1": { title: "<p>Modelo de facturación</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Por nodo, por hora</p>", tooltip: "", icon: "" },
        "3": {
          title: "<p>Por solicitud, en unidades de cómputo</p>",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        "1": {
          title: "<p>Carga de trabajo de nodo completo de Ethereum</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>$0.69 por hora, unos $504 al mes</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title:
            "<p>Plan Free con 30M de CUs al mes, o Pay As You Go a $0.525 por millón de CUs</p>",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        "1": {
          title: "<p>Carga de trabajo de archivo de Ethereum</p>",
          tooltip: "",
          icon: "",
        },
        "2": {
          title: "<p>$2.74 por hora, unos $2,000 al mes</p>",
          tooltip: "",
          icon: "",
        },
        "3": {
          title: "<p>Mismo endpoint y misma tarifa</p>",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
      {
        "1": { title: "<p>Horas inactivas</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Se facturan</p>", tooltip: "", icon: "" },
        "3": { title: "<p>No se facturan</p>", tooltip: "", icon: "" },
        id: 3,
      },
      {
        "1": { title: "<p>Agregar otra cadena</p>", tooltip: "", icon: "" },
        "2": {
          title: "<p>Otro nodo, si la cadena está soportada</p>",
          tooltip: "",
          icon: "",
        },
        "3": { title: "<p>Misma key, misma tarifa</p>", tooltip: "", icon: "" },
        id: 4,
      },
    ],
  }}
/>

Como referencia, los aproximadamente $2,000 al mes que cuesta un nodo de archivo de Ethereum en Google Cloud equivalen a unos 3.8 mil millones de CUs en nuestro plan Pay As You Go, repartidos entre todas las cadenas de tu cuenta. Los equipos que ejecutaban un segundo nodo para redundancia pagaban esa tarifa por hora dos veces. Nuestros endpoints los atiende una flota de nodos detrás de la URL, así que la redundancia no es una partida adicional. Los equipos de alto volumen pueden hablar con nuestro equipo de ventas sobre planes Enterprise y throughput comprometido.

## ¿Necesitas ayuda para planificar el cambio?

<ImageBlock
  src="https://media.alchemy.com/blog/google-cloud-blockchain-node-engine-alternative-migration-support.jpeg"
  alt="Google Cloud cierra Blockchain Node Engine y Alchemy ofrece soporte práctico para la migración"
  width={3200}
  height={1800}
/>

Puedes [crear una cuenta gratuita de Alchemy](https://dashboard.alchemy.com/) y tener un endpoint funcionando hoy, sin contrato y sin nodo que sincronizar. Eso basta para ejecutar la verificación de paridad contra tu configuración actual esta semana.

Para cargas de trabajo en producción, despliegues multi-cadena o equipos que dependían de nodos dedicados, [habla con nuestro equipo de ventas](/contact-sales). Te ayudaremos a mapear tu configuración de Blockchain Node Engine, dimensionar el plan adecuado y programar el cambio con bastante anticipación al 15 de diciembre.

## Preguntas frecuentes

### ¿Cuándo cierra Google Cloud Blockchain Node Engine?

Google Cloud Blockchain Node Engine y Blockchain RPC cierran el 15 de diciembre de 2026. En esa fecha, Google elimina los nodos y endpoints restantes, y cualquier aplicación que todavía los llame falla, así que planifica el cambio con semanas de anticipación.

### ¿Cuál es una buena alternativa a Google Cloud Blockchain Node Engine?

Alchemy es un reemplazo directo. Soporta todas las redes que ofrecía Blockchain Node Engine (Ethereum, Polygon y Solana) mediante los mismos métodos JSON-RPC estándar, además de más de 100 cadenas adicionales con una sola API key. Los equipos que necesitan capacidad de un solo tenant pueden usar Alchemy Dedicated Clusters en lugar de nodos dedicados.

### ¿Tengo que reescribir mi aplicación para dejar Blockchain Node Engine?

No. Alchemy usa JSON-RPC estándar, así que clientes como ethers, viem y `web3.py` siguen funcionando. Cambias la URL del endpoint de cada red y eliminas el header o el parámetro de consulta de la API key de Google Cloud, porque la API key de Alchemy forma parte de la URL.

### ¿Qué reemplaza a un nodo dedicado de Blockchain Node Engine en Alchemy?

Para la mayoría de las cargas de trabajo, el endpoint RPC estándar de Alchemy reemplaza tanto a los nodos completos como a los de archivo, sin nodo que operar ni actualizar. Los equipos que necesitan capacidad reservada solo para su carga de trabajo pueden pasar a Alchemy Dedicated Clusters, que ofrece infraestructura de un solo tenant detrás de un endpoint.

### ¿Qué cadenas puedo usar después de pasarme a Alchemy?

Todas las redes que soportaba Blockchain Node Engine están disponibles, incluidas Ethereum Mainnet, Sepolia, Hoodi, Polygon Mainnet, Amoy y Solana. Además, Alchemy soporta más de 100 cadenas, incluidas Base, Arbitrum, Optimism y BNB Chain, todas accesibles con la misma API key.

### ¿Puede un agente de código con IA migrar mis endpoints?

Sí. Instala el Alchemy CLI, ejecuta `alchemy install skills`, agrega el Alchemy MCP server y luego pídele a un agente como Claude Code o Cursor que encuentre cada endpoint y API key de Google Cloud en tu repositorio, proponga los reemplazos y espere tu aprobación. Después, el agente puede verificar cada endpoint nuevo con el CLI.

### ¿Alchemy es más barato que Google Cloud Blockchain Node Engine?

Para la mayoría de las cargas de trabajo, sí. Blockchain Node Engine factura por nodo, por hora, unos $504 al mes por un nodo completo de Ethereum y $2,000 por un nodo de archivo, incluso cuando están inactivos. Alchemy factura por solicitud. El plan Free incluye 30 millones de unidades de cómputo al mes, y Pay As You Go cuesta $0.525 por millón de unidades de cómputo.