Carbium

Carbium — Full-Stack Solana Infrastructure

Carbium is bare-metal Solana infrastructure — Swiss-engineered, no cloud middlemen. One platform covering the full transaction lifecycle.

Overview

| Product | Endpoint | Purpose | |---|---|---| | RPC | https://rpc.carbium.io | Standard JSON-RPC for reads, writes, subscriptions | | Standard WebSocket | wss://wss-rpc.carbium.io | Native Solana pubsub (account changes, slots, logs, signatures) | | gRPC / Stream | wss://grpc.carbium.io | Yellowstone Full Block streaming (~22ms latency) | | Swap API | https://api.carbium.io | DEX aggregation and execution powered by CQ1 engine | | DEX App | https://app.carbium.io | Consumer-facing trading interface | | Docs | https://docs.carbium.io | Full documentation |

Key differentiators:

• Sub-millisecond DEX quotes via CQ1 routing engine with binary-native state
• ~22ms Full Block gRPC — atomic, complete blocks (no shred reassembly)
• Gasless swaps — users trade without holding SOL
• MEV protection — Jito bundling built into Swap API
• Swiss bare-metal servers — sub-50ms RPC latency, 99.99% uptime

---

When to Use This Skill

| I want to... | Use | Key needed | |---|---|---| | Read account data / balances | RPC | RPC key | | Send a transaction | RPC | RPC key | | Monitor a wallet in real time | Standard WebSocket | RPC key | | Confirm a transaction without polling | Standard WebSocket | RPC key | | Watch program account changes | Standard WebSocket | RPC key | | Build a wallet app | RPC + Swap API | Both | | Get a token swap quote | Swap API | API key | | Execute a swap programmatically | Swap API | API key | | Execute a swap with Jito bundling | Swap API (bundle endpoint) | API key | | Compare quotes across all DEX providers | Swap API (quote/all) | API key | | Swap without users holding SOL | Swap API (gasless flag) | API key | | Snipe pump.fun tokens (pre-graduation) | gRPC + direct bonding curve tx | RPC key (Business+) | | React to on-chain events in real time | gRPC (streaming) | RPC key (Business+) | | Index transactions for a program | gRPC (streaming) | RPC key (Business+) | | Build an arbitrage / MEV bot | gRPC + Swap API | Both |

---

Quick Start

1. Get API Keys

| Product | Signup | Notes | |---|---|---| | RPC + gRPC + WebSocket | rpc.carbium.io/signup | One key covers RPC, WebSocket, and gRPC | | Swap API | api.carbium.io/login | Separate key, free account, instant |

Programmatic key provisioning is not yet available. Keys must be created via the dashboards.

2. Set Environment Variables

export CARBIUM_RPC_KEY="your-rpc-key"
export CARBIUM_API_KEY="your-swap-api-key"

3. Security Rules (Non-Negotiable)

• Never embed keys in frontend/client-side code
• Never commit keys to version control
• Use environment variables: CARBIUM_RPC_KEY, CARBIUM_API_KEY
• Rotate immediately if exposed
• Keep keys server-side only

---

Pricing Tiers

| Tier | Price | Credits/mo | Max RPS | gRPC | WebSocket | |---|---|---|---|---|---| | Free | $0 | 500K | 10 | No | Yes | | Developer | $32/mo | 10M | 50 | No | Yes | | Business | $320/mo | 100M | 200 | Yes | Yes | | Professional | $640/mo | 200M | 500 | Yes | Yes |

gRPC streaming requires Business tier or above.

---

RPC

Standard Solana JSON-RPC. Any Solana SDK works: @solana/web3.js, solana-py, solana Rust crate.

Endpoint:

https://rpc.carbium.io/?apiKey=YOUR_RPC_KEY

TypeScript

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

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

// Read balance
const pubkey = new PublicKey("YOUR_WALLET_ADDRESS");
const balance = await connection.getBalance(pubkey);
console.log(`Balance: ${balance / LAMPORTS_PER_SOL} SOL`);

// Send transaction
const sig = await connection.sendRawTransaction(transaction.serialize(), {
  skipPreflight: false,
  maxRetries: 3,
});
await connection.confirmTransaction(sig, "confirmed");

Python

from solana.rpc.api import Client
from solders.pubkey import Pubkey
import os

rpc = Client(f"https://rpc.carbium.io/?apiKey={os.environ['CARBIUM_RPC_KEY']}")
pubkey = Pubkey.from_string("YOUR_WALLET_ADDRESS")
resp = rpc.get_balance(pubkey)
print(f"Balance: {resp.value / 1e9} SOL")

Rust

use solana_client::rpc_client::RpcClient;
use solana_sdk::pubkey::Pubkey;
use std::str::FromStr;

let url = format!(
    "https://rpc.carbium.io/?apiKey={}",
    std::env::var("CARBIUM_RPC_KEY").unwrap()
);
let client = RpcClient::new(url);
let pubkey = Pubkey::from_str("YOUR_WALLET_ADDRESS").unwrap();
let balance = client.get_balance(&pubkey).unwrap();
println!("Balance: {} lamports", balance);

Commitment Levels

| Level | Speed | Guarantee | Use for | |---|---|---|---| | processed | ~400ms | May roll back | Price feeds, low-stakes UX | | confirmed | ~2s | Supermajority voted | Default — best balance | | finalized | ~32s | Fully finalized | Irreversible confirmations, high-value ops |

---

Standard WebSocket (Solana Pubsub)

Native Solana WebSocket pubsub — any SDK built for Solana WebSocket works with zero modifications.

Endpoint:

wss://wss-rpc.carbium.io/?apiKey=YOUR_RPC_KEY

Auth: same RPC key as query parameter. Available on all tiers (Developer and above recommended for production).

WSS vs gRPC — When to Use Which

| | Standard WSS | gRPC / Yellowstone | |---|---|---| | Protocol | JSON-RPC over WebSocket | Binary protobuf over WebSocket (or HTTP/2) | | What you get | Account changes, slot updates, logs, signatures | Full atomic blocks, all transactions | | SDK support | Any Solana SDK (@solana/web3.js, solana-py) | Yellowstone client or raw WS with JSON filter | | Latency | Sub-100ms subscription ack | ~22ms full block delivery | | Tier required | Developer+ | Business+ | | Best for | Wallets, dApps, monitoring specific accounts | MEV bots, indexers, full-block processing |

Rule of thumb: watching specific accounts or signatures → WSS. Processing all transactions or need full block data → gRPC.

Subscription Methods

| Method | What it streams | Typical use case | |---|---|---| | slotSubscribe | New slot numbers | Block clock, liveness checks | | rootSubscribe | Finalized slots | Finality tracking | | accountSubscribe | Account data changes | Wallet balance updates, PDA state changes | | programSubscribe | All accounts owned by a program | DEX pool state, staking updates | | signatureSubscribe | Transaction confirmation status | Confirm sent transactions in real time | | logsSubscribe | Transaction logs matching filter | Program event monitoring | | blockSubscribe | Full block data | Block explorers, indexers | | slotsUpdatesSubscribe | Detailed slot lifecycle events | Advanced timing, validator monitoring | | voteSubscribe | Vote transactions | Validator monitoring |

TypeScript — Watch a Wallet

import WebSocket from "ws";

const ws = new WebSocket(
  `wss://wss-rpc.carbium.io/?apiKey=${process.env.CARBIUM_RPC_KEY}`
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "accountSubscribe",
    params: [
      "YOUR_WALLET_ADDRESS",
      { encoding: "base64", commitment: "confirmed" },
    ],
  }));
});

ws.on("message", (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.result !== undefined) {
    console.log(`Subscribed, id: ${msg.result}`);
    return;
  }
  if (msg.method === "accountNotification") {
    const { lamports } = msg.params.result.value;
    console.log(`Balance changed: ${lamports / 1e9} SOL`);
  }
});

TypeScript — Confirm Transaction via WSS

ws.send(JSON.stringify({
  jsonrpc: "2.0",
  id: 1,
  method: "signatureSubscribe",
  params: ["YOUR_TX_SIGNATURE", { commitment: "confirmed" }],
}));

// signatureSubscribe auto-unsubscribes after first notification

TypeScript — Stream Program Logs

ws.send(JSON.stringify({
  jsonrpc: "2.0",
  id: 1,
  method: "logsSubscribe",
  params: [
    { mentions: ["PROGRAM_ID"] },
    { commitment: "confirmed" },
  ],
}));

Using @solana/web3.js (Recommended)

The Connection class handles subscriptions natively:

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

const connection = new Connection(
  `https://rpc.carbium.io/?apiKey=${process.env.CARBIUM_RPC_KEY}`,
  {
    commitment: "confirmed",
    wsEndpoint: `wss://wss-rpc.carbium.io/?apiKey=${process.env.CARBIUM_RPC_KEY}`,
  }
);

// Account subscription
connection.onAccountChange(
  new PublicKey("YOUR_WALLET"),
  (info, ctx) => console.log(`Balance: ${info.lamports / 1e9} SOL at slot ${ctx.slot}`),
  "confirmed"
);

// Slot subscription
connection.onSlotChange((slotInfo) => {
  console.log(`Slot: ${slotInfo.slot}`);
});

// Log subscription
connection.onLogs(
  new PublicKey("PROGRAM_ID"),
  (logs, ctx) => {
    console.log(`Tx: ${logs.signature}`);
    logs.logs.forEach(log => console.log(" ", log));
  },
  "confirmed"
);

Python — Watch Account

import asyncio, json, os
import websockets

WALLET = "YOUR_WALLET_ADDRESS"

async def watch_account():
    uri = f"wss://wss-rpc.carbium.io/?apiKey={os.environ['CARBIUM_RPC_KEY']}"
    async with websockets.connect(uri) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0", "id": 1,
            "method": "accountSubscribe",
            "params": [WALLET, {"encoding": "base64", "commitment": "confirmed"}],
        }))
        ack = json.loads(await ws.recv())
        print(f"Subscribed: {ack['result']}")
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("method") == "accountNotification":
                val = msg["params"]["result"]["value"]
                print(f"Balance: {val['lamports'] / 1e9} SOL")

asyncio.run(watch_account())

Unsubscribe

Every subscription method has a matching unsubscribe. Use the subscription ID from the ack:

{"jsonrpc": "2.0", "id": 2, "method": "accountUnsubscribe", "params": [SUBSCRIPTION_ID]}

| Subscribe | Unsubscribe | |---|---| | slotSubscribe | slotUnsubscribe | | accountSubscribe | accountUnsubscribe | | programSubscribe | programUnsubscribe | | signatureSubscribe | signatureUnsubscribe (auto after first notification) | | logsSubscribe | logsUnsubscribe | | blockSubscribe | blockUnsubscribe | | rootSubscribe | rootUnsubscribe |

For full notification shapes and advanced patterns, see resources/websocket-reference.md.

---

gRPC / Full Block Streaming

Real-time Yellowstone-compatible Full Block stream. ~22ms latency. Atomic complete blocks — no shred reassembly needed.

Endpoints & Auth

| Method | Format | Use case | |---|---|---| | WebSocket query param | wss://grpc.carbium.io/?apiKey=YOUR_RPC_KEY | Recommended for TS/Python | | HTTP/2 header | x-token: YOUR_RPC_KEY | For Rust yellowstone-grpc-client |

Requires Business tier or above.

Available Methods

| Method | Description | |---|---| | transactionSubscribe | Subscribe to real-time transactions with filters | | transactionUnsubscribe | Unsubscribe from transaction stream |

TypeScript — Subscribe to Program Transactions

import WebSocket from "ws";

const PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";

const ws = new WebSocket(
  `wss://grpc.carbium.io/?apiKey=${process.env.CARBIUM_RPC_KEY}`
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "transactionSubscribe",
    params: [
      {
        vote: false,
        failed: false,
        accountInclude: [PROGRAM_ID],
        accountExclude: [],
        accountRequired: [],
      },
      {
        commitment: "confirmed",
        encoding: "base64",
        transactionDetails: "full",
        showRewards: false,
        maxSupportedTransactionVersion: 0,
      },
    ],
  }));
});

ws.on("message", (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.result !== undefined) {
    console.log(`Subscribed, ID: ${msg.result}`);
    return;
  }
  if (msg.method === "transactionNotification") {
    const { signature, slot } = msg.params.result;
    console.log(`tx ${signature} in slot ${slot}`);
  }
});

// Always reconnect on close — see Production Patterns
ws.on("close", (code) => {
  console.warn(`Disconnected (${code}), reconnecting...`);
});

Filter Fields

| Field | Type | Description | |---|---|---| | vote | bool | Include vote transactions | | failed | bool | Include failed transactions | | accountInclude | string[] | Include txs involving ANY of these accounts | | accountExclude | string[] | Exclude txs involving these accounts | | accountRequired | string[] | Only include txs involving ALL of these accounts |

At least one of accountInclude or accountRequired must contain values.

Subscription Options

| Field | Type | Values | |---|---|---| | commitment | string | processed / confirmed / finalized | | encoding | string | base64 / base58 / jsonParsed | | transactionDetails | string | full / signatures / none | | showRewards | bool | Include reward information | | maxSupportedTransactionVersion | number | 0 for legacy + v0 |

Python

import asyncio, json, os
import websockets

PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"

async def subscribe():
    uri = f"wss://grpc.carbium.io/?apiKey={os.environ['CARBIUM_RPC_KEY']}"
    async with websockets.connect(uri) as ws:
        await ws.send(json.dumps({
            "jsonrpc": "2.0", "id": 1,
            "method": "transactionSubscribe",
            "params": [
                {
                    "vote": False, "failed": False,
                    "accountInclude": [PROGRAM_ID],
                    "accountExclude": [], "accountRequired": [],
                },
                {
                    "commitment": "confirmed", "encoding": "base64",
                    "transactionDetails": "full", "showRewards": False,
                    "maxSupportedTransactionVersion": 0,
                },
            ],
        }))
        async for message in ws:
            data = json.loads(message)
            if "result" in data:
                print(f"Subscribed: {data['result']}")
            elif data.get("method") == "transactionNotification":
                print(f"tx: {data['params']['result']['signature'][:20]}...")

asyncio.run(subscribe())

Rust (HTTP/2 gRPC)

use yellowstone_grpc_client::GeyserGrpcClient;

#[tokio::main]
async fn main() -> Result> {
    let mut client = GeyserGrpcClient::connect(
        "https://grpc.carbium.io",
        "YOUR_RPC_KEY",  // passed as x-token header automatically
        None,
    )?;
    let (_subscribe_tx, mut stream) = client.subscribe().await?;
    // Define subscription filters and consume stream
    Ok(())
}

Full Blocks vs Shreds

| Metric | Value | Context | |---|---|---| | Solana Slot Resolution | ~400ms | The window in which a block is produced | | Competitor "Shreds" | ~9ms | Fragmented data requiring client-side reassembly | | Carbium Full Blocks | ~22ms | Atomic, complete data ready for use |

The 13ms difference is negligible within a 400ms slot. Full Blocks provide atomic integrity, zero-logic ingestion, and parsing efficiency.

Unsubscribe

{"jsonrpc": "2.0", "id": 2, "method": "transactionUnsubscribe", "params": [SUBSCRIPTION_ID]}

For complete gRPC reference with response shapes, see resources/grpc-reference.md.

---

Swap API

Aggregated DEX quotes and execution powered by the CQ1 engine — sub-millisecond quotes, ~10ms chain-to-queryable latency, binary-native state.

Base URL: `https://api.carbium.

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: sendaifun
• Source: sendaifun/skills
• License: Apache-2.0
• Homepage: https://solanaskills.com

Install and usage instructions live in the source repository linked above.