Solana RPC

Venum runs a free Solana JSON-RPC service at https://rpc.venum.dev. It's a drop-in replacement for any Solana RPC URL — @solana/web3.js, solana-py, raw curl, anything that speaks Solana JSON-RPC.

The service is multi-region: traffic is served from US-EAST, EU, and Asia (Singapore). The default rpc.venum.dev is a Global endpoint with geoDNS routing — your client resolves to the nearest region automatically. Pinned per-region hostnames are available if you want predictable single-region routing.

Endpoints

Pick whichever URL is closest to your application, or use the global one.

URL	Routing	Best for
rpc.venum.dev	Global — geoDNS auto-routes each client to the nearest region (US-EAST, EU, or Asia)	Most apps. Default choice.
us-east.rpc.venum.dev	Pinned US-EAST	Workloads that want a stable single region.
eu.rpc.venum.dev	Pinned EU	Lowest latency from European clients.
asia.rpc.venum.dev	Pinned Asia (Singapore)	Lowest latency from APAC clients.

HTTP : https://<endpoint>/?apiKey=<YOUR_API_KEY>
WS   : wss://<endpoint>/?apiKey=<YOUR_API_KEY>

Both transports run on the same hostname. WebSocket subscriptions (accountSubscribe, slotSubscribe, signatureSubscribe, logsSubscribe, programSubscribe, etc.) are fully supported on all endpoints.

Which endpoint should I use?

For most apps, just use the global rpc.venum.dev. If your client geography is fixed and you want predictable routing, pin to the regional endpoint that's closest.

Your API key works on all endpoints — same key, same rate limits, same data.

Authentication

Every request needs a Venum API key. Two equivalent ways to pass it:

• Query string: ?apiKey=<YOUR_API_KEY> — works for HTTP and WebSocket. Required for WebSocket because browsers can't set custom headers on the WebSocket constructor.
• HTTP header: X-API-Key: <YOUR_API_KEY> — works for HTTP only.

Get a free API key in 30 seconds at app.venum.dev (Google sign-in, no card).

Anonymous requests return 401 Unauthorized with a message pointing at the dashboard.

Drop-in usage

@solana/web3.js

import { Connection } from '@solana/web3.js';

const connection = new Connection(
  `https://rpc.venum.dev/?apiKey=${process.env.VENUM_API_KEY}`,
  'confirmed',
);

const slot = await connection.getSlot();

WebSocket subscription

import { Connection } from '@solana/web3.js';

// web3.js derives wsEndpoint from endpoint by default (https → wss)
const connection = new Connection(
  `https://rpc.venum.dev/?apiKey=${process.env.VENUM_API_KEY}`,
);

const subId = await connection.onSlotChange((info) => {
  console.log('slot', info.slot);
});

curl

curl -X POST https://rpc.venum.dev/ \
  -H "X-API-Key: $VENUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSlot","params":[{"commitment":"processed"}]}'

Rate limits

Limits are per API key, sliding-window. Headers X-RateLimit-Limit and X-RateLimit-Remaining come back on every response; a 429 carries Retry-After in seconds.

Tier	Requests / min	Concurrent WS connections
Free	45	2
Starter	400	10
Growth	1,200	25
Pro	3,000	40

When you hit a 429, the response body is a JSON-RPC error envelope. The error data field carries the limit details and a link to upgrade:

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32005,
    "message": "free tier allows 45 rpc req/min. Upgrade to starter for 400/min at https://app.venum.dev",
    "data": {
      "limit": 45,
      "tier": "free",
      "retryAfterSeconds": 17,
      "nextTier": "starter",
      "nextTierLimit": 400,
      "upgradeUrl": "https://app.venum.dev"
    }
  }
}

If your client follows Retry-After, you'll get clean back-pressure without losing requests.

Method support

All standard Solana RPC methods are supported — read and write, including sendTransaction, simulateTransaction, getProgramAccounts, getMultipleAccounts, and the full *Subscribe family on WebSocket.

If a method doesn't behave as expected for your use case, open a ticket on Discord and we'll take a look.

When to use this vs the Venum API

The RPC service is the right call when you need stateful read patterns or write paths that map cleanly to Solana RPC: tx submission, signature subscriptions, custom on-chain reads, anything that already works with a Solana RPC URL.

For repeated polling patterns — token prices, pool state, account portfolios, quotes — the Venum API is purpose-built and dramatically cheaper per call. A token-balance walk that costs you ~50 getMultipleAccounts calls on RPC is one call to /v1/balances/:wallet. See Reduce RPC Costs.

Error responses

401 Unauthorized — missing or invalid API key.

429 Too Many Requests — over your tier limit. Retry after Retry-After seconds.

502 / 503 — service degraded. Generic JSON-RPC error in the body (code: -32603). Retry with backoff.

Standard JSON-RPC errors (parse error, invalid request, method not found) come back with the proper -32700/-32600/-32601 codes.

Status

Liveness: GET https://rpc.venum.dev/health (no auth required).