Ankr Alternative: Public Endpoints, API Credits, and the Flat-Rate Option

You have probably used Ankr without deciding to. https://rpc.ankr.com/eth is pasted into more MetaMask networks, tutorials, and quick scripts than almost any other endpoint, because it's free, needs no API key, and covers 80-plus chains. As a way to get a read call working in thirty seconds, it's genuinely excellent.

The trouble starts when a prototype becomes a product. The free public endpoint is deliberately limited, and the paid path replaces those limits with a metered API-credit model that brings back the exact budgeting problem developers move to flat-rate providers to escape. This post walks through both walls and where an alternative like SwiftNodes fits.

Wall one: the public endpoint is capped by design

Ankr's public endpoints are anonymous and free, which means they have to be defended against abuse. In practice that means three restrictions that are invisible in development and painful in production:

• A global, IP-level rate throttle. There's no per-key budget you can reason about — you share a throttle with everyone else hitting that public URL from your network. Under real traffic you get intermittent rate-limit errors you can't predict or raise.
• A restricted method set. The public tier doesn't serve archive queries, debug_*/trace methods, or wide eth_getLogs ranges. Those are exactly the calls that indexers, analytics, and anything reading historical state depend on.
• No private endpoint. You can't get a stable, isolated endpoint with its own limits without moving to a paid plan.

The first time this usually bites is indexing. You write a backfill that pages eth_getLogs, it works against a small range in dev, and then it fails in production because the public endpoint caps the range — the same class of problem covered in how eth_getLogs range caps bite you. The second time is when you need a historical eth_call or a debug_traceTransaction for accounting, and discover the public tier simply doesn't answer those (see full node vs archive node for why archive access is a separate capability, not a setting).

None of this is a knock on Ankr — free anonymous infrastructure has to be limited. It just means the public endpoint is a starting line, not a finish line.

Wall two: paid means API credits, priced per method

When you outgrow public, Ankr's paid path is pay-as-you-go API credits. The headline number is simple — roughly $0.10 per 1M credits (starting around $10 per 100M) — but the catch is that different methods cost different amounts of credits. An eth_call runs about 200 credits; heavier methods cost more. So your real cost per request depends entirely on your method mix.

Work an example. If your workload is mostly eth_call at ~200 credits each:

1,000,000 eth_call  ×  200 credits  =  200,000,000 credits
200,000,000 credits  ×  $0.10 / 1,000,000  =  $20

That looks cheap until you remember two things. First, real apps aren't one method — they mix getLogs, getBlockByNumber, traces, and receipts, each at a different credit weight, so you can't predict the bill without modeling the whole distribution. Second, that distribution changes the moment you ship a new feature or traffic spikes. This is the same metered-compute trap we've written about for Alchemy's compute units and QuickNode's credits: the pricing unit isn't a request, it's a synthetic cost that you have to translate back into requests every time you want to answer "what will this cost me next month?"

Ankr's Freemium tier softens the entry — a monthly allotment of free credits — but it still runs under the public rate limits, so it's a bigger evaluation bucket, not a production lane.

What flat-rate changes

The alternative model is to pay one number per month and stop counting. That's what SwiftNodes does, and the difference isn't philosophical — it removes concrete work:

• No method-weight modeling. A request is a request. An eth_call, an eth_getLogs, and a debug_traceTransaction all draw from the same flat plan, so you never build a spreadsheet to predict a bill. For trace-heavy or log-heavy workloads — the ones Ankr's credit weights punish hardest — this is the biggest saving.
• Archive and full methods on paid plans. The methods the public tier withholds — archive state, debug_*/trace, wide getLogs — are available, so you're not forced onto pay-as-you-go just to read history.
• One URL format across every chain. https://rpc.swiftnodes.io/rpc/eth?key=YOUR_API_KEY (and /ws/eth for WebSocket). The slug is the only thing that changes between chains — see the Ethereum RPC page for a live example.

Here's the shape of the trade-off:

For the broader "free public RPC vs a paid endpoint" decision — latency, reliability, and where the line actually is — public RPC vs paid RPC goes deeper, and if you're weighing running your own node instead, self-hosted node vs RPC provider has the cost math.

When Ankr is the right call

Flat-rate isn't automatically the answer, and it's worth being honest about where Ankr wins:

• Prototyping and low-volume read apps. If you never leave read-only, low-traffic territory, the public endpoints are free and cover more chains anonymously than anyone. That's hard to beat for a hackathon or a hobby project.
• You want anonymous, no-signup access. No key, no account — paste and go.
• You're already in the Ankr ecosystem — its staking, RaaS (rollup-as-a-service), or enterprise node products. Keeping RPC in the same account has real convenience value.
• Your method mix is genuinely cheap and stable. If you're overwhelmingly light eth_call traffic and you've actually modeled it, pay-as-you-go credits can come out inexpensive.

The point isn't that credits are bad — it's that credits are work. If you'd rather not re-model your bill every time your traffic changes, flat-rate is the trade you want.

Migration is a URL swap

Because both speak standard JSON-RPC, moving is mechanical. Point your client at the new endpoint and nothing else changes:

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.swiftnodes.io/rpc/eth?key=YOUR_API_KEY"),
});

Same eth_* methods, same responses — you're just trading a shared public throttle (or a per-method credit meter) for a single predictable monthly number, with archive and trace access included on paid plans.

If Ankr's public endpoints have gotten you this far and you're starting to hit the walls above, that's the signal you've outgrown the starting line. SwiftNodes has a free tier to test with — sign up, point your client at /rpc/<chain>?key=YOUR_API_KEY, and see whether flat-rate fits your workload better than counting credits.