FREE RPC

Your first request

Ethereum mainnet, no key, and no header beyond a content type. Paste this into a terminal:

curl -X POST https://ethereum-mainnet.gateway.tatum.io \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

The reply is an ordinary JSON-RPC 2.0 envelope, and result is the height of the head block in hex rather than decimal:

{"id":1,"jsonrpc":"2.0","result":"0x18be3e0"}

eth_blockNumber takes no parameters, which makes it the cheapest way to prove a URL works before you go looking for anything else. From a client, the URL is the only thing you configure:

import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

const client = createPublicClient({
  chain: mainnet,
  transport: http('https://ethereum-mainnet.gateway.tatum.io'),
});

console.log(await client.getBlockNumber());

One trap worth knowing before you lose an hour to it. ethers v6 batches JSON-RPC calls by default, and batch calls are a paid feature, so a plain new JsonRpcProvider(url) fails on the free tier with HTTP 402. Construct it as new JsonRpcProvider(url, undefined, { batchMaxCount: 1 }) and it behaves. The envelope itself is the same on every JSON-RPC network listed here; the method set is not, so each chain page lists the methods that chain's interface actually answers.

The interfaces you can call

There are 198 interfaces across 135 networks on 67 chains, and every one of them is a plain HTTPS or WebSocket URL that goes straight into a client. 127 of them speak JSON-RPC, which is what wallets and the common JavaScript libraries expect and what you will use for almost everything. 53 serve a REST-style HTTP API, which some chains publish instead of JSON-RPC and some publish alongside it. 12 are WebSocket URLs, so your code can be told about a new block instead of asking repeatedly whether there is one. 6 speak gRPC, which a handful of chains prefer for their own native tooling.

The mix differs by chain. A Bitcoin-family network has no use for the Ethereum method set, and a chain with no public streaming interface has no WebSocket URL to list. Each chain page shows what that chain actually has, network by network, with a copy button beside every URL. The grid above also keeps its filter in the address: /?q=ethereum#blockchains opens this page with the search box already filled in and the grid already narrowed. That is worth pasting into a chat or a docs page instead of telling somebody to scroll.

The rate limit, and what crossing it looks like

The free tier serves 5 requests per minute. That figure carries no qualifier: not by chain, not by network, and not by whether you are on mainnet or a test network. Cross it and the same call above comes back like this:

HTTP/2 429
retry-after: 60

{"statusCode": 429, "message": "You have exceeded your limit of 5 requests per minute. To increase this limit, upgrade to a Paid plan with 200 requests per second at https://co.tatum.io/upgrade"}

Two things about that response save time later. It is a plain HTTP error rather than a JSON-RPC error object, so the status code is where the information is: a client that only reads the error field of the envelope will not find one. And it carries a retry-after header, which is worth honouring, because an immediate retry usually just returns the same 429.

Five a minute is comfortable for the work the tier is meant for and nowhere near enough for anything else. It will carry a tutorial, a script on a timer, a balance read when a page loads, a test suite that mocks most of its calls. It will not carry a wallet with users, an indexer, a block-by-block backfill, or anything that polls in a loop. Caching buys back more room than people expect, because more is fixed than it looks: a token's decimals, a contract ABI, a chain ID, the address of a router you call every time.

One non-solution is worth naming. Splitting the same workload across several IP addresses to get past the ceiling is not a clever trick, it is taking capacity out of a pool that every other developer here is sharing. If you need more than the free tier gives, the honest move is to ask for more.

Free versus paid

The useful test is whether anybody other than you depends on the calls. If the answer is yes, the free tier is the wrong tool, not because it will necessarily let you down but because it makes no promise either way: it is best-effort infrastructure with nothing contractual behind it.

A paid Tatum plan changes four things. The ceiling goes from 5 requests a minute to 200 requests per second with no daily limits. Best-effort becomes a 99.9% uptime SLA, which is a number somebody is accountable for rather than a number somebody hopes for. It adds capabilities the free tier does not have at all, and it is worth knowing which before you design around them: archive nodes, for reading state as it stood at a block long in the past, batch RPC calls, and debug and trace methods. And it adds priority support, which counts most on the day you cannot work out whether the problem is yours or ours.

Nothing here is trying to push you across that line. If your project stays under 5 requests a minute forever, stay on the free tier forever, which is what free forever is supposed to mean. The Upgrade link is there for the day the numbers above stop being the ones you need.