Migrate from QuickNode to Carbium

If your QuickNode usage is mostly standard Solana JSON-RPC, the first migration step is straightforward: replace the endpoint, update auth, and rerun your health checks.

The real migration risk is everything QuickNode packages around that core endpoint. QuickNode's current Solana docs separate standard WebSockets, Yellowstone Geyser gRPC, Streams, and Metis into distinct product surfaces. Carbium's public docs today are strongest on JSON-RPC at rpc.carbium.io, transaction-centric streaming at grpc.carbium.io, and Swap API / CQ1 with a separate API key.

This page shows what can move cleanly now, what needs a separate migration track, and how to cut over without assuming every QuickNode feature has a drop-in Carbium equivalent.

Part of the Carbium Solana infrastructure stack.

What migrates cleanly today

For normal backend reads and writes, treat this as a standard RPC provider migration first. The safest cutover is to move plain JSON-RPC traffic before you touch streaming or trading add-ons.

What does not map 1:1

Do not treat these as hostnames you can simply swap:

Endpoint and auth mapping

QuickNode's current Solana endpoint docs publish HTTP and WSS endpoints with embedded auth tokens, and the security docs also allow x-token header auth. Carbium's public docs publish a shared RPC endpoint plus a gRPC endpoint and allow query-param or header-based auth depending on the surface.

One practical difference matters during migration: QuickNode documents multiple auth models per endpoint, including multiple tokens per endpoint on some plans. Carbium's public docs recommend separate keys per product and environment, plus RPC endpoint restrictions in the dashboard.

Minimal cutover for standard RPC traffic

If your QuickNode footprint is mainly standard Solana JSON-RPC, migrate in this order:

1. Create a Carbium RPC key.
2. Add CARBIUM_RPC_KEY to your secret store.
3. Replace the QuickNode endpoint URL in the services you want to move first.
4. Re-run a small smoke test with getVersion, getSlot, and one high-volume production read.
5. Check whether any service still depends on QuickNode-only products like Streams or Metis.

TypeScript before and after

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

// Before: QuickNode
const quicknode = new Connection(process.env.QUICKNODE_RPC_URL!, "confirmed");

// After: Carbium
const carbium = new Connection(
  `https://rpc.carbium.io/?apiKey=${process.env.CARBIUM_RPC_KEY}`,
  "confirmed"
);

async function smokeTest() {
  const [version, slot] = await Promise.all([
    carbium.getVersion(),
    carbium.getSlot(),
  ]);

  console.log(version["solana-core"]);
  console.log(slot);
}

cURL smoke test

curl -X POST "https://rpc.carbium.io/?apiKey=$CARBIUM_RPC_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getVersion",
    "params": []
  }'

How to handle QuickNode real-time products

Standard WebSockets

QuickNode's Solana docs position WebSockets as the easy path for account changes, logs, and other native subscription flows. Carbium's public docs do not currently publish a standard WebSocket page as a live canonical path. If your app depends on standard WSS subscriptions, keep that part of the stack separate until Carbium's standard WebSocket docs are verified.

Yellowstone Geyser gRPC

QuickNode documents Yellowstone as a separate add-on with its own secure port and token handling. Carbium publicly documents grpc.carbium.io, but you should still re-test:

• how your client authenticates
• which subscription method names your code expects
• whether your filters are account-centric or transaction-centric
• whether you are relying on language-specific client code that assumes QuickNode's endpoint shape

Treat this as a streaming migration, not a simple endpoint swap.

Streams

QuickNode Streams is a managed service with historical backfill, JavaScript filtering, multiple destinations, and delivery guarantees. Carbium's public docs do not describe a direct replacement for that managed workflow. If Streams is in production today, give it its own migration plan and owner.

If you use Metis or other QuickNode add-ons

QuickNode's current Solana docs treat Metis as a separate trading API with its own private endpoints and supported methods. Carbium's equivalent public surface is a separate Swap API with its own authentication model:

• quote: https://api.carbium.io/api/v2/quote
• swap: https://api.carbium.io/api/v2/swap
• auth: X-API-KEY: YOUR_API_KEY

That means a QuickNode app using Metis, Pump.fun trading methods, limit-order endpoints, or Metis webhooks should not be migrated as part of the standard RPC cutover. Migrate the RPC path first, then map trading flows separately against Carbium's Swap API docs.

Security and environment model changes

QuickNode's security docs currently include:

• URL-embedded token auth
• x-token header auth
• optional referrer whitelisting
• JWT auth on higher plans
• multiple auth tokens per endpoint
• method rate limiting and domain masking on higher plans

Carbium's public docs currently emphasize:

• separate keys by product and environment
• RPC endpoint restrictions by domain or IP
• server-side secret storage
• key rotation when access changes or a leak is suspected

So if your QuickNode setup depends on platform-managed security features beyond basic token auth, reproduce those controls in your own backend, gateway, or infrastructure layer before full cutover.

Migration checklist

• CARBIUM_RPC_KEY is stored in your secrets manager or environment
• Standard JSON-RPC traffic has been tested against rpc.carbium.io
• The Carbium RPC endpoint is restricted by trusted domain or IP where practical
• QuickNode Streams, Metis, or other add-ons have a separate migration owner
• Standard QuickNode WebSocket consumers are not being moved blindly
• Yellowstone / gRPC clients have been tested against grpc.carbium.io before production cutover
• Rate-limit behavior has been checked against the Carbium plan you intend to use

When Carbium is a good fit

Carbium is the cleanest next step when your QuickNode usage is centered on:

• standard Solana JSON-RPC
• transaction-centric streaming
• swap or routing workflows you are comfortable mapping onto a separate API surface

It is not a same-day, one-window migration for teams that depend heavily on QuickNode Streams, Metis, or QuickNode-managed security features.

📘The safest QuickNode migration is layered: move standard RPC first, then treat WebSockets, Yellowstone, Streams, and trading add-ons as separate tracks.

🔶Ready to move your Solana RPC traffic to Carbium? Start with the documented setup flows at carbium.io.