1 of 22

Temporal Docs

Nozomi

Introduction

Land transactions faster and more consistently.

Nozomi is a fully custom proprietary client written by HPC and HFT engineers designed to land transactions as fast as possible.

Who Should Use It

Sniper Bots — Snipe tokens and mints before the competition.
DeFi Apps — Create a better UX so user transactions do not stall or fail.
Traders — Land with speed and precision to capture the most opportunities.
Liquidators — Be first to a liquidation transaction.
Jito Bundle Users — Get through the block engine faster and more efficiently.
Algorithmic Traders — Get predictability with your bots in all market conditions.

Nozomi is available to approved users.

Regions & Endpoints

Regional endpoint URLs for all Nozomi APIs.

All requests require your API key passed as a query parameter:

Don't have an API key yet?

Method

Path

Response

Tipping

Every Nozomi transaction must include a tip — a standard Solana system transfer instruction to one of the Nozomi tip addresses. The minimum tip is 0.001 SOL.

You only pay when your transaction lands. The tip is an instruction inside your transaction, so if the transaction fails, the tip is never charged. This means you can intentionally fail a transaction if, for example, you detect that someone else already captured the opportunity you were targeting.

Delivery path

What happens

JSON-RPC

Standard Solana JSON-RPC transaction submission through Nozomi.

The standard way to send transactions through Nozomi. Compatible with any Solana client — just replace your RPC URL with the Nozomi endpoint.

Field

Value

Rust

Use full service RPC for fetching latest blockhash. Nozomi only supports sendTransaction.

Python

Use full service RPC for fetching latest blockhash.. Nozomi only supports sendTransaction.

JavaScript

Use full service RPC for fetching latest blockhash. Nozomi only supports sendTransaction.

TypeScript

Use full service RPC for fetching latest blockhash. Nozomi only supports sendTransaction.

cURL

Please specify base64 encoding, Solana recognizes base58 as default. If you do not specify, you might get malformed transaction error

curl https://nozomi.temporal.xyz/?c=<YOUR_API_KEY> \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "<YOUR_BASE_64_ENCODED_TXN_BYTES>",
      {
        "encoding": "base64"
      }
    ]
  }'

API v2

High-performance transaction submission with reduced overhead.

A faster alternative to JSON-RPC that eliminates JSON parsing overhead and CORS preflight latency. Recommended for browser clients and performance-sensitive backends.

Field

Value

Rust

Use full service RPC for fetching latest blockhash.


use solana_client::rpc_client::RpcClient;
use solana_sdk::{message::Instruction, pubkey, pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
use base64::{Engine as _, engine::general_purpose};

const NOZOMI_ENDPOINT: &str = "https://nozomi.temporal.xyz/api/sendTransaction2?c=<YOUR_API_KEY>";
const NOZOMI_TIP: Pubkey = pubkey!("TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq");
const MIN_TIP_AMOUNT: u64 = 1_000_000;

const SOLANA_RPC_ENDPOINT: &str = "https://api.mainnet-beta.solana.com";

fn send_nozomi_txn(
    ixns: &mut Vec<Instruction>,
    signer: &Keypair,
    nozomi_endpoint: &str,
    solana_rpc_client: &RpcClient
) -> Result<(), Box<dyn std::error::Error>> {
    let tip_ixn = solana_system_interface::instruction::transfer(
        &signer.pubkey(),
        &NOZOMI_TIP,
        MIN_TIP_AMOUNT
    );
    ixns.push(tip_ixn);

    let blockhash = solana_rpc_client.get_latest_blockhash()?;
    let txn = Transaction::new_signed_with_payer(
        ixns,
        Some(&signer.pubkey()),
        &[signer],
        blockhash
    );

    let txn_bytes = bincode::serialize(&txn)?;

    let txn_base64 = general_purpose::STANDARD.encode(&txn_bytes);

    let client = reqwest::blocking::Client::new();
    let response = client
        .post(nozomi_endpoint)
        .header("Content-Type", "text/plain")
        .body(txn_base64)
        .send()?;

    // api v2 does not return a signature, just check for success
    if response.status().is_success() {
        Ok(())
    } else {
        Err(Box::new(response.error_for_status().unwrap_err()))
    }
}

fn build_ixns() -> Vec<Instruction> {
    // your instruction building logic here..
    vec![]
}

fn main() {
    let solana_rpc_client = RpcClient::new(SOLANA_RPC_ENDPOINT.to_string());

    // replace with actual keypair loading logic
    let signer = Keypair::new();

    let mut ixns = build_ixns();

    if send_nozomi_txn(
        &mut ixns,
        &signer,
        NOZOMI_ENDPOINT,
        &solana_rpc_client
    ).is_ok() {
        println!("Transaction sent successfully");
    }
}

Python

Use full service RPC for fetching latest blockhash.

import aiohttp
import asyncio
import base64

from typing import List

from solders.pubkey import Pubkey
from solders.keypair import Keypair
from solders.instruction import Instruction
from solders.transaction import Transaction
from solders.system_program import transfer, TransferParams
from solders.hash import Hash

from solana.rpc.async_api import AsyncClient

NOZOMI_ENDPOINT = "https://nozomi.temporal.xyz/api/sendTransaction2?c=<YOUR_API_KEY>"
NOZOMI_TIP = Pubkey.from_string("TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq")
MIN_TIP_AMOUNT = 1_000_000

SOLANA_RPC_ENDPOINT = "https://api.mainnet-beta.solana.com"

async def send_nozomi_txn(
    ixns: List[Instruction],
    signer: Keypair,
    nozomi_endpoint: str,
    solana_rpc_client: AsyncClient
) -> None:
    tip_ixn = transfer(TransferParams(
        from_pubkey=signer.pubkey(),
        to_pubkey=NOZOMI_TIP,
        lamports=MIN_TIP_AMOUNT
    ))
    ixns.append(tip_ixn)

    blockhash_resp = await solana_rpc_client.get_latest_blockhash()
    blockhash = blockhash_resp.value.blockhash

    txn = Transaction.new_signed_with_payer(
        ixns,
        signer.pubkey(),
        [signer],
        blockhash
    )

    txn_bytes = bytes(txn)
    txn_base64 = base64.b64encode(txn_bytes).decode('utf-8')

    async with aiohttp.ClientSession() as session:
        async with session.post(
            nozomi_endpoint,
            headers={"Content-Type": "text/plain"},
            data=txn_base64
        ) as response:
            # api v2 does not return a signature, just check for success
            if response.status >= 200 and response.status < 300:
                print("Transaction sent successfully")
            else:
                error_text = await response.text()
                raise Exception(f"Transaction failed with status {response.status}: {error_text}")

def build_ixns() -> List[Instruction]:
    # your instruction building logic here..
    return []

async def main():
    solana_rpc_client = AsyncClient(SOLANA_RPC_ENDPOINT)

    # replace with actual keypair loading logic
    signer = Keypair()

    ixns = build_ixns()

    await send_nozomi_txn(ixns, signer, NOZOMI_ENDPOINT, solana_rpc_client)

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

Use full service RPC for fetching latest blockhash.

TypeScript

Use full service RPC for fetching latest blockhash.

import { Connection, PublicKey, Keypair, TransactionInstruction, SystemProgram, TransactionMessage, VersionedTransaction } from "@solana/web3.js";

const NOZOMI_ENDPOINT = "https://nozomi.temporal.xyz/api/sendTransaction2?c=<YOUR_API_KEY>";
const NOZOMI_TIP = new PublicKey("TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq");
const MIN_TIP_AMOUNT = 1_000_000;

const SOLANA_RPC_ENDPOINT = "https://api.mainnet-beta.solana.com";

async function sendNozomiTxn(
    ixns: TransactionInstruction[],
    signer: Keypair,
    nozomiEndpoint: string,
    solanaRpcClient: Connection
): Promise<void> {
    const tipIxn = SystemProgram.transfer({
        fromPubkey: signer.publicKey,
        toPubkey: NOZOMI_TIP,
        lamports: MIN_TIP_AMOUNT
    });
    ixns.push(tipIxn);

    const { blockhash } = await solanaRpcClient.getLatestBlockhash();

    const messageV0 = new TransactionMessage({
        payerKey: signer.publicKey,
        recentBlockhash: blockhash,
        instructions: ixns,
    }).compileToV0Message();

    const versionedTxn = new VersionedTransaction(messageV0);
    versionedTxn.sign([signer]);

    const txnBytes = versionedTxn.serialize();
    const txnBase64 = Buffer.from(txnBytes).toString('base64');

    const response = await fetch(nozomiEndpoint, {
        method: 'POST',
        headers: {
            'Content-Type': 'text/plain',
        },
        body: txnBase64
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Transaction failed with status ${response.status}: ${errorText}`);
    }

    // api v2 does not return a signature, just check for success
    console.log('Transaction sent successfully');
}

function buildIxns(): TransactionInstruction[] {
    // your instruction building logic here..
    return [];
}

async function main() {
    const solanaRpcClient = new Connection(SOLANA_RPC_ENDPOINT);

    // replace with actual keypair loading logic
    const signer = Keypair.generate();

    const ixns = buildIxns();

    await sendNozomiTxn(ixns, signer, NOZOMI_ENDPOINT, solanaRpcClient);
}

main().catch(err => {
    console.error(err);
});

cURL

curl https://nozomi.temporal.xyz/api/sendTransaction2?c=<YOUR_API_KEY> \
  -X POST \
  -H "Content-Type: text/plain" \
  -d '<YOUR_BASE_64_ENCODED_TXN_BYTES>'

Batch Send

Submit multiple raw Solana transactions in a single request using a compact binary format. Reduces per-request overhead when you have multiple transactions ready to send.

Field

Value

JavaScript

cURL

Tip Stream

Stream Nozomi Tip Floors by Percentile

TCP Keep-Alive

How Do I Keep the Connection Alive?

To keep your TCP connection to our server alive and avoid reconnecting, periodically send a request to the /ping endpoint.

Strategy

The server supports persistent connections with a keep-alive timeout of 65 seconds. This means:

If your connection is idle for more than 65 seconds, it will be closed.
To keep it open, send any request before that timeout expires.
Each connection can send a maximum of 1000 requests.

We recommend using the /ping endpoint:

GET /ping

This endpoint is lightweight, fast, and designed specifically to maintain your connection.

Send a request to /ping every 60 seconds to keep the connection alive reliably.

This is not a health check — it's just a way to prevent idle disconnects.
Avoid pinging more often than needed.

FAQ

Nozomi is available to approved users.

Each API key has an associated rate limit. Rate limits are applied per region — sending the same transaction to multiple regions does not count against your limit.

If your transactions have a high failure rate, Nozomi applies a QoS penalty to your priority. For example, if only 10% of your transactions land successfully over the last 30 minutes, your effective priority is discounted to 10%.

To maintain high QoS priority:

Check account state before submitting to avoid predictable failures.

import { Connection, PublicKey, Keypair, SystemProgram, TransactionMessage, VersionedTransaction } from "@solana/web3.js"; const NOZOMI_ENDPOINT = "https://nozomi.temporal.xyz/api/sendTransaction2?c=<YOUR_API_KEY>"; const NOZOMI_TIP = new PublicKey("TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq"); const MIN_TIP_AMOUNT = 1_000_000; const SOLANA_RPC_ENDPOINT = "https://api.mainnet-beta.solana.com"; async function sendNozomiTxn(ixns, signer, nozomiEndpoint, solanaRpcClient) { const tipIxn = SystemProgram.transfer({ fromPubkey: signer.publicKey, toPubkey: NOZOMI_TIP, lamports: MIN_TIP_AMOUNT }); ixns.push(tipIxn); const { blockhash } = await solanaRpcClient.getLatestBlockhash(); const messageV0 = new TransactionMessage({ payerKey: signer.publicKey, recentBlockhash: blockhash, instructions: ixns, }).compileToV0Message(); const versionedTxn = new VersionedTransaction(messageV0); versionedTxn.sign([signer]); const txnBytes = versionedTxn.serialize(); const txnBase64 = Buffer.from(txnBytes).toString('base64'); const response = await fetch(nozomiEndpoint, { method: 'POST', headers: { 'Content-Type': 'text/plain', }, body: txnBase64 }); if (!response.ok) { const errorText = await response.text(); throw new Error(`Transaction failed with status ${response.status}: ${errorText}`); } // api v2 does not return a signature, just check for success console.log('Transaction sent successfully'); } function buildIxns() { // your instruction building logic here.. return []; } async function main() { const solanaRpcClient = new Connection(SOLANA_RPC_ENDPOINT); // replace with actual keypair loading logic const signer = Keypair.generate(); const ixns = buildIxns(); await sendNozomiTxn(ixns, signer, NOZOMI_ENDPOINT, solanaRpcClient); } main().catch(err => { console.error(err); });

Temporal Docs

Nozomi

Introduction

Who Should Use It

Regions & Endpoints

Tipping

JSON-RPC

Rust

Python

JavaScript

TypeScript

cURL

API v2

Rust

Python

JavaScript

TypeScript

cURL

Batch Send

JavaScript

cURL

Tip Stream

TCP Keep-Alive

How Do I Keep the Connection Alive?

Strategy

FAQ

Introduction

Who Should Use It

Regions & Endpoints

Tipping

JSON-RPC

Rust

Python

JavaScript

TypeScript

API v2

Get Access

Python

Rust

Request

Request Body

Response

When to Use

Authentication

API Paths

Base URLs

Regional Endpoints

Direct vs Cloudflare

Best Practices

Send to multiple regions

Frontend clients

Overview

How Tips Are Used

Tip Priority

Compute Unit Price

Retries

Tip Addresses

Private Tip Addresses

Front-Running Protection

Request

Response

Why Use API v2

When to Use

cURL

FAQ

JavaScript

cURL

Tip Stream

How do I get access?

Rate Limits

QoS Priority

Custom Limits

Does Nozomi Simulate Transactions?

REST Endpoint

WebSocket

Schema

TypeScript

TCP Keep-Alive

How Do I Keep the Connection Alive?

Strategy