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. 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
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 queueone hop from our relay to the leader

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.

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

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

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

default landed send
0.00015SOL

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
Get an API key
exactly what you are charged for
Billing boundary by submission outcome
Accepted with prepaid balance0.00015 SOL reserved
Prepaid transaction lands0.00015 SOL settled
Prepaid transaction does not landfully refunded
In-transaction SOL paymentexecutes with the transaction
In-transaction payment does not landno transfer occurs
Duplicate signature within 90sfree
Invalid transaction envelopefree
Unknown or invalid API keyfree
Account disabledfree
Insufficient balancefree
Forwarding failed upstreamcharged, 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.

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

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