Migration guide

Migrate from Alchemy to GoldRush

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

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 — this guide says where.

4 direct2 need work2 no equivalent8 GoldRush only

Reviewed 2026-09-11. Endpoint paths read from www.alchemy.com, goldrush.dev. Verify against Alchemy docs before relying on a row.

What changes before any endpoint works

These are the cross-cutting differences. Miss one and every call fails the same way, so fix them first.

 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 — leaks into logs, referrers, and traces.Authorization: Bearer <GOLDRUSH_API_KEY> — 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 are not going to paper over — read those first.

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 history
One 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 metadata
Metadata 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 address
Same 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 topic
GoldRush 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 access
Alchemy 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 webhooksNo equivalent
Account abstraction / bundler
Out of scope for GoldRush. We are a data API, not an infrastructure suite.
Alchemy Account Kit, bundler and paymaster APIsNo equivalent

Before and after

Copy-pasteable. Left is what you have on Alchemy; right is 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

  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. 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. 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. 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. 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. 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 any of these is load-bearing for your product, do not 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

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.

Migration FAQ

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.

Start the port

Free API key with 25,000 credits and no card, or skip signup entirely and pay per request with x402.

Still deciding?

This page assumes you have decided to move. If you are still evaluating, the comparison covers pricing, coverage, and feature parity side by side.

GoldRush vs Alchemy

Other migration guides

Get Started

Get started with GoldRush API in minutes. Sign up for a free API key and start building.

Support

Explore multiple support options! From FAQs for self-help to real-time interactions on Discord.

Contact Sales

Interested in our professional or enterprise plans? Contact our sales team to learn more.