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. Balance-funded sends are only paid when they land.
- Staked connections, held open and kept warm
- QUIC or plain HTTPS, whichever your stack prefers
- 0.00015 SOL for a default landed 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();
A diagram comparing two transaction paths. The typical RPC path passes through several hops with queueing at each before reaching the leader. The swqos.com path passes through one staked connection and arrives sooner.
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, reserve the price from 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 the signed bytes were accepted for forwarding. The transaction register separately reports whether they landed on chain.
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.00015 SOL for a default landed send. Pay from a prepaid balance or inside the signed transaction. Balances are prepaid in native SOL. There is no card, no invoice and no subscription.
Balance-funded sends are fully refunded when they do not land. An in-transaction SOL payment has no separate refund because the transfer only executes when the transaction executes.
- top up
- any amount, any time
- payload cap
- 1232 bytes
- dedupe window
- 90 seconds
- transports
- QUIC and HTTPS
| Accepted with prepaid balance | 0.00015 SOL reserved |
| Prepaid transaction lands | 0.00015 SOL settled |
| Prepaid transaction does not land | fully refunded |
| In-transaction SOL payment | executes with the transaction |
| In-transaction payment does not land | no transfer occurs |
| 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 |
Balance-funded transactions that do not land are fully refunded. An in-transaction SOL payment has no separate refund because the transfer itself only executes with the transaction.
Questions.
Answered plainly.
swqos.com forwards already-signed Solana transactions over stake-weighted QoS connections. A default landed send costs 0.00015 SOL, with no subscription or minimum. Balance-funded sends that do not land are fully refunded.