alchemy_getAssetTransfers alternative: faster, cross-chain, cheaper

Alchemy's getAssetTransfers is the most-called Data API endpoint on the market. 1F's drop-in replacement adds cross-chain joins, sub-millisecond latency, and 60% lower price per million calls.

alchemy_getAssetTransfers is the most-used indexed Data API in web3. If you're building a portfolio tracker, a tax tool, a compliance flow, or an indexer-as-a-service product, you probably make this call hundreds of thousands of times per day. Here's how 1F's drop-in replacement compares.

The endpoint

1F exposes both shapes — the original Alchemy JSON-RPC method via the passthrough proxy, and a clean REST surface that's easier to consume:

# Alchemy-compat (same payload as alchemy_getAssetTransfers)
curl -X POST https://1f.ai/v2/$KEY/eth-mainnet \
  -d '{"jsonrpc":"2.0","method":"alchemy_getAssetTransfers","params":[{...}],"id":1}'

# 1F native — same data, REST-shaped, multichain
curl https://1f.ai/api/cross-chain/transfers/0xab5801a7d398351b8be11c439e05c5b3259aec9b \
  -H "X-API-Key: $KEY"

Latency

Median latency on warm-cache transfer queries:

Provider	p50	p99
Alchemy `getAssetTransfers` (10 results)	~120 ms	~340 ms
1F `/api/cross-chain/transfers` (10 results)	~6 ms	~22 ms

The gap comes from how the data is stored. Alchemy serves transfers from a generic OLAP backend that has to scan-and-filter; 1F stores edges in a graph index where the "transfers-touching-this-address" lookup is O(degree). For a wallet with 10K transfers, that's the difference between a 1-second response and a 30-millisecond response.

Cross-chain in one call

The biggest win isn't latency — it's that the same query covers 14 EVM chains plus Solana and Bitcoin. Today, doing the equivalent across providers means:

// Alchemy approach — one call per chain
const eth = await alchemy.eth.getAssetTransfers({...});
const polygon = await alchemy.polygon.getAssetTransfers({...});
const arbitrum = await alchemy.arbitrum.getAssetTransfers({...});
// ...8 more
const merged = mergeAndSortByTimestamp([eth, polygon, arbitrum, ...]);

vs.

// 1F — one call, all chains
const all = await fetch('https://1f.ai/api/cross-chain/transfers/' + address)
  .then(r => r.json());

Cost difference for a portfolio tracker covering 14 chains: 14× cheaper RPC bill, 14× less latency overhead, no client-side merge logic.

Pricing per million calls

Provider	Cost per 1M `getAssetTransfers`-equivalent calls
Alchemy Growth ($289/mo, 1.5B CU/mo, ~5K CU/call)	~$0.96
QuickNode Build ($299/mo, 50M credits/mo, ~5 credits/call)	~$30
1F Pro ($200/mo, 5M calls/mo)	$40 flat (above 5M, $0.04/call ≈ same)

For mid-volume use (up to ~5M/mo), 1F Pro is the cheapest. Above that, Alchemy Growth wins on raw price-per-call but loses on cross-chain ergonomics.

Filter expressivity

alchemy_getAssetTransfers supports fromAddress, toAddress, contractAddresses, category (external/internal/erc20/erc721/erc1155), and pagination via page key.

1F's /api/cross-chain/transfers supports the same plus:

Chain filter — ?chain=ethereum,polygon,arbitrum
Direction filter — ?direction=in|out|both
Decoded protocol — filter to swaps via Pancake, Uniswap V2/V3, Curve, etc.
Bridge-paired — return only transfers that originated from a bridge with the source-chain tx hash joined

Compatibility shim

If you're migrating from Alchemy and don't want to rewrite the client code:

// drop-in replacement — change the URL, keep the method
const provider = new AlchemyProvider({
  network: 'eth-mainnet',
  apiKey: process.env.ONEF_KEY,
  url: 'https://1f.ai/v2/' + process.env.ONEF_KEY + '/eth-mainnet'
});
// existing alchemy.eth.getAssetTransfers() calls now route through 1F

Try it

curl https://1f.ai/api/cross-chain/transfers/0xab5801a7d398351b8be11c439e05c5b3259aec9b \
  -H "X-API-Key: $KEY"

Returns transfers across all 14 chains in one response, sorted by timestamp.