mainnet-beta······

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
TypeScript
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});
11
12const { signature, charged_lamports } = await res.json();
QUICsend.swqos.com:11000
typical RPC path
your app → RPC → queue → leader
swqos.com staked connection
your app → swqos.com → leader
fewer hops, no queue6.29 ms p50 relay overhead, measured on production traffic

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.

[01]

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])
[02]

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/transactions
[03]

You 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.

[01]

HTTPS

simplest

One request, one receipt. Use a client with keep-alive so you are not paying for TCP and TLS on every send.

TypeScript
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});
11
12const { signature, charged_lamports } = await res.json();
[02]

QUIC

fastest

Connect once at startup and hold it. Your identity is established at the handshake, so no send pays for authentication.

TypeScript
1import { Agent } from "undici";
2
3// Node's QUIC support is still experimental, so the fastest reliable path from
4// Node today is HTTP/1.1 with a warm keep-alive pool rather than raw QUIC. This
5// removes the TCP and TLS handshake from every send, which is most of what the
6// QUIC path buys you.
7//
8// If you want true QUIC from a JS runtime, run the Rust or Go client above as a
9// sidecar and talk to it over a local socket.
10
11const agent = new Agent({
12 keepAliveTimeout: 60_000,
13 keepAliveMaxTimeout: 300_000,
14 connections: 4, // a small warm pool, mirroring the QUIC guidance
15 pipelining: 1,
16});
17
18const API_KEY = process.env.SWQOS_API_KEY!;
19
20export 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 types
31 dispatcher: agent,
32 });
33
34 if (!res.ok) {
35 const { error } = await res.json();
36 throw new Error(`${error.code}: ${error.message}`);
37 }
38 return res.json();
39}
HTTPS compared with QUIC
HTTPSQUIC
Setup costTCP and TLS per connectionone handshake, then nothing
Identitybearer header on every requestclient certificate, once at connect
Per sendan HTTP requestone bidirectional stream
ReceiptJSON response bodyJSON on the stream
Best fordropping into an existing servicelatency-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.

  1. 01Build and sign with the library you already use.
  2. 02Base64 the serialized transaction and POST it, or write it to a QUIC stream.
  3. 03Read the receipt for the signature, the charge, and your remaining balance.
  4. 04Confirm landing yourself when you need certainty. We never guess for you.
Full quickstart
send.ts
1import {
2 Connection, Keypair, SystemProgram,
3 TransactionMessage, VersionedTransaction, PublicKey,
4} from "@solana/web3.js";
5
6const API_KEY = process.env.SWQOS_API_KEY!;
7const payer = Keypair.fromSecretKey(
8 Buffer.from(JSON.parse(process.env.PAYER_SECRET_KEY!)),
9);
10
11// 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");
14
15const 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();
26
27const tx = new VersionedTransaction(message);
28tx.sign([payer]);
29
30const 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});
40
41if (!res.ok) {
42 const { error } = await res.json();
43 throw new Error(`${error.code}: ${error.message}`);
44}
45
46const receipt = await res.json();
47console.log(receipt.signature, receipt.charged_lamports);
48
49// 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.

per accepted send
0.0002SOL

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
Get an API key
exactly what you are charged for
Billing boundary by submission outcome
Accepted and forwarded upstream0.0002 SOL
Duplicate signature within 90sfree
Invalid transaction envelopefree
Unknown or invalid API keyfree
Account disabledfree
Insufficient balancefree
Forwarding failed upstreamcharged, then reversed
Accepted but never lands on chain0.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.

Longer answers in the docs
  • 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.

Start sending in ten minutes.
Fund it with SOL, keep the change.