Carbium RPC

Carbium RPC is the standard Solana JSON-RPC surface in the Carbium infrastructure stack. Use it for account reads, transaction submission, confirmation checks, SDK integrations, and the operational paths that still belong on normal RPC instead of a streaming feed.

This page is the product map. It should help you answer one question quickly: which Carbium RPC path should I use next?

Part of the Carbium full-stack Solana infrastructure stack.

Direct answer

For standard Solana application traffic, start with:

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

Any normal Solana JSON-RPC client can use that endpoint. In TypeScript, Python, Rust, or curl, the integration model is the same: send standard Solana RPC requests to Carbium's endpoint with your RPC dashboard key attached.

Use this surface when you need to:

fetch balances, account data, blocks, transactions, or recent blockhashes
submit signed transactions
confirm signatures and inspect transaction status
run wallet, dashboard, backend, bot, or support tooling that uses normal JSON-RPC methods

If your workload is mostly "tell me when something changes", evaluate Carbium gRPC before building a high-frequency polling loop.

Choose the right next page

If you are trying to...	Start here	Why
Get connected in a few minutes	Quick Start RPC	Shortest path from key to first `getHealth` call
Create or manage the RPC key	Get Your API Key	Dashboard setup and key handling basics
Copy the endpoint into a client	Get Your Endpoint	Endpoint page and dashboard orientation
Test methods before writing code	Your First Test Call	Simple request/response validation path
Pick a plan or understand RPS	RPC Pricing and Usage Tiers	Canonical owner for credits, RPS caps, and gRPC plan threshold
Diagnose `429` responses	Solana RPC Rate Limits Explained	Burst, retry, and traffic-shaping guidance
Classify RPC failures	RPC Errors Reference	HTTP status, JSON-RPC, transaction, and support payload triage
Monitor usage and credit burn	Status and Metrics	Operational map for dashboard, method mix, and incident reads
Move from polling to streaming	Carbium gRPC	Streaming setup and transport choice

This page deliberately does not duplicate the full pricing table, error taxonomy, or key security checklist. Those pages own the deeper operational details.

Minimal smoke test

After you create an RPC key, run one small call before wiring the endpoint into a full application:

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

A successful response proves the key, endpoint, and network path are working. After that, move to the method your app actually needs, such as getBalance, getLatestBlockhash, sendTransaction, or getSignatureStatuses.

TypeScript connection shape

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

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

const slot = await connection.getSlot();
console.log(slot);

Keep the RPC key in a backend environment variable whenever possible. If the application also uses Carbium Swap API, keep the Swap API key separate from the RPC key.

What belongs on RPC vs streaming

Standard RPC and streaming solve different problems. Do not force every workload into one path.

Workload	Better default	Reason
Wallet balance read	RPC	One direct account read is simpler than a stream
Transaction submission	RPC	The write path still submits a signed transaction through JSON-RPC
Signature confirmation after a send	RPC first, streaming when the app needs it	Polling `getSignatureStatuses` is enough for many backends
Always-on program monitoring	gRPC	A stream avoids repeated "anything new?" polling
Trading or indexing workers reacting to chain activity	gRPC plus RPC	Stream for detection, RPC for targeted reads and writes
Usage, billing, and request mix checks	Dashboard and monitoring pages	Operational signals live outside the endpoint itself

The practical rule: use RPC when your app asks a specific question or submits a specific transaction. Use gRPC when your app needs a continuous feed.

Production decisions to make early

Before live traffic, decide these five things instead of discovering them during an incident:

Where the key lives: backend env var, secret manager, or another server-side store.
Which plan shape fits traffic: monthly credits and request-per-second pressure are separate constraints.
How retries behave: backoff and jitter should prevent retry storms, especially after timeouts.
Which metrics prove normal behavior: baseline credit burn, method mix, peak windows, and common errors.
When streaming is required: gRPC starts at Business tier in Carbium's published pricing docs, so streaming workloads should validate plan access early.

For key storage, restrictions, and rotation, use API Key Security Best Practices. For burst behavior, use Solana RPC Rate Limits Explained.

📘
The first RPC integration should be boring: one key, one endpoint, one small method call, then a controlled move into pricing, monitoring, rate limits, and streaming only when the workload needs them.

How RPC fits with the rest of Carbium

Carbium RPC is one layer of the stack, not the whole product surface.

Carbium surface	Use it for	Key model
RPC	Solana JSON-RPC reads, writes, and confirmation checks	RPC dashboard key
gRPC	Real-time Solana stream consumption	RPC dashboard key; Business tier and above
Swap API	Quote and transaction-building workflows	Separate Swap API key
Carbium Data	Token search, mint lookup, batch resolves, and cached logos	Public no-key API for current Token Index routes
Carbium DEX	Browser-based swap product	Wallet connection

If you are building a wallet, trading bot, dashboard, or backend, you may use more than one surface: RPC for chain access, Swap API for executable swap transactions, and Carbium Data for token metadata.

🔶
Ready to wire Carbium RPC into a Solana app? Start from carbium.io, create the RPC key, and use the quick-start path before moving into production hardening.