This guide is for Solana teams currently running on Helius (or QuickNode, or Alchemy, or any major credit-metered JSON-RPC provider) who want to move reads + submits to Subglow. We bundle gRPC streaming on the same API key, so migrating is particularly attractive if you're already using us for gRPC.

Short version: change the URL, keep your client code. The details below cover what to check before you flip production traffic.

Compatibility at a glance

Subglow's JSON-RPC endpoint speaks the standard Solana JSON-RPC 2.0 protocol. Any client library that talks to api.mainnet-beta.solana.com or a Helius endpoint works against us with no code changes — only the endpoint URL is different.

@solana/web3.js — works.
solders (Python) — works.
anchor-client — works.
solana_sdk (Rust) — works.
Plain fetch with a JSON body — works.

The wire protocol is identical. Our gateway forwards the request to an edge RPC backend and pipes the response straight back. Nothing in your client-side code needs to know you switched providers.

The one URL change

The Subglow endpoint is:

https://rpc.subglow.io/<your-api-key>

Or, with a Bearer header:

https://rpc.subglow.io/
Authorization: Bearer <your-api-key>

Both forms work. Pick whichever your client makes easier.

If you're currently constructing a Helius URL like:

https://rpc.helius.xyz/?api-key=<helius-key>

Your migration is a one-line change in config. Below are the three most common client shapes.

TypeScript / Node (@solana/web3.js)

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

// Before
const connection = new Connection(
  `https://rpc.helius.xyz/?api-key=${process.env.HELIUS_KEY}`
);

// After
const connection = new Connection(
  `https://rpc.subglow.io/${process.env.SUBGLOW_KEY}`
);

Python (solders + httpx)

import httpx

# Before
RPC_URL = f"https://rpc.helius.xyz/?api-key={os.environ['HELIUS_KEY']}"

# After
RPC_URL = f"https://rpc.subglow.io/{os.environ['SUBGLOW_KEY']}"

async with httpx.AsyncClient() as c:
    resp = await c.post(RPC_URL, json={
        "jsonrpc": "2.0",
        "id": 1,
        "method": "getSlot",
    })

Rust (reqwest)

let url = format!(
    "https://rpc.subglow.io/{}",
    std::env::var("SUBGLOW_KEY")?
);
let body = serde_json::json!({
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSlot",
});
let resp: serde_json::Value = client.post(&url).json(&body).send().await?.json().await?;

What's on parity

Everything in the Subglow standard method allowlist returns byte-compatible responses to Solana RPC 2.0. Specifically:

Account reads: getAccountInfo, getMultipleAccounts, getBalance, getTokenAccountsByOwner, getTokenAccountBalance.
Slot / epoch: getSlot, getEpochInfo, getLatestBlockhash, getBlockHeight.
Token supply + metadata: getTokenSupply, getTokenLargestAccounts.
Submits: sendTransaction, sendRawTransaction.
Fees: getFeeForMessage, getRecentPrioritizationFees.
Transaction reads: getTransaction (for non-archival lookups).

If your client today calls these methods against Helius, it calls the same methods with the same parameters against Subglow and gets the same response shape.

What's different

Four things you should know before flipping production traffic.

1. Archival methods gated to Dedicated

getProgramAccounts without filters, historical getBlock, wide getSignaturesForAddress scans — these are allowed only on Subglow's Dedicated tier. On shared tiers they return:

{"error":{"code":-32001,"message":"archival-disabled: getProgramAccounts requires Dedicated plan"}}

Most sniper / copy-trader workloads don't need archival. If yours does, Dedicated provisions archival capacity sized for your traffic. We wrote up the reasoning here.

2. Flat daily caps instead of credits

Helius charges credits per method with weights. Subglow charges one request per call regardless of method, with a daily cap. Most workloads come out cheaper on Subglow because heavy methods (especially filtered getProgramAccounts) cost the same as a getBalance. Full breakdown here.

3. Separate sendTransaction bucket

sendTransaction and sendRawTransaction count against their own daily limit, independent of reads. On Helius, a scanner spike can burn credits your submit path needed. On Subglow, it can't. Here's why we built it that way.

4. Same API key unlocks gRPC

This is the genuinely new thing. The API key you use for https://rpc.subglow.io/<key> also opens grpc.subglow.io:443 for Yellowstone-compatible streams. If you're already on Helius for RPC and self-hosting a Yellowstone node (or paying for Laserstream on the side), you can consolidate the whole data plane onto one vendor.

Migration checklist

A low-risk way to move over without a flag day:

Signup + get an API key. Start on a free trial if you want to run end-to-end tests before paying.
Dual-run for 24h. Keep your Helius endpoint configured, point a copy of your bot (or a shadow request pipeline) at Subglow. Compare responses byte-for-byte on the methods that matter to you.
Compare latencies. We publish p50 getSlot latency at 20–40ms from AMS/FRA. If you're colocated in those regions you should see similar numbers. If you're far away, your regional picture dominates.
Flip read traffic first. Reads are idempotent. If something breaks, flip back without losing a trade.
Flip submits second. Start with a small percentage of submits routed to Subglow, watch sendTransaction confirmation rates, ramp up if they match.
Cancel the old plan. Once your Subglow usage looks steady and your Helius usage is zero for a billing cycle, cancel.

Common gotchas

Your client is sending a commitment level that the old provider silently normalized. Subglow respects the commitment parameter exactly as documented. If you were relying on a provider-specific default, pass commitment: "confirmed" (or whatever you need) explicitly.

Your client expects a proprietary method. Some Helius-specific methods (getAssetsByOwner, getAsset, searchAssets) are in the DAS extension, not standard Solana RPC. On Subglow these are part of the archival allowlist and gated to Dedicated.

Your client parses errors by message string. Error codes match the JSON-RPC spec; error messages are ours. Parse by code, not message.

Migrating From Helius to Subglow JSON-RPC: A One-URL-Change Walkthrough