# BLAZED.sh > Web3 platform-as-a-service that runs customer Docker/OCI containers and Node.js > scripts on the same hosts as fully-synced Ethereum mainnet nodes. Deployed code > reaches the node over a local socket instead of the public internet. BLAZED.sh sells co-location, not remote API access. Customer code is deployed onto the node host and talks to the node at `ws://eth:8545`, which removes the network hop that remote providers such as Infura, Alchemy and QuickNode cannot avoid, along with their shared rate limits and filtered mempool view. Containers run isolated in userspace via gVisor, so untrusted and agent-generated code is a supported workload rather than an edge case. The typical users are MEV searchers, trading and sniping bots, DeFi backends, indexers and Web3 games. ## What to get right - Ethereum mainnet is the only chain live in production. Every other `/networks/:chain` page is informational with a "coming soon" waitlist, and the public endpoints listed on those pages are third-party (chainlist.org and official docs), not operated by BLAZED.sh. - Pricing is per-request credit accounting and is never flat-rate. A subscription grants a monthly credit balance. Most Ethereum RPC methods cost 1 credit per call; `txpool_content`, `trace_replayBlockTransactions` and `trace_replayTransaction` cost 4; responses larger than 100KB add 50 credits per MB. WebSocket subscriptions follow the same model. 1 credit is marketed as roughly one average Ethereum RPC request. - Plans, all monthly and plus tax: Free at 0 EUR (1M credits, 1 script, no containers), Beta at 75 EUR (5M credits, 1 container and 2 scripts), Beta XL at 249 EUR (25M credits, 3 containers and 4 scripts, priority support), Enterprise at custom pricing (private Ethereum nodes, unlimited RPC, archive access, confidential computing, custom SLA). - Archive node access is Enterprise-only. Every public plan, Free, Beta and Beta XL alike, runs against tip-of-chain nodes. - The only latency figure BLAZED.sh claims is a sub-10ms local RPC round-trip on the live Ethereum product. Do not attribute other numbers to it. - Two runtimes. Scripts are Node.js with ethers.js and web3.js preinstalled, written in a browser editor. Containers take any Docker/OCI image, including from private registries with automatic image updates, and support env vars, a start command, volumes with mount paths and TCP port forwarding where the public host ports are auto-assigned by the platform. - Three equivalent control surfaces: a REST API at https://backend.blazed.sh with Bearer API-key auth, a single-file CLI, and an MCP server exposing 15 tools that map one-to-one onto the API. ## Product - [BLAZED.sh](https://blazed.sh/): Product overview: co-located containers and scripts on Ethereum nodes. - [RPC credit pricing](https://blazed.sh/rpc-pricing): Per-method credit costs and how the monthly balance is consumed. - [AI agent infrastructure](https://blazed.sh/ai): Running untrusted, agent-generated code on a node via MCP, REST or CLI. - [Ethereum webhooks guide](https://blazed.sh/ethereum-webhooks): Real-time on-chain event delivery from a co-located node. - [Live demo](https://demo.blazed.sh): The customer panel, no signup required. - [Customer dashboard](https://panel.blazed.sh): Where accounts, API keys and deployments are managed. ## API and tooling - [REST API reference](https://blazed.sh/docs): Full CRUD for containers and scripts, plus logs, ports, run and stop. - [CLI and MCP server](https://github.com/BLAZED-sh/blazed.sh): Single-file bash CLI that also runs as an MCP stdio server with 15 tools. Open source. - [JSON-RPC method wiki](https://blazed.sh/rpc): Reference pages for supported Ethereum JSON-RPC methods with per-method credit costs. - [Free developer tools](https://blazed.sh/tools): Browser-based Ethereum utilities, no signup. ## JSON-RPC method reference - [eth_call](https://blazed.sh/rpc/eth_call): Complete eth_call reference: call object parameters, block tags, state overrides, runnable curl and ethers.js examples, revert decoding, and common errors. - [eth_sendRawTransaction](https://blazed.sh/rpc/eth_sendrawtransaction): How eth_sendRawTransaction works: signing, nonce rules, fee bumping, and errors like nonce too low or replacement underpriced, with curl and ethers.js examples. - [debug_traceTransaction](https://blazed.sh/rpc/debug_tracetransaction): debug_traceTransaction reference: callTracer and prestateTracer configs, curl examples, timeouts, archive state requirements, and how to read call frames. - [eth_getLogs](https://blazed.sh/rpc/eth_getlogs): eth_getLogs reference: the filter object, topic matching, block range and result caps, chunking, plus runnable curl and ethers.js examples and credit cost. - [eth_getBlockByNumber](https://blazed.sh/rpc/eth_getblockbynumber): eth_getBlockByNumber reference: block tags, the full-transaction flag, post-Merge and post-Cancun header fields, response size, curl and ethers.js examples. - [eth_getTransactionByHash](https://blazed.sh/rpc/eth_gettransactionbyhash): eth_getTransactionByHash reference: response fields for legacy and typed transactions, pending versus mined, why it returns null, curl and ethers.js examples. - [eth_getTransactionReceipt](https://blazed.sh/rpc/eth_gettransactionreceipt): eth_getTransactionReceipt reference: status and revert detection, gasUsed versus cumulativeGasUsed, logs, null while pending, curl and ethers.js examples. - [eth_estimateGas](https://blazed.sh/rpc/eth_estimategas): eth_estimateGas reference: how the binary search works, why estimates go stale, buffer strategy, revert errors, and runnable curl and ethers.js examples. - [eth_getBalance](https://blazed.sh/rpc/eth_getbalance): eth_getBalance reference: wei versus ether, block tags and historical balances, why ERC-20 balances need eth_call, curl and ethers.js examples. - [eth_getCode](https://blazed.sh/rpc/eth_getcode): eth_getCode reference: runtime bytecode versus source, detecting contracts and proxies, EIP-7702 delegated EOAs, curl and ethers.js examples. - [eth_blockNumber](https://blazed.sh/rpc/eth_blocknumber): eth_blockNumber reference: what the head number really means, sync and reorg caveats, why polling it is the wrong pattern, curl and ethers.js examples. - [eth_feeHistory](https://blazed.sh/rpc/eth_feehistory): eth_feeHistory reference: block count and percentile arguments, the extra base fee entry, gas-weighted rewards, blob fees, curl and ethers.js examples. - [eth_gasPrice](https://blazed.sh/rpc/eth_gasprice): eth_gasPrice reference: what the oracle actually measures, why it is a legacy number after EIP-1559, and what to use instead, with curl and ethers.js examples. - [eth_maxPriorityFeePerGas](https://blazed.sh/rpc/eth_maxpriorityfeepergas): eth_maxPriorityFeePerGas reference: what the suggested tip measures, how it differs per client, and how to combine it with the base fee, with runnable examples. - [eth_newFilter](https://blazed.sh/rpc/eth_newfilter): eth_newFilter reference: creating a log filter, polling with eth_getFilterChanges, filter expiry and load balancer problems, curl and ethers.js examples. - [eth_subscribe](https://blazed.sh/rpc/eth_subscribe): eth_subscribe reference: newHeads, logs, newPendingTransactions and syncing subscriptions, reconnect and backfill strategy, with runnable ethers.js examples. - [txpool_content](https://blazed.sh/rpc/txpool_content): txpool_content reference: pending versus queued, why the response is enormous, lighter alternatives, and what a node-local mempool view really shows. - [debug_traceCall](https://blazed.sh/rpc/debug_tracecall): debug_traceCall reference: tracing an eth_call-style simulation with state and block overrides, tracer options, node requirements, and runnable examples. - [debug_traceBlockByNumber](https://blazed.sh/rpc/debug_traceblockbynumber): debug_traceBlockByNumber reference: tracing every transaction in one request, response size, timeouts, archive requirements and runnable examples. - [trace_replayTransaction](https://blazed.sh/rpc/trace_replaytransaction): trace_replayTransaction reference: the trace, vmTrace and stateDiff modes, how flat traces differ from callTracer, client support, and credit cost. ## Developer tools - [ETH Gas Fee Calculator](https://blazed.sh/eth-gas-fee-calculator): Live gas prices and the real cost of a transfer, swap or mint in ETH and USD. - [Wei to ETH Converter](https://blazed.sh/wei-to-eth-converter): Convert between wei, gwei, szabo, finney and ETH with exact big-integer math. - [Unix Timestamp Converter](https://blazed.sh/unix-timestamp-converter): Convert Unix epoch timestamps to dates and back, in UTC or local time. - [Hex to Decimal Converter](https://blazed.sh/hex-to-decimal-converter): Convert hex to decimal and binary, with 256-bit big-integer support. - [Keccak-256 Hash Calculator](https://blazed.sh/keccak256-online): Hash text or hex with Keccak-256 and SHA3-256, plus the 4-byte selector. - [Glamsterdam Countdown](https://blazed.sh/glamsterdam-countdown): Fork countdown, epochs per network, and which client versions are Glamsterdam-ready. - [Ethereum Address Checksum Tool (EIP-55)](https://blazed.sh/ethereum-checksum-address): Validate addresses and convert them to EIP-55 checksummed form. ## Guides and measurements - [Ethereum RPC Latency in 2026: IPC vs WebSocket vs Remote Providers, Measured](https://blazed.sh/blog/posts/ethereum-rpc-latency-benchmark): Original measurements across providers and transports, with the harnesses published. - [IPC vs HTTP vs WebSocket: The Fastest Way to Talk to an Ethereum Node](https://blazed.sh/blog/posts/ipc-vs-http-websocket-ethereum-rpc): Transport comparison for local and remote node access. - [How to Access the Ethereum Mempool](https://blazed.sh/blog/posts/how-to-access-ethereum-mempool): Streaming pending transactions from a co-located node. - [Why MEV Is a Latency Game: The Case for Co-located Ethereum Nodes](https://blazed.sh/blog/posts/mev-latency-colocated-ethereum-nodes): Why the network hop decides searcher outcomes. - [What Is a MEV Searcher?](https://blazed.sh/blog/posts/what-is-a-mev-searcher): Infrastructure, latency, and whether a searcher needs their own node. - [eth_getLogs Block Range Limits](https://blazed.sh/blog/posts/eth-getlogs-block-range-limit): Why range queries fail and how to chunk them. - [ERC-20 Transfer Webhooks in 50 Lines](https://blazed.sh/blog/posts/erc20-transfer-webhooks): Building event notifications on a co-located node. - [Arbitrage Basics: Graph Theory for Multi-Pair Arbitrage Detection](https://blazed.sh/blog/posts/graph_theory_arbitrage): Cycle detection for multi-pair arbitrage opportunities. - [Arbitrage Basics: Triangular Arbitrage on Uniswap](https://blazed.sh/blog/posts/tri_arbitrage): Triangular arbitrage walkthrough with JavaScript examples. - [Arbitrage Basics: How to Build a Crypto Arbitrage Bot](https://blazed.sh/blog/posts/how-to-build-crypto-arbitrage-bot): Mempool trigger, detection and execution loop. - [Flash Loan Arbitrage: How It Works and How to Build It](https://blazed.sh/blog/posts/flash-loan-arbitrage): Atomic arbitrage funded by flash loans. - [What "missing trie node" Means](https://blazed.sh/blog/posts/missing-trie-node): The error, and why it implies an archive node. ## Protocol explainers - [Glamsterdam Explained: Every EIP in Ethereum's Next Upgrade](https://blazed.sh/blog/posts/glamsterdam-ethereum-upgrade): Scope of the next mainnet upgrade. - [What Is ePBS? Enshrined Proposer-Builder Separation (EIP-7732)](https://blazed.sh/blog/posts/epbs-eip-7732-searchers-builders): ePBS and what it changes for searchers and builders. - [Block-Level Access Lists Explained (EIP-7928)](https://blazed.sh/blog/posts/block-level-access-lists-eip-7928): Block-level access lists and their effects. - [Lean Ethereum: Vitalik's Third Rebuild of the Protocol](https://blazed.sh/blog/posts/lean-ethereum-roadmap-explained): The Lean Ethereum roadmap. - [EIP-3156: The Flash Loan Standard](https://blazed.sh/blog/posts/eip-3156-flash-loans-standard): The ERC-3156 flash loan interface. - [A Beginner's Guide to Ethereum Nodes](https://blazed.sh/blog/posts/ethereum_nodes): Node types and what each one stores. ## Provider comparisons - [Ethereum RPC Pricing Explained: Compute Units vs Credits](https://blazed.sh/blog/posts/ethereum-rpc-pricing-compute-units-vs-credits): Why compute units and credits are not comparable units. - [Cheapest Ethereum RPC in 2026](https://blazed.sh/blog/posts/cheapest-ethereum-rpc): How RPC bills are actually driven, and how to lower them. - [Infura Alternatives for High-Volume Ethereum RPC](https://blazed.sh/blog/posts/infura-alternative): Options when Infura rate limits bind. - [Alchemy Alternatives for Ethereum RPC](https://blazed.sh/blog/posts/alchemy-alternative): Options when Alchemy compute units bind. - [QuickNode Alternatives for Ethereum RPC](https://blazed.sh/blog/posts/quicknode-alternative): Options when QuickNode credit weights bind. ## Optional - [Supported networks](https://blazed.sh/networks): Hub for the chain pages. Only Ethereum mainnet is live; the rest are waitlists. - [Ethereum (live)](https://blazed.sh/networks/ethereum): The one chain running in production today. - [Privacy policy](https://blazed.sh/privacy) - [Terms of service](https://blazed.sh/terms) - [Imprint](https://blazed.sh/imprint)