Until now the only way to find out what running your code on the node actually feels like was to pay for the Beta plan or poke at the live demo panel. That was the wrong shape for a product whose whole pitch is a latency difference you have to measure yourself. So there is now a free plan: one always-on JavaScript script, running on a host with a fully synced Ethereum mainnet node, with 1,000,000 RPC credits a month. No card, no trial clock.
At the same time the paid plans got more generous. The Beta plan went from 1M to 5M monthly credits, and Beta XL went from 10M to 25M, both at the same price they were before.
What the free plan gets you
One script, active at a time, written and deployed from the browser-based editor (with VIM keybinds, if that is your thing). ethers.js and web3.js are already installed, so there is no build step and nothing to package. The script runs on the same host as a fully synced Ethereum mainnet node and reaches it over a local socket rather than the public internet, which is the entire point: the round-trip is sub-10ms instead of the 50 to 500ms a remote gateway costs you, and there is no shared gateway rate limit sitting between your code and the chain. The mempool view is the node’s own, not a downstream relay’s.
In practice, deploying looks like this. There is no endpoint to sign up for and no API key to paste, because the node is local:
const { ethers } = require('ethers');
// the co-located node, over a local socket on the same host
const provider = new ethers.WebSocketProvider('ws://eth:8545');
provider.on('block', async (blockNumber) => {
const block = await provider.getBlock(blockNumber);
console.log(blockNumber, block.transactions.length, 'txs');
});
That is a complete script. Paste it into the editor, hit run, and it is live.
What 1M credits actually buys
A million credits a month is roughly 32,000 calls a day, or a sustained 22 calls a minute, every minute, for a month. Ethereum produces about 7,200 blocks a day, so a block-driven loop can afford four or so calls per block and still stay inside the allowance. Most methods cost 1 credit; the heavy ones (txpool_content, trace_replayBlockTransactions, trace_replayTransaction) cost 4, and responses over 100KB add 50 credits per MB. WebSocket subscriptions draw from the same balance. The RPC pricing page has the full table, and the compute units vs credits breakdown explains why we count calls this way instead of weighting every method differently.
Concretely, that is enough for a price watcher polling a handful of pools every block, an ERC-20 transfer webhook on a busy contract, a mempool monitor that filters before it reads state, or an indexer backfilling at a steady pace. It is not enough for a tight arbitrage scanner rebuilding a token graph on every block, which is what the paid plans are for.
The paid plans got bigger, not pricier
The Beta plan at €75 now includes 5M credits instead of 1M, alongside its 1 container and 2 scripts. Beta XL at €249 now includes 25M instead of 10M, with 3 containers and 4 scripts and priority support. Nothing else about those plans changed and the prices are the same, so if you are already on one, your allowance simply went up.
The reason for the increase is that the old numbers were sized before we had much real usage data, and the workloads people actually run here are read-heavy by nature. When your code sits next to the node, the sensible design is to read state freely rather than cache defensively around a rate limit, and the credit allowance should not be the thing that talks you out of that.
Where the free tier stops
It is one script, not containers: Docker and OCI images start at the Beta plan. The nodes are tip-of-chain, so archive access remains an Enterprise feature. Ethereum mainnet is the only chain live today; everything on the networks pages beyond it is a waitlist, not a running product. And the free plan is available temporarily while we work out how much capacity we can give away, so it is worth claiming a slot rather than bookmarking the idea.
Getting started
Sign up at panel.blazed.sh, open the script editor, and paste something that talks to ws://eth:8545. If you want a starting point with more substance than a block counter, the mempool access guide and the ERC-20 transfer webhook walkthrough both run as-is on the free plan, and the API reference covers deploying scripts over REST once you outgrow the editor.
The thing worth doing in the first ten minutes is the measurement: log the time around a getBlock call here, then run the same script against whatever remote endpoint you use today and compare. That number is the product.