SwiftNodesSwiftNodes

Multi-chain RPC
infrastructure.

One API key for 139 chains. Create a free key in 30 seconds, then scale on flat monthly pricing with no compute units or surprise bills.

Never an overage fee. Your bill is your plan price, every month. No compute units, no per-request charges: on paid plans, a traffic spike can use your burst headroom; past that it hits your rate limit, never your card.

View pricing
139
chains
250K
free requests/month
20
HTTP req/s
No card required · no KYC · HTTP and WebSocket on every chain
rpc.swiftnodes.io — eth_blockNumber
$ curl -X POST https://rpc.swiftnodes.io/rpc/eth?key=demo \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
{
"jsonrpc": "2.0", "id": 1,
"result": "0x…"
}
Press Run it to send this request for real. No sign-up needed.
Follow @swiftnodesio for new chain launches, RPC tips, and live status updates.
Follow on X
139
Mainnets, plus testnets
1B+
Requests served
99.70%
Uptime, 30 days
139 / 139
Chains online, latest check

Uptime is the 30-day share of health checks that found a chain serving. Chains online is the latest check, refreshed every 2 minutes. Live per-chain status →

Features

Production RPC for 139 chains, one key.

Reliability, streaming, and transaction protection, without running another infrastructure project.

2×
Paid plans

Bursts absorb the spike.

Run up to twice your plan's rate for about 10 seconds instead of getting an instant 429. The credit refills over five minutes.

2× ceilingplan rate~10srefills over 5 min
How burst credit works →
WS
Subscriptions

Stream heads and logs.

Persistent wss:// connections for newHeads, logs, and pending transactions. No polling loop required.

wss:// · eth_subscribe
const ws = new WebSocket(
  "wss://rpc.swiftnodes.io/ws/eth?key=YOUR_KEY"
);

ws.onopen = () => ws.send(JSON.stringify({
  jsonrpc: "2.0", id: 1,
  method: "eth_subscribe",
  params: ["newHeads"]
}));
WebSocket guide →
LB

Multi-upstream failover

Health-checked pools route around a lagging upstream automatically. The status you see is the same check routing uses.

Live status →
139

One key, every chain

EVM and non-EVM networks behind the same path, auth, and bill. Testnets included.

Browse chains →
MEV

MEV-protected sends

Add protect=1 and Ethereum transactions go to a private relay instead of the public mempool.

Protect a send →
sn_

Enhanced APIs

Token balances, portfolios, and decoded logs in one call instead of dozens of eth_call round trips.

Enhanced APIs →
✓

Measured, not assumed

Weekly probes publish method support, eth_getLogs range, and archive depth per chain, with the probe date.

Method matrix →
>

Instant setup

Create a key with Google, GitHub, email, or a wallet. No KYC; no card for the free tier.

First request →
Supported chains

One key, every chain that matters

Start with the networks teams use most, or search the full directory.

Browse all 139 chains →
Showing 12 of 139 chains. Browse all 139 chains →
Global regions

Closer to your users. One key.

Choose your region →

Run the same RPC API from four regions. Paid plans can pin a key to the region closest to the app or users; the EU endpoint is included on every plan. Measure from where your app actually runs before choosing.

EUFrankfurtUS WestSeattleUS EastVirginiaJapanTokyo
Active regionDefault: EU · paid plans can pin to any region
For AI agents

Give Claude, Cursor or your own agent an RPC key

Our hosted MCP server lets an agent list chains and endpoints, check which methods a chain supports, probe an endpoint and make RPC calls, with your key and your plan's limits. Agent traffic is bursty and hard to predict; flat-rate pricing means a busy agent can never run up a bill.

  • ✓Remote server at rpc.swiftnodes.io/mcp, or local with npx -y swiftnodes-mcp
  • ✓Listed in the official MCP Registry as io.swiftnodes/swiftnodes
  • ✓Works with Claude Code, Cursor, Codex and other MCP clients
# Claude Code
claude mcp add --transport http --scope user   swiftnodes https://rpc.swiftnodes.io/mcp   --header "Authorization: Bearer YOUR_API_KEY"

# Cursor: ~/.cursor/mcp.json
{
  "mcpServers": {
    "swiftnodes": {
      "url": "https://rpc.swiftnodes.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
Quick start

Drop-in replacement for any RPC URL

Same JSON-RPC interface your client already speaks. Swap the URL, add your key, done. Works with every library and every supported chain. No key yet? Use demo in place of YOUR_KEY to try it.

✓HTTP & WebSocket — wss:// subscriptions on most chains
✓One key, all chains — just change the path segment
✓Archive access — included on every paid plan
curl -X POST https://rpc.swiftnodes.io/rpc/eth?key=YOUR_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
Testing? Swap eth for eth-sepolia or eth-hoodi. Same key, same plan. All testnets
Pricing

Simple, flat-rate pricing

One flat number per month. No per-request fees, no overage bills, and no monthly request cap on paid plans. Your plan's request rate still applies.

Monthly, 6 months (−5%), or 12 months (−10%). Card or crypto; cancel anytime.

Free
20 req/s · $0
250K requests/month · no card
✓All chains
✓1 WebSocket connection
✓1 WS msg/s · newHeads only
✓Community support
Starter
Side projects & hobby builds
$49/mo
70 req/s
no monthly cap · rate-limited
✓All chains
✓HTTP & WebSocket
✓No monthly request cap
✓25 WS msg/s
✓20 WS connections
✓Archive on supported chains
✓Bursts to 2× for ~10 s, refills in 5 min
+Enhanced APIs
Most popular
Growth
Indie SaaS & production apps
$89/mo
150 req/s
no monthly cap · rate-limited
✓All chains
✓HTTP & WebSocket
✓No monthly request cap
✓75 WS msg/s
✓50 WS connections
✓Archive on supported chains
✓Bursts to 2× for ~10 s, refills in 5 min
+Enhanced APIs
Scale
Heavy traffic & busy backends
$149/mo
300 req/s
no monthly cap · rate-limited
✓All chains
✓HTTP & WebSocket
✓No monthly request cap
✓150 WS msg/s
✓100 WS connections
✓Archive on supported chains
✓Bursts to 2× for ~10 s, refills in 5 min
+Enhanced APIs
Pro
Enterprise & high-RPS workloads
$249/mo
600 req/s
no monthly cap · rate-limited
✓All chains
✓HTTP & WebSocket
✓No monthly request cap
✓250 WS msg/s
✓200 WS connections
✓Archive on supported chains
✓Bursts to 2× for ~10 s, refills in 5 min
+Enhanced APIs
Custom
600+ req/s
Limits and price set to your traffic
✓Everything in Pro
✓HTTP rate set per account
✓WebSocket limits set per account
✓No monthly request cap
✓Archive on supported chains
Contact us

Plan limits at a glance

Choose by request rate; paid plans have no monthly request cap.

Full limits and 429 behavior →
Public demo key
2 req/s · shared
For trying the request box above. This is not the Free plan.
Registered Free key
20 req/s · 250K requests/month
1 WebSocket connection, 1 msg/s, newHeads only.
PlanPriceHTTP req/sRequests/monthWS connectionsWS msg/sBurstArchive
Free$020250K11None—
Starter$49/mo70No cap20252× / ~10sSupported chains
Growth$89/mo150No cap50752× / ~10sSupported chains
Scale$149/mo300No cap1001502× / ~10sSupported chains
Pro$249/mo600No cap2002502× / ~10sSupported chains
CustomContact us600+No capSet per accountSet per accountSet per accountSupported chains

Paid plans absorb short bursts; over-limit requests return 429 and are never queued or billed.

What 100 million Ethereum requests a month cost
SwiftNodes
$49–$89
dRPC
~$600
QuickNode
$999
Alchemy
~$1,418

eth_call-class reads at each provider's published pricing, checked October 3, 2026. Heavier methods cost more on metered plans and the same on ours. Full comparison →

Switching? Compare the QuickNode alternative, Chainstack alternative, GetBlock alternative and dRPC alternative.

How it works

From signup to first call in 30 seconds

1
Sign in
Continue with Google or GitHub, use your email (we send a one-time code) or connect a wallet. We never store passwords. No KYC.
2
Get API key
Receive an API key instantly. Use the same key across every supported chain.
3
Start building
Drop-in replacement for any RPC endpoint. HTTP on every chain, WebSocket on most.
Missing a chain?

Need a chain we don't support yet?

Tell us what you're building on and we'll add it — most requests ship within a week.

Need help with an existing endpoint, account, or billing? Contact support →

FAQ
Which blockchains does SwiftNodes support?

SwiftNodes provides RPC endpoints for 139 chains including Ethereum, Solana, Base, BNB Smart Chain, Arbitrum, Optimism, Polygon, Avalanche, Linea, Scroll, zkSync, Cosmos, Polkadot, TRON, Sui, Aptos, and many more EVM and non-EVM networks. One API key works across all of them.

How does SwiftNodes pricing work?

SwiftNodes uses flat-rate monthly pricing with no per-request fees. Plans range from a free tier (20 HTTP req/s, capped at 250,000 requests/month) through Starter ($49/mo, 70 req/s), Growth ($89/mo, 150 req/s), Scale ($149/mo, 300 req/s), and Pro ($249/mo, 600 req/s). Paid plans have no monthly request cap — just the flat rate limit. Prepay 6 months for 5% off, or 1 year for 10% off.

Is KYC required to use SwiftNodes?

No. Sign up with Google, GitHub, an email address (we send a one-time code) or a crypto wallet. We never ask for ID documents and we never store passwords.

How can I pay for a plan?

Paid plans accept either a credit or debit card, or cryptocurrency — ETH, BNB, USDT, and USDC on any supported chain. The free tier needs no payment method at all.

Does SwiftNodes support WebSocket RPC?

Yes, on most chains: alongside the HTTP endpoint (https://rpc.swiftnodes.io/rpc/<chain>) there is a WebSocket endpoint (wss://rpc.swiftnodes.io/ws/<chain>) for subscriptions and streaming, and each chain page shows whether WebSocket is available there. The free plan includes one WebSocket connection with new-head subscriptions; logs and pending-transaction feeds come with paid plans.

Do paid plans include archive node access?

Yes. Archive access is included on every paid plan, on every chain where we run an archive upstream — there's no separate, more expensive 'archive tier' to upgrade to. Each chain page shows how far back its state was readable when we last measured.

Do you support testnets?

Yes. Testnets use the same API key and plan as mainnets: for example https://rpc.swiftnodes.io/rpc/eth-sepolia for Ethereum Sepolia. In the dashboard, switch any chain between Mainnet and Testnet to copy its URLs; each chain page lists its testnet endpoints too.

Can I try SwiftNodes without signing up?

Yes. The public key demo works on every chain, for example https://rpc.swiftnodes.io/rpc/eth?key=demo. It is shared by everyone and limited to 2 requests per second, so it is for trying requests, not for running an app: sign up for your own free key before you build on it.

What happens if I go over my plan's rate limit?

Paid plans absorb short spikes first: requests above your plan's rate can draw on burst credit up to twice the plan rate for about 10 seconds, and the credit refills over five minutes. Past twice the rate, or once the credit is spent, requests get HTTP 429 and {"error":"Rate limited"} straight away. They are not queued and not billed, so retry with a short backoff. The free plan has no burst credit and is limited to 20 requests per second; it also stops at 250,000 requests in a month with a 429 that says when the limit resets.

How does flat-rate pricing work if paid plans have no monthly cap?

We cap speed, not monthly volume. Every plan has a requests-per-second ceiling, which bounds what a plan can use in a month, and we size upstream capacity for that. Providers that meter by request or compute unit tie your bill to your traffic; with SwiftNodes a traffic spike can hit your rate limit, but it never changes your bill.

Start building in 30 seconds.

Free tier, no card, no KYC. Upgrade when you need to.

Need help? Contact support →
Read the docs