1 of 21

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

Algorithmic traders: Get predictability with your bots in all market conditions.

Tipping & FAQ

Transaction Tip

Each transaction must include a system transfer instruction to the Nozomi tip address, with a minimum tip of 0.001 SOL. Increasing the tip raises your transaction’s priority in the queue—higher tips settle faster.

These tips compensate the Jito tip and pay validators for staked connections. If Jito validates the transaction, the tip goes to the Jito validator. In that case, Nozomi forwards the entire tip to Jito.

Here is a breakdown of tips by percentile.

Nozomi Tip Addresses

Send your tip to any one of these 17 addresses. To optimize performance and avoid write CU exhaustion, use a random different address for each transaction.

Priority Fee

Nozomi gets your transaction to the scheduler. At this point, priority fees matter. It is recommended to set CU price to at least 1,000,000 lamports, or expect subpar performance.

Retries

Nozomi will retry transactions until confirmation or expiry. Nozomi will prioritize retries based on the amount tipped.

Rate Limits

Each API key has an associated rate limit.

QoS Priority

Clients with high failure rate will have a QoS penalty to their priority. For example if only 10% of your transactions successfully land, your priority will be discounted to 10%. This is based on last 30 minutes of transaction sending.

Optimized Routing

What makes Nozomi unique is how it routes transactions through the TPU. It knows exactly when and how to send transactions.

Nozomi does not simulate transactions.

Avoiding Front-Running

There is Front Running Protection URL that only sends through a custom whitelist of trusted validators (Helius, Coinbase, etc.) .

Set strict slippage tolerances and calculate minAmountOut to have protections against front-running.

Customizability

Only pay the tip if you execute your desired opportunity. Since the tip is a transfer, if you detect someone captured the opportunity you wanted, you can fail your transaction to avoid paying the tip.

If you are a high tipper, please reach out for custom rate limits.

Contact

Reach out via Telegram: @ h3ll0wrld

Transaction Submission (JSON-RPC)

Nozomi sends transactions through multiple channels to achieve best performance.

sendTransaction

The Nozomi transaction submission endpoint supports the `sendTransaction` Solana JSON-RPC method. Just insert the URL where you would place a RPC URL.

Transactions are sent through 1) Self hosted nodes 2) Staked connections and 3) Jito bundles.

Auto Routed Endpoint

https://nozomi.temporal.xyz/?c=

Regioned Endpoints

Direct HTTP:

PITT:

TYO:

SGP:

EWR:

AMS:

FRA:

Secure HTTPS:

PITT:

TYO:

SGP:

EWR:

AMS:

FRA:

HTTP POST Body

Just add API Key after ?c=<uuid> to get custom URL for sending.

Regional submission endpoints are in US East, Frankfurt, Amsterdam, Singapore and Tokyo.

All boxes are run with custom hardware modifications.

Please specify base64 encoding.

Rust

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

use solana_client::rpc_client::RpcClient;
use solana_sdk::{message::Instruction, pubkey, pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};

const NOZOMI_ENDPOINT: &str = "https://nozomi.temporal.xyz/?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_rpc_client: &RpcClient, solana_rpc_client: &RpcClient) {
    let tip_ix = solana_system_interface::instruction::transfer(&signer.pubkey(), &NOZOMI_TIP, MIN_TIP_AMOUNT);
    ixns.push(tip_ix);

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

    nozomi_rpc_client.send_transaction(&tx).unwrap();
}

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

fn main() {
    let nozomi_rpc_client = RpcClient::new(NOZOMI_ENDPOINT.to_string());

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

    let keypair = Keypair::new();

    let mut ixns = build_ixns();

    send_nozomi_txn(&mut ixns, &keypair, &nozomi_rpc_client, &solana_rpc_client);
}

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.

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

const NOZOMI_ENDPOINT = "https://nozomi.temporal.xyz/?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, nozomiRpcClient: Connection, solanaRpcClient: Connection): Promise<TransactionSignature> {
    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]);

    return await nozomiRpcClient.sendTransaction(versionedTxn);
}

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

async function main() {
    const nozomiRpcClient = new Connection(NOZOMI_ENDPOINT);

    const solanaRpcClient = new Connection(SOLANA_RPC_ENDPOINT);

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

    const ixns = buildIxns();

    const signature = await sendNozomiTxn(ixns, signer, nozomiRpcClient, solanaRpcClient);

    console.log(`Transaction sent with signature: ${signature}`);
}

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

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"
      }
    ]
  }'

Jupiter Swap Example

Github URL for Jupiter Swap Transactions.

https://github.com/temporalxyz/nozomi-examples/blob/main/typescript/jup-swap-example/jup-json-rpc.ts

Go

Made by a wonderful community member.

https://github.com/weeaa/tempgoral

Transaction Submission (API v2)

Nozomi sends transactions through multiple channels to achieve best performance.

sendTransaction2

The /api/sendTransaction2 endpoint is not compatible with the Solana JSON-RPC sendTransaction method. Requests sent via the /api/sendTransaction2 endpoint from browser clients will see better performance, as this endpoint will skip the OPTIONS preflight request triggered by normal Solana JSON-RPC methods.

The /api/sendTransaction2

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.

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>'

Jupiter Swap Example

Github URL for Jupiter Swap Transactions.

Go

Use full service RPC for fetching latest blockhash.

Tip Stream

Stream Nozomi Tip Floors by Percentile

Rest Endpoint

Websocket

Keeping Your TCP Connection Alive

🔄 How Do I Keep the Connection Alive?

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

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())

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

Tipping & FAQ

Transaction Tip

Nozomi Tip Addresses

Priority Fee

Retries

Rate Limits

QoS Priority

Optimized Routing

Avoiding Front-Running

Customizability

Contact

Transaction Submission (JSON-RPC)

sendTransaction

Auto Routed Endpoint

Regioned Endpoints

Direct HTTP:

Secure HTTPS:

Rust

Python

JavaScript

TypeScript

CURL

Jupiter Swap Example

Go

Transaction Submission (API v2)

sendTransaction2

Rust

Python

JavaScript

TypeScript

CURL

Jupiter Swap Example

Go

Tip Stream

Rest Endpoint

Websocket

Keeping Your TCP Connection Alive

🔄 How Do I Keep the Connection Alive?

CURL

Tipping & FAQ

Transaction Tip

Nozomi Tip Addresses

Priority Fee

Retries

Rate Limits

QoS Priority

Optimized Routing

Avoiding Front-Running

Customizability

Contact

TypeScript

JavaScript

Go

Jupiter Swap Example

Rust

Transaction Submission (JSON-RPC)

sendTransaction

Auto Routed Endpoint

Regioned Endpoints

Direct HTTP:

Secure HTTPS:

Python

Tip Stream

Rest Endpoint

Websocket

Python

Transaction Submission (API v2)

sendTransaction2

Keeping Your TCP Connection Alive

🔄 How Do I Keep the Connection Alive?

Jupiter Swap Example

Benefits

How to Use

Endpoints (Regions)

TypeScript

Rust