The fastest way to land
a transaction on Solana.
Sign your transaction, hand us the bytes, and we push them to the leader over staked connections we keep warm. No RPC hop. No simulation. No blockhash round trip. One prepaid balance and a flat price per send.
- Staked connections, held open and kept warm
- QUIC or plain HTTPS, whichever your stack prefers
- 0.0002 SOL per accepted send, prepaid in SOL
1const res = await fetch("https://send.swqos.com/v1/transactions", {2 method: "POST",3 headers: {4 Authorization: `Bearer ${process.env.SWQOS_API_KEY}`,5 "Content-Type": "application/json",6 },7 body: JSON.stringify({8 transaction: Buffer.from(tx.serialize()).toString("base64"),9 }),10});1112const { signature, charged_lamports } = await res.json();
A diagram comparing two transaction paths. The typical RPC path passes through three hops with queueing at each before reaching the leader. The swqos.com path passes through one staked connection and arrives sooner. Measured relay overhead is 6.29 milliseconds at the median on production traffic.
Three steps.
Nothing hidden in between.
You keep control of the transaction. We are a path, not a middleman that rewrites what you signed.
You sign
Build and sign the transaction exactly as you do today, with your own keypair on your own machine. We never see a private key and we never touch the contents.
tx.sign([payer])We forward
We validate the envelope, charge your prepaid balance, and write the unchanged bytes to a staked connection that is already open. Nothing is added to your transaction.
POST /v1/transactionsYou get a receipt
A receipt means we forwarded your bytes and the upstream acknowledged the stream. Landing on chain is the network's decision, not ours.
getSignatureStatuses([sig])Why it is fast.
Four reasons, all structural.
Speed here is not tuning. It is what we removed.
- staked connections
- We hold stake-weighted QoS connections to the network and keep 4 of them warm at all times. Your transaction never waits on a handshake, because the handshake happened long before you showed up.
- one hop
- Your bytes go from our relay to the leader. There is no general-purpose RPC in the middle deciding what to do with them, batching them behind someone else's traffic, or dropping them under load.
- nothing in the hot path
- We do not fetch a blockhash, run a simulation, check a signature status, or attach a tip instruction. We read your bytes, validate the envelope, charge, and forward. That is the entire critical path.
- persistent QUIC
- Open one connection and keep it. One bidirectional stream per submission, no reconnect, no TLS handshake and no TCP slow start per transaction. Point a client at send.swqos.com:11000 and hold it open for the life of your process.
Two ways in.
Pick the one that fits your stack.
HTTPS is a plain JSON POST and drops into anything. QUIC holds one connection open and takes the handshake out of every send. Both reach the same relay and the same staked connections.
HTTPS
simplestOne request, one receipt. Use a client with keep-alive so you are not paying for TCP and TLS on every send.
1const res = await fetch("https://send.swqos.com/v1/transactions", {2 method: "POST",3 headers: {4 Authorization: `Bearer ${process.env.SWQOS_API_KEY}`,5 "Content-Type": "application/json",6 },7 body: JSON.stringify({8 transaction: Buffer.from(tx.serialize()).toString("base64"),9 }),10});1112const { signature, charged_lamports } = await res.json();
QUIC
fastestConnect once at startup and hold it. Your identity is established at the handshake, so no send pays for authentication.
1import { Agent } from "undici";23// Node's QUIC support is still experimental, so the fastest reliable path from4// Node today is HTTP/1.1 with a warm keep-alive pool rather than raw QUIC. This5// removes the TCP and TLS handshake from every send, which is most of what the6// QUIC path buys you.7//8// If you want true QUIC from a JS runtime, run the Rust or Go client above as a9// sidecar and talk to it over a local socket.1011const agent = new Agent({12 keepAliveTimeout: 60_000,13 keepAliveMaxTimeout: 300_000,14 connections: 4, // a small warm pool, mirroring the QUIC guidance15 pipelining: 1,16});1718const API_KEY = process.env.SWQOS_API_KEY!;1920export async function send(tx: Uint8Array) {21 const res = await fetch("https://send.swqos.com/v1/transactions", {22 method: "POST",23 headers: {24 Authorization: `Bearer ${API_KEY}`,25 "Content-Type": "application/json",26 },27 body: JSON.stringify({28 transaction: Buffer.from(tx).toString("base64"),29 }),30 // @ts-expect-error undici dispatcher is not in the DOM fetch types31 dispatcher: agent,32 });3334 if (!res.ok) {35 const { error } = await res.json();36 throw new Error(`${error.code}: ${error.message}`);37 }38 return res.json();39}
| HTTPS | QUIC | |
|---|---|---|
| Setup cost | TCP and TLS per connection | one handshake, then nothing |
| Identity | bearer header on every request | client certificate, once at connect |
| Per send | an HTTP request | one bidirectional stream |
| Receipt | JSON response body | JSON on the stream |
| Best for | dropping into an existing service | latency-sensitive senders |
Node’s QUIC support is still experimental, so the TypeScript sample uses a warm keep-alive pool instead, which removes the same handshake cost. Full detail in send over QUIC.
Integrate in minutes.
Four languages, no SDK required.
It is one HTTP request. There is nothing to install, nothing to learn, and nothing to lock into. Every sample below is complete: set your key and run it.
- 01Build and sign with the library you already use.
- 02Base64 the serialized transaction and POST it, or write it to a QUIC stream.
- 03Read the receipt for the signature, the charge, and your remaining balance.
- 04Confirm landing yourself when you need certainty. We never guess for you.
1import {2 Connection, Keypair, SystemProgram,3 TransactionMessage, VersionedTransaction, PublicKey,4} from "@solana/web3.js";56const API_KEY = process.env.SWQOS_API_KEY!;7const payer = Keypair.fromSecretKey(8 Buffer.from(JSON.parse(process.env.PAYER_SECRET_KEY!)),9);1011// Any RPC will do. We only need a blockhash; we never send through it.12const rpc = new Connection("https://api.mainnet-beta.solana.com", "confirmed");13const { blockhash } = await rpc.getLatestBlockhash("confirmed");1415const message = new TransactionMessage({16 payerKey: payer.publicKey,17 recentBlockhash: blockhash,18 instructions: [19 SystemProgram.transfer({20 fromPubkey: payer.publicKey,21 toPubkey: new PublicKey("11111111111111111111111111111111"),22 lamports: 1,23 }),24 ],25}).compileToV0Message();2627const tx = new VersionedTransaction(message);28tx.sign([payer]);2930const res = await fetch("https://send.swqos.com/v1/transactions", {31 method: "POST",32 headers: {33 Authorization: `Bearer ${API_KEY}`,34 "Content-Type": "application/json",35 },36 body: JSON.stringify({37 transaction: Buffer.from(tx.serialize()).toString("base64"),38 }),39});4041if (!res.ok) {42 const { error } = await res.json();43 throw new Error(`${error.code}: ${error.message}`);44}4546const receipt = await res.json();47console.log(receipt.signature, receipt.charged_lamports);4849// The receipt means we forwarded it. Confirm landing separately.50const status = await rpc.getSignatureStatuses([receipt.signature]);51console.log(status.value[0]?.confirmationStatus ?? "not yet visible");
One price.
No plans, no minimums, no invoice.
0.0002 SOL per accepted send, deducted from a prepaid SOL balance. Balances are prepaid in native SOL. There is no card, no invoice and no subscription.
You are charged once a submission is accepted and forwarded. Refused submissions are free.
- top up
- any amount, any time
- payload cap
- 1232 bytes
- dedupe window
- 90 seconds
- transports
- QUIC and HTTPS
| Accepted and forwarded upstream | 0.0002 SOL |
| Duplicate signature within 90s | free |
| Invalid transaction envelope | free |
| Unknown or invalid API key | free |
| Account disabled | free |
| Insufficient balance | free |
| Forwarding failed upstream | charged, then reversed |
| Accepted but never lands on chain | 0.0002 SOL |
The last row is on this table on purpose. A transaction can be forwarded correctly and still not make it into a block, because inclusion is the network’s decision. You would find that out from an invoice eventually, so you may as well read it here first.
Questions.
Answered plainly.
swqos.com is a prepaid Solana transaction relay that forwards already-signed transactions to the leader over stake-weighted QoS connections. You send the serialized bytes over HTTPS or QUIC, and the relay writes them to a connection it already holds open. It costs 0.0002 SOL per accepted send with no subscription and no minimum.