Solana RPC infrastructure on self-owned bare metal

JSON-RPC, WebSocket and Carbon Stream gRPC streaming for Solana, served from hardware Carbium owns and runs in Switzerland. Plans start at $0.

Free plan

$0

Free plan to start

Pro plan

500 req/s

Requests per second on cached reads on Pro

Carbon Stream

$20

Per month, with gRPC streaming included

What you get with Carbium RPC

  • Bare metal in Switzerland

    • Hardware Carbium owns in Switzerland
    • Operated by Carbium, not resold cloud
    • Flat monthly plans from $0 to $500
    • Published credit and RPS limits
    See our infrastructure
  • Developer tools

    • Standard Solana JSON-RPC endpoint
    • WebSocket subscriptions on every plan
    • API keys on every plan
    • Dashboard with usage and key management
    RPC quick start
  • Carbon Stream

    • Solana gRPC streaming, native Yellowstone
    • Included from the Dev plan
    • Filters by account and commitment level
    • Same API key as your RPC endpoint
    Carbon Stream: Solana gRPC plans and fit

Plans and pricing

Simple pricing for teams of any scale

First paid plan $20 a month, $49 at Helius - Save more, build better

  • Free

    Ideal for testing

    $0Monthly

    • 500K credits, granted once
    • 5 requests/sec on cached reads
    • WebSocket: 5 connections, 10 subscriptions
    • Carbon Stream gRPC streaming (not included)
    • 1 API key
    Start building
  • Dev

    Recommended

    For small projects

    $20Monthly

    • 10M credits a month
    • 30 requests/sec on cached reads
    • WebSocket: 150 connections, 5,000 subscriptions
    • Carbon Stream: 5 gRPC streams
    • 5 API keys
    Start building
  • Business

    For growing teams

    $250Monthly

    • 50M credits a month
    • 100 requests/sec on cached reads
    • WebSocket: 250 connections, 20,000 subscriptions
    • Carbon Stream: 25 gRPC streams, 1 heavy
    • 10 API keys
    Start building
  • Pro

    For teams at scale

    $500Monthly

    • 200M credits a month
    • 500 requests/sec on cached reads
    • WebSocket: 1,000 connections, 50,000 subscriptions
    • Carbon Stream: 100 gRPC streams, 2 heavy
    • 15 API keys
    Start building

Free covers testing. getProgramAccounts and getTokenAccountsByOwner are served on every plan, Free and Dev at a floor rate. Dev covers standard JSON-RPC workloads and is the first plan with Carbon Stream. Plans are bought on carbium.sh. Prices are in US dollars, and card through Stripe is the main way to pay. You can also pay in USDC or USDT from your own wallet.

Compare all plans and limits

Enterprise

Custom limits, volume pricing and direct access to the engineering team for teams that outgrow Pro.

  • Volume discounts
  • Custom rate limits
  • Custom optimized infrastructure
  • Direct access to our engineering team
  • Advanced geographic coverage

Carbium vs Helius vs Quicknode

Solana RPC providers compared on what each plan includes and what it costs. Helius and Quicknode prices checked 21 October 2026; Carbium's are read from carbium.sh.

Carbium, Helius and Quicknode compared on plans, features and list prices, Helius and Quicknode checked 21 October 2026, Carbium's read from carbium.sh
FeatureCarbiumHeliusQuicknode
Free planYesYes1-month trial
JSON-RPC and WebSocket subscriptionsYesYesYes
WebhooksNoYesYes
Self-owned bare metal in SwitzerlandYesNoNo
List prices
First paid plan, per month$20$49$49
gRPC streaming included from$20$499$499
Highest public plan, per month$500$999$999+

List prices from each provider's own pricing page, Helius and Quicknode checked 21 October 2026, Carbium's read from carbium.sh. Plan contents differ, so compare credits and limits before you choose. All three stream over native gRPC. Helius includes it on mainnet from Business, with 10 connections, and bills streamed data from plan credits, and its $49 plan streams devnet only; Quicknode includes it from Scale or as a $499 a month add-on.

Connect in three steps

Carbium speaks standard Solana JSON-RPC, so your client code stays the same. Only the endpoint changes.

  1. Create a free account

    Sign up on carbium.sh with an emailed code, Google, X or a Solana wallet. The Free plan costs $0.

  2. Get your API key

    Your first sign-in gives you a starter key. One key works for JSON-RPC, WebSocket and, from Dev, Carbon Stream.

  3. Swap the endpoint URL

    Point @solana/web3.js, Anchor or any Solana client at your Carbium endpoint.

connect.ts
// Carbium RPC speaks standard Solana JSON-RPC
import { Connection } from "@solana/web3.js";

const connection = new Connection("https://services.carbium.sh/?api-key=YOUR_KEY", {
  commitment: "confirmed",
  wsEndpoint: "wss://services.carbium.sh/?api-key=YOUR_KEY",
});

const slot = await connection.getSlot();
The same key works for WebSocket subscriptions and, from the Dev plan, Carbon Stream.

FAQs

Can't find the answer you're looking for? We're always here to help you.

Browse the documentation

What is Carbium RPC?

Carbium RPC is a Solana RPC service run on servers Carbium owns and operates in Switzerland. It gives you a JSON-RPC endpoint, WebSocket subscriptions and, from the Dev plan, Carbon Stream, its Solana gRPC stream, all on one API key.

What is a Solana RPC endpoint, and why use a dedicated one?

An RPC endpoint is how your application reads from and writes to Solana: fetching accounts, sending transactions and subscribing to updates. Public endpoints are shared by everyone and rate-limited for everyone. A dedicated endpoint tied to your own API key gives you published credits and requests-per-second limits that are yours alone.

How much does Carbium RPC cost?

There are four public plans: Free at $0 with 500K credits, granted once, and 5 requests per second on cached reads, Dev at $20 a month with 10M credits and 30 requests per second, Business at $250 with 50M credits and 100, and Pro at $500 with 200M credits and 500. Plans are bought on carbium.sh. Prices are in US dollars, and card through Stripe is the main way to pay. You can also pay in USDC or USDT from your own wallet. Enterprise plans are priced on request.

Compare all plans and limits

Is there a free Solana RPC plan?

Yes. The Free plan costs $0 and includes 500K credits, granted once, and 5 requests per second on cached reads. It is meant for testing and proof-of-concept work. Carbon Stream is not included on Free.

Which plan includes gRPC streaming?

Dev ($20 a month), Business ($250 a month) and Pro ($500 a month) include Carbon Stream, Carbium's Solana gRPC stream. If your architecture depends on transaction streaming from day one, Dev is the plan to start on.

Carbon Stream: Solana gRPC plans and fit

What is the difference between credits and requests per second?

Credits are your usage budget; each request draws from it. Requests per second is the burst capacity available at one time. A workload can stay under its RPS ceiling and still use up its credits, or have credits left and still hit the RPS ceiling during spikes.

Rate limits and 429 responses explained

Does Carbium work with @solana/web3.js and Anchor?

Yes. Carbium speaks standard Solana JSON-RPC, so @solana/web3.js, Anchor and other Solana clients work by replacing the endpoint URLs, HTTP and WebSocket, with your Carbium endpoints. No other code changes are needed.

Example calls for common Solana RPC methods

How is Carbium different from Helius and Quicknode?

Carbium runs its own bare-metal servers in Switzerland and sells flat monthly plans with published credit and RPS limits. On list prices (Helius and Quicknode checked October 2026, Carbium's read from carbium.sh), the first paid plan is $20 against $49 at Helius and Quicknode, and Carbon Stream, its native gRPC stream, is included from $20 against $499 at both. Plan contents differ, so compare the limits on each site.

Read the full comparison, including Triton

What does self-owned infrastructure in Switzerland mean for my data?

It means Carbium owns and operates the servers that answer your requests, in Switzerland, instead of renting capacity on someone else's cloud. Your traffic is served from hardware under Carbium's control.

Who is Carbium RPC built for?

Wallets that need balance reads and signature subscriptions, indexers and real-time feeds that consume one upstream stream, and dashboards built on Carbium Token Data, the free token API. The docs have an implementation guide for each.

Implementation guides

How do I connect my app to Carbium RPC?

Create a free account on carbium.sh; your first sign-in gives you a starter key. Point your client at https://services.carbium.sh/?api-key=YOUR_KEY, and its WebSocket at wss://services.carbium.sh/?api-key=YOUR_KEY. The quick start guide walks through a first call.

RPC quick start

Where can I see service status?

Service status is published at status.carbium.io. The docs also cover monitoring your own usage from the dashboard.

status.carbium.io