SWQOS Quickstart

⚡ Integrate with AI

I'm integrating Blockspace SWQOS to improve transaction landing rates on Solana.

Product: Blockspace SWQOS — stake-weighted priority transaction routing through Everstake validators. Two submission paths.

Path 1 — HTTP (easiest to integrate):
- No API key or auth. Public endpoint.
- Every transaction MUST include a tip-transfer: SystemProgram::transfer paying ≥1,000,000 lamports to a designated Everstake tip account.
- Tip account list: https://github.com/everstake/everstake-swqos-docs
- The HTTP endpoint only accepts sendTransaction — no read methods. Fetch blockhash from a separate standard Solana RPC.
- Endpoints (6 regions): fra-swqos.everstake.com / ams-swqos.everstake.com / ny-swqos.everstake.com / tyo-swqos.everstake.com / lon-swqos.everstake.com / sgp-swqos.everstake.com / main-swqos.everstake.one (anycast)

Path 2 — QUIC (lower latency, custom client):
- Auth: signing-keypair allowlist. Generate a dedicated Solana keypair, add pubkey in dashboard → SWQOS → QUIC pubkeys.
- To connect: log in to your Blockspace account, purchase a subscription or activate a trial, then add your QUIC pubkey to the desired location in the dashboard.
- 7 locations available: Frankfurt, Amsterdam, New York, Tokyo, London, Singapore, Dublin.
- Tip is still required in every transaction.
- Reference QUIC client: https://github.com/everstake/everstake-swqos-docs

Important: SWQOS doesn't replace standard priority fees. No preflight — invalid txs are silently dropped at the validator. This is a landing probability boost, not a guarantee.
Full reference: https://docs.blockspace.everstake.com/llms-full.txt

My stack: [ADAPT: Rust / TypeScript — pick one and tell me which].
Generate a minimal HTTP-path example that: fetches a recent blockhash from mainnet-beta, builds a transaction with a tip-transfer instruction + a placeholder business instruction, and submits it to the Frankfurt SWQOS endpoint. Then explain what I need to change to switch to QUIC.

Open in Claude →Open in ChatGPT →Open in Perplexity →

SWQOS has two submission paths. Pick one — they have different setup requirements.

Path 1 — HTTP / RPC (no auth, fastest to integrate)

The HTTP path is a public endpoint. You don't need an API key, you don't whitelist anything. The only thing it cares about: each transaction must include a tip-transfer instruction.

1. Build a transaction with a tip-transfer

Add a SystemProgram::transfer instruction paying ≥1,000,000 lamports to a designated Everstake tip account. Without it, SWQOS doesn't prioritize the tx.

The list of valid tip accounts is published in the open-source SWQOS docs at github.com/everstake/everstake-swqos-docs.

Pick a tip account at random on every transaction — rotating across the published accounts avoids write-lock contention on any single one. Reference the tip account directly in the transfer; adding it to an Address Lookup Table (ALT) instead risks the tip going unrecognized. The tip is what buys priority inclusion: multi-path fanout to upcoming leaders and a stake-weighted priority boost. Skip it and the transaction rides a single SWQOS path with no boost.

2. Fetch a recent blockhash

The SWQOS HTTP endpoint only accepts sendTransaction — no read methods, no preflight. Fetch your blockhash from any standard Solana RPC (your own RPC, public mainnet, etc.).

3. Submit via sendTransaction

Rust

use solana_client::rpc_client::RpcClient;
use solana_sdk::{
    commitment_config::CommitmentConfig,
    instruction::Instruction,
    pubkey::Pubkey,
    signature::Keypair,
    signer::Signer,
    system_instruction,
    transaction::Transaction,
};

// 1. Fetch blockhash from any standard RPC (NOT the SWQOS endpoint)
let rpc = RpcClient::new_with_commitment(
    "https://api.mainnet-beta.solana.com".to_string(),
    CommitmentConfig::confirmed(),
);
let blockhash = rpc.get_latest_blockhash()?;

// 2. Build transaction with tip-transfer + your business logic instruction
let tip_account: Pubkey = "<EVERSTAKE_TIP_ACCOUNT_PUBKEY>".parse()?;
let tip_ix = system_instruction::transfer(&payer.pubkey(), &tip_account, 1_000_000);
let business_ix: Instruction = /* your logic here */;

let tx = Transaction::new_signed_with_payer(
    &[tip_ix, business_ix],
    Some(&payer.pubkey()),
    &[&payer],
    blockhash,
);

// 3. Submit to SWQOS HTTP endpoint
let swqos = RpcClient::new("https://fra-swqos.everstake.com".to_string());
let sig = swqos.send_transaction(&tx)?;
println!("Submitted: {}", sig);

JavaScript

import {
  Connection, Keypair, PublicKey, SystemProgram, Transaction
} from '@solana/web3.js';

// 1. Use a standard RPC for blockhash
const rpc = new Connection('https://api.mainnet-beta.solana.com', 'confirmed');
const { blockhash } = await rpc.getLatestBlockhash();

// 2. Build tx with tip + business instruction
const tipAccount = new PublicKey('<EVERSTAKE_TIP_ACCOUNT_PUBKEY>');
const tx = new Transaction({ recentBlockhash: blockhash, feePayer: payer.publicKey });
tx.add(SystemProgram.transfer({
  fromPubkey: payer.publicKey,
  toPubkey: tipAccount,
  lamports: 1_000_000,
}));
// tx.add(yourBusinessInstruction)
tx.sign(payer);

// 3. Submit to SWQOS HTTP endpoint
const swqos = new Connection('https://fra-swqos.everstake.com');
const sig = await swqos.sendRawTransaction(tx.serialize());
console.log('Submitted:', sig);

Endpoints

Pick the region closest to your bot:

https://fra-swqos.everstake.com    # Frankfurt
https://ams-swqos.everstake.com    # Amsterdam
https://ny-swqos.everstake.com     # New York
https://tyo-swqos.everstake.com    # Tokyo
https://lon-swqos.everstake.com    # London
https://sgp-swqos.everstake.com    # Singapore
https://main-swqos.everstake.one   # Cloudflare anycast (region routes automatically)

For lowest latency, use HTTP/2 with prior knowledge (h2c) over plain http://. HTTPS works too, just adds TLS handshake.

Path 2 — QUIC (lowest latency, custom client)

QUIC requires a pubkey-authenticated connection and a custom client implementation. Solana SDK doesn't speak this protocol.

1. Whitelist your QUIC pubkey

Generate a Solana keypair you'll use only for QUIC authentication (not necessarily the same one that signs your transactions):

solana-keygen new --no-passphrase --outfile ~/.config/solana/swqos-quic.json
solana-keygen pubkey ~/.config/solana/swqos-quic.json

In the dashboard → SWQOS → QUIC pubkeys, add the pubkey from above. Save.

Whitelist edits propagate within ~30 seconds.

2. Connect to a QUIC endpoint

To get access to the QUIC endpoints, log in to your Blockspace account, purchase a subscription or activate a trial, then add your QUIC pubkey to the desired location in the dashboard under SWQOS → QUIC pubkeys.

We have 7 locations available:

• Frankfurt
• Amsterdam
• New York
• Tokyo
• London
• Singapore
• Dublin

The QUIC handshake is authenticated by the keypair you whitelisted. There's no separate API key.

3. Send a raw serialized transaction

The transaction itself still must include the tip-transfer instruction (≥1,000,000 lamports to an Everstake tip account). Serialize the signed transaction and write its bytes to a QUIC stream.

The reference open-source implementation lives at github.com/everstake/everstake-swqos-docs — see the example Rust binary that does the QUIC handshake and submits.

Common to both paths

• Tip is required on every transaction (≥1,000,000 lamports). Reference the tip account as a static key — never through an ALT.
• Want a reconciliation trail? Attach an optional Memo instruction; it's recorded permanently on-chain.
• Neither flow needs an API key.
• SWQOS runs no preflight checks — invalid transactions get dropped silently at the validator.
• Priority fees still apply: set them on your transaction as usual, since SWQOS layers on top rather than replacing them.
• Standard transaction lifecycle otherwise — SWQOS raises the odds of inclusion, it doesn't skip block production.

Next

• API Reference — endpoint list, tip-account source, rate limits.
• Pricing & Limits covers the tiers.