Skip to main content

​
Landing Endpoint (TPU Forwarder)

Maximize transaction landing rates with direct TPU forwarding. Bypass the standard RPC relay path and send transactions directly to the current leader’s TPU port for the fastest possible inclusion.

​
Endpoint

https://land.vali.wtf
Drop-in replacement for sendTransaction — same JSON-RPC API, different routing under the hood.

​
How It Works

Standard path (via RPC): 
Your app → RPC node → Leader validator TPU
Landing Endpoint path: 
Your app → Landing Endpoint → Leader TPU (direct QUIC)
                             → Next leader TPU (pre-forward)
The Landing Endpoint:
  1. Receives your signed transaction
  2. Identifies the current and upcoming leaders from the schedule
  3. Opens stake-weighted QUIC connections to their TPU ports
  4. Forwards your transaction directly, bypassing the RPC relay
  5. Retries across leader rotations with intelligent backoff

​
Quick Start

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

// Use the landing endpoint for sendTransaction
const connection = new Connection('https://land.vali.wtf', {
  commitment: 'confirmed',
});

// Build your transaction as normal
const tx = new Transaction();
// ... add instructions ...

// Send via TPU forwarder
const signature = await connection.sendTransaction(tx, [payer], {
  skipPreflight: true,  // recommended for speed
  maxRetries: 0,        // landing endpoint handles retries
});

console.log('Sent via TPU:', signature);

​
cURL

curl https://land.vali.wtf -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "BASE64_ENCODED_TX",
      {
        "encoding": "base64",
        "skipPreflight": true,
        "maxRetries": 0
      }
    ]
  }'

​
Features

FeatureDescription
Direct TPUQUIC-based direct connection to leader TPU ports
Leader TrackingReal-time leader schedule monitoring for optimal routing
Multi-leaderForward to current and upcoming leaders simultaneously
Stake-weightedPrioritized connections via stake-weighted QUIC streams
Auto RetryIntelligent retry with backoff across leader rotations
Priority FeesAutomatic priority fee estimation and suggestion
ParameterValueWhy
skipPreflighttrueAvoids extra RPC round-trip for simulation
maxRetries0Landing endpoint handles retries internally
encodingbase64Slightly more compact than base58

​
Supported Methods

The Landing Endpoint only supports transaction submission:
MethodSupported
sendTransactionYes
All other methodsNo — use the standard RPC endpoint

​
Combining with RPC

A common pattern is to use the standard RPC for reads and the Landing Endpoint for writes: 
import { Connection } from '@solana/web3.js';

// Read connection (standard RPC)
const readConn = new Connection('https://rpc.vali.wtf');

// Write connection (landing endpoint)
const writeConn = new Connection('https://land.vali.wtf');

// Fetch data via RPC
const balance = await readConn.getBalance(pubkey);

// Submit transactions via Landing
const sig = await writeConn.sendTransaction(tx, [payer], {
  skipPreflight: true,
  maxRetries: 0,
});

​
TPU (Transaction Send)

TPU forwarding sends your signed transactions directly to the current and upcoming slot leaders over QUIC, bypassing the standard RPC sendTransaction path. 
Your signed transaction
        ↓
   Sent via QUIC to current + next leaders
        ↓
   Leaders include it in their block
Standard sendTransaction goes: your client → RPC node → RPC forwards to leader. TPU forwarding skips the middleman — your transaction goes straight to the leaders who are actually producing blocks.

​
Why It’s Faster

  • No RPC queue — RPC sendTransaction batches and retries on a timer (default 2s). TPU sends immediately.
  • Multi-leader fanout — sends to multiple upcoming leaders in parallel, increasing the chance of landing in the next slot.
  • QUIC priority — staked connections get priority in the leader’s QUIC listener. Higher stake = higher priority in the queue.

​
TPS (Transactions Per Second)

TPS refers to how many transactions your client can submit per second through the TPU path. This depends on:
  • Your QUIC connection quality to the leaders
  • Leader proximity — lower latency = transactions arrive in time for the current slot
  • Stake weight — staked validators get prioritized QUIC streams
  • Network congestion — during high-traffic periods, leaders drop lower-priority transactions
TPU forwarding doesn’t guarantee landing — it guarantees the fastest possible delivery to the leader. Landing depends on priority fees, compute budget, and leader queue depth.