RPC endpoints connect wallets, trading bots and dashboards to blockchain state, event subscriptions and transaction broadcasting. Providers differ in chain coverage, usage metering, streaming support and whether their free access is permanent or limited to a trial. This comparison is based on each provider's official documentation and published features, checked in November 2026; we have not tested the tools hands-on.
Which one to pick
- Trading on Solana: Helius, with Solana-specific RPC and standard LaserStream WebSocket access.
- Running an EVM trading bot: Chainstack, with a managed endpoint and WebSocket subscriptions on its Developer plan.
- Monitoring BNB Chain or Ethereum: MegaNode, with a free monthly compute allowance and method-based metering.
- Reading data across multiple chains: Ankr, with a substantial monthly credit allowance and broad network coverage.
- Needing an endpoint without registration: Pocket Network, with publicly accessible endpoints for numerous networks.
- Evaluating managed infrastructure temporarily: QuickNode, with a one-month trial and private endpoint provisioning.
Compare RPC endpoints for on-chain trading
| Tool | Type / use case | Trader-relevant access | Price |
|---|---|---|---|
| QuickNode | Managed multichain RPC | 10M credits; 15 RPS; HTTP and WSS | Free for one month |
| Chainstack | Managed blockchain nodes | 3M request units/month; 25 RPS; WSS | Free Developer |
| Ankr | Multichain RPC API | 200M credits/month; 45+ chains; HTTPS | Free (Freemium) |
| Helius | Solana RPC and streaming | 1M credits/month; 10 RPS; LaserStream WSS | Free |
| MegaNode | Ethereum and BNB Chain RPC | 10M CU/month; 150 CUPS/API key; 3 API keys | Free |
| GetBlock | Shared multichain RPC | 50K CUs/day shared across endpoints; 20 RPS; 2 endpoints | Free |
| dRPC | Public multichain nodes | 50M CU/30 days; 25 RPS; no free WSS | Free |
| Pocket Network | Keyless public RPC | Dozens of networks; no account or API key | Free |
| Alchemy | Multichain developer RPC | 30M CU/month; 25 RPS; mainnets and testnets | Free |
| Infura | Multichain RPC infrastructure | 3M credits/day; 500 credits/second; 40+ networks | Free Core |
The tools
QuickNode
Managed RPC for temporary deployments
QuickNode provisions a managed endpoint for a selected network, but its no-cost access is a trial rather than a continuing allowance. The current offer supplies 10 million metered credits and a 15-request-per-second ceiling for one month; the price of a call depends on the RPC method. Its Ethereum RPC reference documents HTTP and WebSocket access. The trial's eth_getLogs range is restricted to five blocks, so it is a poor fit for broad backfills.
Choose it when you need a temporary environment to evaluate a managed endpoint and its subscription workflow.
Watch out for the trial expiry and restricted historical log queries. Budget for a paid replacement before making it part of a live trading setup.
Chainstack
Managed endpoints with WebSocket access
Chainstack's Developer tier gives one managed node, 3 million request units per month, a 25-RPS cap and WebSocket connectivity. Archive data sits in the paid Growth tier, so historical state and large log scans need separate planning. Its chain catalogue is broad, but confirm that the chosen network appears in the account's deployment options. The official pricing page lists the Developer allowance without requiring a credit card.
Choose it when your EVM monitor needs a managed endpoint and continuous event subscriptions.
Watch out for the single-node cap and archive access being reserved for Growth.
Ankr
Multichain RPC with monthly credits
Ankr's Freemium Node API offers a 200-million-credit monthly pool across 45-plus chains. You need an account, and the free tier still inherits the public request ceiling of approximately 1,800 calls per minute across endpoints. The connection is HTTPS; WebSocket access, Trace and Debug methods sit outside the no-cost plan. API credits are charged by method, so repeated log scans or other heavier calls consume the allowance differently from simple state reads. Its service-plan documentation separates free access from premium capabilities.
Choose it when you need multichain HTTPS reads and can operate within shared throughput limits.
Watch out for the absence of free WebSockets, Trace and Debug functionality.
Helius
Solana RPC and transaction monitoring
Helius focuses on Solana rather than trying to cover every chain. The free account includes standard LaserStream WebSocket access, a monthly credit balance and explicit caps on both ordinary RPC traffic and transaction submission. Its documentation explains getLatestBlockhash, preflight simulation and rebroadcast behaviour, useful details when a bot builds and sends transactions. The free sending ceiling makes it more suitable for a small bot, wallet monitor or prototype than a high-volume execution service. Its pricing page specifies the free allowance and method-related limits. For Solana-specific context, see the Solana RPC provider guide.
Choose it when your workflow is Solana-first and requires a native event-streaming option.
Watch out for the one-per-second free sendTransaction ceiling and credit consumption from account-intensive queries.
MegaNode
BNB Chain and Ethereum infrastructure
MegaNode is NodeReal's managed RPC product, with free access for developers working on BNB Chain or Ethereum. Monthly CU is shared across the account, while the 150-CUPS limit applies separately to each API key; each RPC method has its own CU weight. The published free plan also limits the number of API keys. The official pricing page publishes its free-tier limits.
Choose it when BNB Chain or Ethereum reads fit your monthly compute budget.
Watch out for method-weighted consumption and the independent per-second throughput restriction.
GetBlock
Shared RPC across supported networks
GetBlock's Free plan exposes shared RPC endpoints on a limited set of mainnets and testnets, with one daily compute budget shared across endpoints. Once that budget is exhausted, the service rate-limits further calls until the next daily reset. This makes it useful for light reads, integration checks and a secondary endpoint, but not a dependable primary path for a bot that needs sustained bursts. Archive access and MEV-protected endpoints are listed among paid features. Its official FAQ explains the daily allowance and the difference between shared and dedicated infrastructure.
Choose it when you need a spare RPC connection for low-volume reads across different chains.
Watch out for shared-node capacity and daily resets. Historical archive access and protected transaction endpoints require paid access.
dRPC
Public nodes for multichain reads
dRPC routes free traffic through public nodes and meters it in compute units. The published plan sets a per-30-day allowance and a 25-RPS normal ceiling; archive access and Debug and Trace methods are excluded. Free requests also face a short timeout, a cap on returned log entries and a three-item batch ceiling; filters are disabled by default. This can work for straightforward EVM reads, but not a stream-first trading system. Its plan documentation details the restrictions.
Choose it when public multichain access matters more than streaming or historical archive queries.
Watch out for the short timeout, batch and log restrictions, and the absence of WebSockets on the free tier.
Pocket Network
Keyless public blockchain access
Pocket Network's public RPC portal does not ask for an account or API key. Its documentation lists endpoints for Ethereum, Base, Arbitrum, BNB, Hyperliquid and Solana, among other networks, and explains that requests are routed through independent suppliers. That makes it convenient for quick reads or a spare endpoint when you do not want to provision credentials. The public endpoint catalogue also covers Sui, NEAR and several Cosmos networks. It remains a shared public service, so build your own freshness and availability checks.
Choose it when you need an immediately accessible endpoint for basic reads or a backup data connection.
Watch out for the public-service model. Do not make a keyless endpoint your only route for order-critical traffic.
Alchemy
Multichain RPC with a developer dashboard
Alchemy's Free plan is a multi-chain developer account rather than a single shared public URL. It covers mainnets and testnets in its supported catalogue and provides a dashboard with separate apps and webhooks. Its usage pool is measured in compute units, while throughput is capped independently, so a busy stream of expensive methods can hit a different limit from a simple polling loop. The plan's published request ceiling should be tested before using it for order-critical traffic. The pricing page documents its monthly allocation and application limits.
Choose it when you need a multi-network development environment with usage visibility and webhook support.
Watch out for the 25-RPS ceiling and method-dependent compute consumption.
Infura
Multichain RPC with archive access
Infura's Core tier offers authenticated RPC access to more than 40 networks and includes full archive data. Its allowance resets daily and uses weighted credits, with a separate guaranteed throughput ceiling and a single API key. That makes it useful for historical queries and ordinary EVM reads where you can plan around a daily budget. The paid Developer plan adds Debug and Trace API access, so do not assume those methods are available on Core. Its official pricing page identifies the daily quota and supported network coverage.
Choose it when you need archive queries and standard RPC access across its supported network catalogue.
Watch out for daily credit exhaustion and the restricted debugging capabilities of the free tier.
How to set up and validate a free RPC for on-chain trading
- List your required chains and methods. For EVM trading, identify whether you need eth_chainId, eth_blockNumber, eth_getLogs, eth_call, eth_estimateGas, eth_sendRawTransaction and eth_subscribe. For Solana, account for getSlot, getLatestBlockhash, simulateTransaction, sendTransaction and logsSubscribe.
- Match the provider to the workflow. Select Helius for Solana streaming, Chainstack for an EVM WebSocket endpoint, or a multichain provider for ordinary state queries. Check that the exact network and methods are available under the free plan.
- Create your endpoint and secure its credentials. Generate an API key where registration is required. Store the endpoint URL and credentials in server-side configuration rather than exposing them in a browser bundle. Pocket Network can supply a public endpoint without this registration process.
- Compare two providers using identical requests. Send the same block-height, account-state and log queries from the same machine. Record response times, returned block numbers or slots, chain IDs, HTTP errors and JSON-RPC errors across repeated samples.
- Test the exact data workload. On EVM networks, try your contract calls and small eth_getLogs ranges at the block tags your strategy needs. On Solana, test account queries and transaction simulation. Verify historical-data access and method restrictions before depending on them.
- Validate the WebSocket connection. Subscribe to newHeads and logs on EVM or the relevant Solana slot and log notifications. Disconnect deliberately, reconnect and backfill from the last processed block or slot.
- Exercise transaction submission and failover. Start with a testnet transaction, estimate or simulate it, submit it through your normal signing process, and check its receipt or signature status through another endpoint. Configure usage alerts, rate-limit handling and a tested backup before relying on the connection for live orders. For infrastructure beyond free allowances, see the blockchain node provider comparison.
Worked example (illustrative): A Base trading bot monitors three liquidity pools and subscribes to four contract-log filters. Its primary RPC begins returning 429 errors during a 20-RPS burst and remains two blocks behind its backup across three consecutive checks. The bot reduces polling, switches the event feed, backfills from its last processed block and pauses new submissions until both sources agree.
Risks of relying on free RPC infrastructure
Keep provider credentials in server-side secrets, not browser bundles, and never share a wallet seed phrase or signing key with an RPC service. Public infrastructure can become stale, throttled or unavailable, so validate chain IDs, block hashes and slots against a separate provider and fail closed when the sources disagree.
Frequently asked questions
Can I use a free RPC for live crypto trading?
Yes, free access can support low-volume monitoring, reads and development. For order submission, test the actual workload and throughput limits first, and maintain a separate connection for recovery.
Which free RPC endpoints support WebSockets?
Chainstack Developer and Helius Free explicitly include WebSocket access. QuickNode also documents Ethereum WebSocket subscriptions, but its no-cost offer is a temporary trial rather than a permanent free plan.
Are API credits the same as RPC requests?
No. Compute units and API credits can carry different costs for different methods, while per-second throughput is a separate restriction. A large allowance does not necessarily translate into the same number of usable calls across providers.
Can I broadcast transactions through a public RPC?
That depends on whether the endpoint exposes the required transaction-submission method. Public access does not imply private routing, delivery priority or confirmation, so check the transaction independently after submission.
Does a free RPC endpoint protect trades from MEV?
Not automatically. Ordinary RPC connectivity is different from private transaction routing, and GetBlock specifically lists MEV-protected endpoints among paid features. Check the provider's explicit transaction-routing options before assuming an order is protected.
Why can a Solana transaction fail after the RPC accepts it?
A recent blockhash can expire or belong to a fork that is not retained by the cluster. Use a suitably recent blockhash, keep preflight commitment consistent and independently check the transaction signature rather than treating initial acceptance as final confirmation.
Sources
Show all 18 sources
- QuickNode pricing and trial allowance
- QuickNode trial terms
- QuickNode eth_getLogs documentation
- QuickNode WebSocket subscriptions
- Chainstack pricing and Developer plan
- Ankr service plans and rate limits
- Helius RPC pricing
- Helius Solana transaction submission guide
- NodeReal MegaNode pricing
- MegaNode compute-unit allowances
- GetBlock free-plan FAQ
- dRPC plans and compute-unit pricing
- dRPC free-node rate limits
- Pocket Network public RPC
- Pocket Network supported chains
- Alchemy free-tier pricing
- Infura Core pricing
- Infura credit pricing documentation