Documentation

Everything you need to connect to Subglow filtered Solana gRPC streams. From API key to first filtered transaction in under 5 minutes.

Industry Standard Compatibility

Subglow is fully compatible with the Yellowstone (Dragon's Mouth) gRPC specification. We don't force you to use a proprietary SDK or learn a custom protocol. If your bot already uses standard Yellowstone client libraries, you are ready to use Subglow — just change the endpoint. Same wire protocol, but with pre-parsed JSON that eliminates the 15-30ms parsing bottleneck from your execution path.

LayerSpecification
ConsensusSolana Mainnet-Beta
TransportgRPC over HTTP/2 + Protobuf 3
CompressionZstandard (zstd) / Gzip
FinalitySlot confirmation (~400ms) · Alpenglow target: ~150ms
InterfaceYellowstone SubscribeRequest / SubscribeUpdate
Client Libraries@triton-one/yellowstone-grpc (JS) · yellowstone-grpc-client (Rust)
Execution AdvantagePre-parsed JSON eliminates 15-30ms Borsh/Protobuf parsing overhead

Prepared for Alpenglow

As Solana transitions to Alpenglow consensus with faster finality, Subglow's Yellowstone-compatible interface means your integration requires zero code changes. We track the Alpenglow rollout and will surface finality metadata as soon as it's available on Mainnet-Beta.

Quickstart

// Step 1

Create an account

Sign up at subglow.io/register. Choose a paid plan for instant access, or apply for a free trial (100 requests/day, reviewed within 24 hours).

// Step 2

Choose your filters

In your dashboard, select which programs to stream: pump_fun, raydium, jupiter, or provide custom Program IDs (Pro tier).

// Step 3

Connect and trade

Point your gRPC client at grpc.subglow.io:443 with your API key in the x-api-key metadata header. You'll start receiving filtered transactions immediately.

Authentication

All requests require an API key passed as gRPC metadata. Your key determines your tier (Sniper, Pro, or Dedicated) and which filters are available.

gRPC metadata
x-api-key: your-api-key-here

API keys are 32-character alphanumeric strings. Never expose your key in client-side code or public repositories.

Migration Guide

Switching from providers like Triton One, Helius, or any Yellowstone-compatible endpoint to Subglow takes less than 60 seconds. Because we support the standard Yellowstone SubscribeRequest schema, your existing code works as-is — and you gain pre-parsed JSON that eliminates 15-30ms of parsing overhead.

Before → After (Node.js — only 2 lines change)
const client = new Client("https://grpc.triton.one");
const meta = { "x-token": "TRITON_KEY" };
const client = new Client("https://grpc.subglow.io");
const meta = { "x-api-key": "YOUR_SUBGLOW_KEY" };
// Everything else stays the same — same subscribe(), same filters
// Step 1

Update your endpoint

Replace your old provider's connection string with the Subglow global load-balancer. We auto-route to the nearest region (Frankfurt, NY4).

grpc.triton.one:443
grpc.subglow.io:443
// Step 2

Update authentication

We use the standard x-api-key metadata header. Coming from a provider that uses x-token? Our proxy accepts both — or simply rename the header key in your connection settings.

x-api-key: your-subglow-key
x-token also accepted for Yellowstone client compat
// Step 3

Keep your filters

We support the standard Yellowstone SubscribeRequest schema. Your existing filter configurations for Program IDs, Account Mentions, and transaction subscriptions work exactly as they do now. On top of that, Subglow adds pre-parsed JSON output — a free upgrade to your existing pipeline.

Filter Configuration

Filters determine which transactions reach your client. Filtering happens server-side before data leaves our infrastructure — reducing your bandwidth and CPU consumption.

Filter IDProgramEventsTier
pump_funPump.funbuy, sell, create, migrateAll
raydiumRaydium v5swap, add_liq, remove_liq, create_poolAll
jupiterJupiter v6swap, limit_order, dcaAll
customAny Program IDAll instructionsPro+

Node.js Example

Uses the standard @triton-one/yellowstone-grpc client library. No proprietary SDK required.

index.js
const Client = require("@triton-one/yellowstone-grpc");
const client = new Client(
"https://grpc.subglow.io",
undefined,
{ "grpc.max_receive_message_length": 64 * 1024 * 1024 }
);
const metadata = { "x-api-key": "YOUR_SUBGLOW_KEY" };
const stream = await client.subscribe(metadata);
stream.on("data", (data) => {
console.log("New transaction:", data);
});

npm install @triton-one/yellowstone-grpc — works with any Yellowstone-compatible endpoint.

Rust Example

Uses the standard yellowstone-grpc-client crate. Our proxy maps x-token to the internal API key automatically.

main.rs
use yellowstone_grpc_client::GeyserGrpcClient;
#[tokio::main]
async fn main() -> Result<()> {
let mut client = GeyserGrpcClient::build_from_shared(
"https://grpc.subglow.io"
)?
.x_token(Some("YOUR_SUBGLOW_KEY".into()))
.connect().await?;
println!("Connected to Subglow gRPC stream");
let (mut subscribe_tx, mut stream) = client
.subscribe().await?;
while let Some(msg) = stream.next().await {
println!("{:?}", msg?);
}
Ok(())
}

cargo add yellowstone-grpc-client — same crate used with Triton, Helius, and other Yellowstone endpoints.

Python Example

main.py
import grpc
from subglow_pb2_grpc import SubglowStub
from subglow_pb2 import SubscribeRequest
channel = grpc.secure_channel(
"grpc.subglow.io:443",
grpc.ssl_channel_credentials()
)
stub = SubglowStub(channel)
metadata = [("x-api-key", "your-api-key")]
for tx in stub.Subscribe(
SubscribeRequest(filters=["pump_fun"]),
metadata=metadata
):
print(tx.parsed)

Output Schema

Every transaction arrives as a structured JSON object. The parsed field contains program-specific data with human-readable field names and native types (no base58/base64 encoded blobs).

Pump.fun

Pump.fun buy event
{
"signature": "5K7x...",
"slot": 284391204,
"slot_lag_ms": 4,
"program": "pump_fun",
"type": "buy",
"parsed": {
"token": "7xKXtg...",
"sol_amount": 2.45,
"token_amount": 1284000,
"bonding_curve_pct": 34.2,
"buyer": "Gh9Z...",
"virtual_sol_reserves": 48.7
}
}

Raydium AMM

Raydium swap event
{
"signature": "5vK9...",
"slot": 284391210,
"slot_lag_ms": 3,
"program": "raydium_amm",
"type": "swap",
"parsed": {
"pool": "58oQ...",
"token_in": { "mint": "So11...", "amount": 1500000000 },
"token_out": { "mint": "EPjF...", "amount": 42819200 },
"direction": "buy",
"price_impact_bps": 12
}
}

Error Codes

CodeStatusDescription
UNAUTHENTICATED401Missing or invalid API key
PERMISSION_DENIED403Filter not available on your tier
RESOURCE_EXHAUSTED429Rate limit exceeded (Sniper tier)
UNAVAILABLE503Upstream node temporarily unreachable
INTERNAL500Server error — retry with backoff

Rate Limits by Tier

TierConcurrent streamsFiltersDelivery
Sniper2pump_fun, raydium, jupiterStandard
Pro10All + custom Program IDsFull-speed
DedicatedUnlimitedAll + customFull-speed + SLA

WebSocket Fallback

For environments where gRPC is not available (browsers, serverless functions), we offer a WebSocket endpoint with the same filtered output.

WebSocket connection
wss://ws.subglow.io/v1?key=your-api-key&filter=pump_fun,raydium

WebSocket adds ~2-5ms wire latency compared to native gRPC. Both deliver pre-parsed JSON, so execution latency stays low regardless of transport.

Health Endpoint

Monitor our infrastructure's real-time slot lag versus the Solana network. Use this to verify data freshness and detect upstream issues.

Requires authentication. Pass your API key via the x-api-key header.

Never guess if you're behind. Check your real-time slot lag directly from your bot.

GET https://api.subglow.io/health
{
"status": "healthy",
"slot_lag_ms": 4,
"current_slot": 284391208,
"upstream_slot": 284391212,
"active_streams": 142,
"region": "eu-west-1"
}

Quick Check

curl
curl -H "x-api-key: YOUR_SUBGLOW_KEY" https://api.subglow.io/health
Node.js — embed in your bot
const res = await fetch("https://api.subglow.io/health", {
headers: { "x-api-key": "YOUR_SUBGLOW_KEY" },
});
const health = await res.json();
if (health.slot_lag_ms > 10)
console.warn("Slot lag elevated:", health.slot_lag_ms);