# rpc edge - agent & integration guide

> Low-latency Solana RPC, Yellowstone gRPC & preprocessed gRPC for trading firms, funds, and quants.
> Last updated: 2026-07-13

This file tells an AI agent or coding assistant how to wire up rpc edge. For a
map of the site + content, see https://rpcedge.com/llms.txt. Full docs: https://docs.rpcedge.com.

## What rpc edge is
Co-located Solana infrastructure for high-frequency teams and on-chain agents: low-latency RPC, Yellowstone gRPC, preprocessed/decoded shreds (pre-confirm transaction intent), a direct-to-leader transaction sender, and dedicated bare-metal nodes. Racked at Equinix FR13 (Frankfurt), beside the Solana stake clusters and the Jito Block Engine. The thesis: see state first, land first.

Products:
- Solana RPC: Performance-tuned HTTP & WebSocket RPC (https://rpcedge.com/solana-rpc)
- Yellowstone gRPC: Geyser gRPC streaming, server-side filters (https://rpcedge.com/yellowstone-grpc)
- Preprocessed gRPC: Pre-execution transaction intent (https://rpcedge.com/decoded-shreds)
- Transaction Sender: JSON-RPC, raw HTTP, and QUIC relay paths (https://rpcedge.com/transaction-sender)
- Dedicated Nodes: Private bare-metal, co-located on request (https://rpcedge.com/dedicated-nodes)

## Get access
1. Sign up and create an API key: https://app.rpcedge.com/signup
2. The key is a UUID (e.g. `10bcb316-cd81-47d2-89c4-375354a8c54f`) and authenticates every endpoint below. Treat it like a password; load it from an env var, never commit it.
3. Billing is USDC on Solana - self-serve tiers Trader ($249/mo) and Desk ($499/mo), plus Custom dedicated. Pricing: https://rpcedge.com/pricing (machine-readable: https://rpcedge.com/pricing.md).

## Auth
- HTTP + WebSocket: pass the key as the `key` query param (`?key=YOUR_KEY`), or send an `x-api-key: YOUR_KEY` or `Authorization: Bearer YOUR_KEY` header.
- gRPC (Yellowstone / preprocessed): send `x-api-key: YOUR_KEY` (or `authorization: Bearer`) metadata.
- Mainnet only. Frankfurt-pinned aliases exist: `frankfurt.rpc.rpcedge.com`, `frankfurt.ws.rpcedge.com`, `frankfurt.grpc.rpcedge.com`, `frankfurt.relay.rpcedge.com`.

## Endpoints
| Product | Protocol | Endpoint | Auth |
|---|---|---|---|
| Solana RPC | HTTP + WebSocket (JSON-RPC) | `https://rpc.rpcedge.com?key=YOUR_KEY` | ?key= query param, or x-api-key / Bearer header |
| Yellowstone gRPC | gRPC (Geyser) | `grpc.rpcedge.com:443` | x-api-key metadata (or Bearer) |
| Preprocessed gRPC (decoded shreds) | gRPC stream (pre-confirm intent) | `gRPC stream - see /decoded-shreds` | x-api-key metadata |
| Transaction Sender | JSON-RPC / raw HTTP / QUIC | `https://relay.rpcedge.com/v1/submit` | x-api-key / Bearer |

- WebSocket (subscriptions): `wss://rpc.rpcedge.com?key=YOUR_KEY`.
- Transaction sender extra paths: `POST https://relay.rpcedge.com/v1/sendTransaction` (JSON-RPC), `POST https://relay.rpcedge.com/v1/transactions` (raw bytes/base64), `relay.rpcedge.com:4433` (QUIC).

## Quickstart

### TypeScript - RPC (@solana/web3.js)
```ts
import { Connection } from "@solana/web3.js";
const key = process.env.RPCEDGE_KEY;
const conn = new Connection(`https://rpc.rpcedge.com?key=${key}`, {
  wsEndpoint: `wss://rpc.rpcedge.com?key=${key}`,
  commitment: "processed", // lowest latency; use "confirmed"/"finalized" for safety
});
console.log(await conn.getSlot());
```

### Python - RPC (solana-py)
```python
import os
from solana.rpc.api import Client
client = Client(f"https://rpc.rpcedge.com?key={os.environ['RPCEDGE_KEY']}")
print(client.get_slot().value)
```

### Rust - RPC (solana-client)
```rust
use solana_client::rpc_client::RpcClient;
let url = format!("https://rpc.rpcedge.com?key={}", std::env::var("RPCEDGE_KEY")?);
let client = RpcClient::new(url);
let slot = client.get_slot()?;
```

### Raw HTTP JSON-RPC (any language)
```bash
curl -sX POST "https://rpc.rpcedge.com?key=$RPCEDGE_KEY" \
  -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSlot","params":[{"commitment":"processed"}]}'
```

### Yellowstone gRPC (Geyser stream)
Point any standard Yellowstone gRPC client at `grpc.rpcedge.com:443` and send `x-api-key: YOUR_KEY` (or `authorization: Bearer`) metadata. Open one stream, set narrow server-side filters (accounts by owner/key, transactions by account inclusion), and drain it. Full example: https://docs.rpcedge.com/yellowstone-grpc.

### Transaction sender - land fast
Easiest: send through the normal RPC (JSON-RPC compatible), e.g. `connection.sendRawTransaction(tx, { skipPreflight: true, maxRetries: 0 })`. For the fastest paths use the dedicated relay:
```bash
curl -sX POST "https://relay.rpcedge.com/v1/sendTransaction" \
  -H "x-api-key: $RPCEDGE_KEY" -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"sendTransaction","params":["<BASE64_SIGNED_TX>",{"encoding":"base64"}]}'
```

## Guidance for agents
- Reads: use `processed` commitment for the lowest latency; `confirmed`/`finalized` when correctness matters.
- Real-time state: prefer Yellowstone gRPC (push) over polling `getProgramAccounts`/`getSignaturesForAddress` in a loop.
- Earliest signal: use preprocessed/decoded shreds to see transaction intent before confirmation - but it is provisional (no execution result); reconcile against processed/confirmed state before treating it as settled.
- Landing: submit via the transaction sender (relay) for the fastest paths, not the public RPC, when you need the tx to land.
- Plans are flat monthly in USDC with included bandwidth (TB). Beyond the allowance traffic is limited/throttled - not auto-invoiced at $/GB. Manage keys, usage, and billing in the dashboard. Paid service only - no unauthenticated free public endpoint.

## Links
- Docs: https://docs.rpcedge.com (LLM index: https://docs.rpcedge.com/llms.txt)
- Benchmarks: https://rpcedge.com/benchmarks
- Pricing (machine-readable): https://rpcedge.com/pricing.md
- Site map for LLMs: https://rpcedge.com/llms.txt
- Support / onboarding: https://t.me/rpcedge