Migrate from Alchemy

Swap POST-with-key-in-URL Data APIs for flat GET endpoints.

Alchemy to GoldRush16 endpoints
Direct equivalent
4
Needs work
2
No equivalent
2
GoldRush advantage
8
Reviewed . Paths read from www.alchemy.com, goldrush.dev.

Why move from Alchemy

Alchemy splits wallet data across three surfaces: Data APIs (POST, API key in the URL path), enhanced JSON-RPC methods (alchemy_getAssetTransfers and friends), and standard node RPC. GoldRush serves the same reads as flat authenticated GETs, and serves JSON-RPC on the same key. Alchemy remains stronger on node infrastructure breadth, webhooks, and account abstraction, and this guide says where.

What changes before any endpoint works

The cross-cutting differences. Miss one and every call fails the same way, so fix these first.

Alchemy vs GoldRush: auth, format and pagination
AlchemyGoldRush
Base URLhttps://api.g.alchemy.com/data/v1/{apiKey}/... and https://{network}.g.alchemy.com/v2/{apiKey} for RPChttps://api.covalenthq.com
AuthAPI key embedded in the URL path, so it leaks into logs, referrers, and traces.Authorization: Bearer <GOLDRUSH_API_KEY>, so the key stays in the header.
Request stylePOST with a JSON body for Data APIs; JSON-RPC POST envelopes for alchemy_* methods.GET with path and query params. Cacheable and curl-able.
Chain addressingNetwork slug per subdomain for RPC (eth-mainnet.g.alchemy.com); networks[] array in the body for Data APIs.Chain slug in the path, or /v1/allchains/* for cross-chain reads.
PaginationCursor tokens whose parameter name varies by endpoint.Page number in the path, uniform across endpoints. Page 0 is the OLDEST page.

Endpoint mapping

Every Alchemy endpoint we could source, with its GoldRush equivalent. Rows marked No equivalent are gaps we won't paper over, so read those first. Verify a row against the Alchemy docs before relying on it.

Alchemy endpoints and their GoldRush equivalents
Use caseAlchemyGoldRushParity
Token balances with pricesPOST /data/v1/{apiKey}/assets/tokens/by-addressGET /v1/{chainName}/address/{walletAddress}/balances_v2/Direct equivalent
Multichain balancesPOST /data/v1/{apiKey}/assets/tokens/by-address (networks[] in body)GET /v1/allchains/address/{walletAddress}/balances/Direct equivalent
NFTs heldPOST /data/v1/{apiKey}/assets/nfts/by-addressGET /v1/{chainName}/address/{walletAddress}/balances_nft/Direct equivalent
Transfer historyalchemy_getAssetTransfers (JSON-RPC)GET /v1/{chainName}/address/{walletAddress}/transfers_v2/Direct equivalent
Full transaction historyOne call instead of two. Decoded log_events are already attached to each transaction.alchemy_getAssetTransfers + alchemy_getTransactionReceiptsGET /v1/{chainName}/address/{walletAddress}/transactions_v3/page/{page}/GoldRush advantage
Token metadataMetadata rides along with balances. For a standalone lookup use the pricing endpoint, which returns ticker, decimals, and logo with the price.alchemy_getTokenMetadata (JSON-RPC)GET /v1/{chainName}/address/{walletAddress}/balances_v2/Needs work
Token prices by addressSame endpoint serves live and historical. Alchemy needs a separate historical call.POST /prices/v1/{apiKey}/tokens/by-addressGET /v1/pricing/historical_by_addresses_v2/{chainName}/{quoteCurrency}/{contractAddress}/GoldRush advantage
Token approvalsNot availableGET /v1/{chainName}/approvals/{walletAddress}/GoldRush advantage
Historical balances by dateNot availableGET /v1/{chainName}/address/{walletAddress}/historical_balances/GoldRush advantage
Portfolio value over timeNot availableGET /v1/{chainName}/address/{walletAddress}/portfolio_v2/GoldRush advantage
Token holders at a blockNot availableGET /v1/{chainName}/tokens/{tokenAddress}/token_holders_v2/GoldRush advantage
Log events by contract or topicGoldRush decodes against the ABI. eth_getLogs returns raw topics and data for you to decode.eth_getLogs (standard RPC, undecoded)GET /v1/{chainName}/events/address/{contractAddress}/GoldRush advantage
Bitcoin dataNot availableGET /v1/btc-mainnet/address/{walletAddress}/balances_v2/GoldRush advantage
JSON-RPC node accessAlchemy covers more networks and more enhanced methods. If node breadth is the reason you are on Alchemy, that is a real reason to stay.https://{network}.g.alchemy.com/v2/{apiKey}GoldRush JSON-RPC on 30+ EVM chainsNeeds work
Webhooks / NotifyAlchemy Notify webhooksNoneNo equivalent
Account abstraction / bundlerOut of scope for GoldRush. We are a data API, not an infrastructure suite.Alchemy Account Kit, bundler and paymaster APIsNoneNo equivalent

Sources: www.alchemy.com and goldrush.dev for Alchemy, the GoldRush docs for GoldRush.

Before and after

Code you can paste. On the left, what you have on Alchemy; on the right, the GoldRush replacement.

Token balances with prices

Alchemy

// BEFORE -- Alchemy: POST, key in the URL path, networks in the body.
const res = await fetch(
  "https://api.g.alchemy.com/data/v1/" + process.env.ALCHEMY_API_KEY +
    "/assets/tokens/by-address",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      addresses: [{ address, networks: ["eth-mainnet", "base-mainnet"] }],
      withPrices: true,
    }),
  }
);
const body = await res.json();
const tokens = body.data.tokens;

GoldRush

// AFTER -- GoldRush: GET, key in the header, chains as a query param.
const res = await fetch(
  "https://api.covalenthq.com/v1/allchains/address/" + address +
    "/balances/?chains=eth-mainnet,base-mainnet",
  { headers: { Authorization: "Bearer " + process.env.GOLDRUSH_API_KEY } }
);
const { data, error, error_message } = await res.json();
if (error) throw new Error(error_message);
const tokens = data.items; // quote (USD) already on each item

Transaction history: two calls become one

Alchemy

// BEFORE -- Alchemy: getAssetTransfers for the list, then receipts for detail.
const rpc = "https://eth-mainnet.g.alchemy.com/v2/" + process.env.ALCHEMY_API_KEY;

const transfers = await fetch(rpc, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    id: 1,
    jsonrpc: "2.0",
    method: "alchemy_getAssetTransfers",
    params: [{
      fromAddress: address,
      category: ["external", "internal", "erc20", "erc721", "erc1155"],
    }],
  }),
}).then((r) => r.json());

// Second pass for receipts / logs, batched by block.
const receipts = await fetch(rpc, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    id: 1,
    jsonrpc: "2.0",
    method: "alchemy_getTransactionReceipts",
    params: [{ blockNumber: transfers.result.transfers[0].blockNum }],
  }),
}).then((r) => r.json());

GoldRush

// AFTER -- GoldRush: one GET, decoded log_events already attached.
const res = await fetch(
  "https://api.covalenthq.com/v1/eth-mainnet/address/" + address +
    "/transactions_v3/page/0/",
  { headers: { Authorization: "Bearer " + process.env.GOLDRUSH_API_KEY } }
);
const { data, error, error_message } = await res.json();
if (error) throw new Error(error_message);

for (const tx of data.items) {
  // Decoded against the contract ABI -- no second call, no manual decoding.
  for (const ev of tx.log_events ?? []) {
    console.log(ev.decoded?.name, ev.sender_contract_ticker_symbol);
  }
}

Getting the key out of the URL

Alchemy

# BEFORE -- Alchemy puts the API key in the path. It lands in access logs,
# proxy traces, and anything that records a URL.
curl -X POST \
  "https://api.g.alchemy.com/data/v1/$ALCHEMY_API_KEY/assets/tokens/by-address" \
  -H "Content-Type: application/json" \
  -d '{"addresses":[{"address":"'$ADDRESS'","networks":["eth-mainnet"]}]}'

GoldRush

# AFTER -- GoldRush keeps the credential in the Authorization header,
# so the URL is safe to log, cache, and share in a bug report.
curl "https://api.covalenthq.com/v1/eth-mainnet/address/$ADDRESS/balances_v2/" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

Migration steps

The port in order. Each step is small enough to ship and check on its own.

  1. 1.

    Move the key out of the URL

    Replace the key-in-path pattern with Authorization: Bearer <GOLDRUSH_API_KEY>. Then audit logs and dashboards for previously leaked Alchemy keys and rotate them.

  2. 2.

    Convert POST bodies to GET params

    Alchemy Data API bodies become path segments and query params. The addresses/networks array becomes either a chain slug in the path or a chains= list on /v1/allchains/*.

  3. 3.

    Replace alchemy_* RPC calls with REST

    alchemy_getAssetTransfers becomes transfers_v2; getAssetTransfers plus getTransactionReceipts collapses into transactions_v3. Drop the JSON-RPC envelope entirely for these reads.

  4. 4.

    Delete your ABI decoding layer

    GoldRush attaches decoded log_events to each transaction. Whatever you built to decode raw topics from eth_getLogs can usually be removed.

  5. 5.

    Swap cursor pagination for page paths

    Alchemy's cursor parameter names vary per endpoint. GoldRush uses .../page/{page}/ uniformly, with page 0 as the oldest page.

  6. 6.

    Keep Alchemy where it is genuinely ahead

    If you use Notify webhooks, Account Kit, or networks GoldRush does not serve over RPC, keep those on Alchemy and move only the data reads.

What you lose by moving

If one of these is load-bearing for your product, don't migrate that surface. Running both providers is a legitimate answer.

  • Fewer JSON-RPC networks and enhanced methods

    GoldRush serves JSON-RPC on 30+ EVM chains. Alchemy covers more networks and a deeper set of enhanced methods. If you are on Alchemy primarily for node infrastructure, that is a legitimate reason to stay.

  • No webhooks

    Alchemy Notify pushes events to your endpoint. GoldRush has no equivalent, so real-time becomes polling.

  • No account abstraction stack

    Account Kit, bundler, and paymaster APIs have no GoldRush counterpart and are not on our roadmap. GoldRush is a data API.

  • No first-class DeFi protocol positions

    There is no GoldRush endpoint that returns staking, lending, or LP positions decoded per protocol. balances_v2 returns LP and receipt tokens as token balances, so the value is visible, but the protocol-level breakdown is not. This is a real gap, not a naming difference.

What you gain

Each of these maps to a row above or to a documented GoldRush capability.

  • GET instead of POST, header instead of URL

    Flat authenticated GETs are cacheable at the CDN, easy to curl, and keep the API key out of URLs and access logs. Alchemy's Data APIs are POSTs with the key in the path.

  • One call where Alchemy needs two

    Full transaction history with decoded log_events is a single request. On Alchemy it is alchemy_getAssetTransfers plus alchemy_getTransactionReceipts, then your own ABI decoding.

  • 100+ chains, including Bitcoin

    Live chain list at /v1/chains/ and per-chain sync state at /v1/chains/status/. Bitcoin is first-class with its own balances, historical balances, and HD-wallet endpoints. Most wallet APIs are EVM-only or EVM+Solana.

  • x402: no signup, no API key

    An autonomous agent can pay per request from an onchain wallet without registering an account or holding a key. If you are building agents rather than a dashboard, this removes the credential provisioning step entirely.

Start the port

A free API key comes with 25,000 credits and no card. Or skip signup and pay per request with x402.

Common questions

For decoded wallet and contract data, yes. For node RPC it depends on your networks: GoldRush serves 30+ EVM chains and Alchemy serves more. For webhooks and account abstraction, no. Many teams move the data reads and keep Alchemy for infrastructure.

Still deciding?

This guide assumes you have decided to move. The comparison covers pricing, coverage and features side by side.

GoldRush vs Alchemy

Other migration guides

  • From Zerion API

    Every Zerion v1 wallet endpoint, mapped to its GoldRush equivalent.

  • From Dune Sim

    Sim shut down on 1 August 2026. Here is where each endpoint goes.

  • From DeBank Cloud

    Map the /v1/user/* Pro API onto GoldRush, including what does not port.