❓ Frequently Asked Questions

Here’s some helpful information to get you started.

What is PumpApi?

PumpApi is a fast Pump.fun API for building trading bots, token launchers, market monitors, analytics tools, and backtesting systems. It also supports trading and real-time data across PumpSwap, Raydium, and Meteora through the same API.

How is PumpApi better than other Pump.fun APIs?

PumpApi is designed to make Solana trading faster, simpler, and more affordable:

• Faster transactions and data delivery: PumpApi is optimized for both low-latency transaction submission and real-time Data Stream delivery.
• Only 0.25% trading fees: PumpApi charges 0.25% of trade volume, while competing APIs may charge up to 1%.
• 100% landing rate: PumpApi Lightning transactions provide a 100% landing rate, compared with rates of around 80% on some competing APIs.
• More than Pump.fun: One API supports Pump.fun, PumpSwap, Raydium, and Meteora, plus real-time streaming of native Solana and token transfers.
• FREE Historical Replay: Use our completely free Historical Replay to backtest strategies and replay previous market conditions.
• FREE real-time data: The Data Stream is completely free.
• No sign-up required: PumpApi works without an account or API key.
• Cleaner bot code: Lightning mode handles transaction building, signing, and sending, keeping your integration as short and simple as possible.
• Solana and token transfer streaming: The Data Stream includes real-time native SOL and token transfers.

We want PumpApi to be the Apple of the Solana world. Every detail is designed to be as simple, polished, and convenient as possible for our users. With PumpApi, your code stays clean and minimal while your bot competes at maximum speed.

I am not a programmer. How can I create a Pump.fun trading bot?

We offer two options:

1. The easiest option: PumpApi Agent. You pay for your AI agent's server and AI usage, then simply describe the bot you want. PumpApi Agent has preinstalled PumpApi skills that help it build the bot, run it on the remote server, and assist you with future changes. It is a modified version of Hermes Agent designed to make PumpApi automation accessible to non-programmers.
2. Run a coding agent yourself. Install Claude Code, Codex, or Hermes Agent on your computer or server. Give it the complete PumpApi documentation, then describe the bot you want it to build. For the simplest AI-generated implementation, ask it to use Lightning mode: the transaction workflow and resulting code are shorter, so the coding agent has less complexity to handle.

Is PumpApi fast?

Yes. PumpApi is built for low-latency Solana trading and real-time data delivery. Our servers are located in Frankfurt am Main, Germany, close to major Solana validator and RPC infrastructure. We also use multiple optimizations to build, deliver, and send your transactions as quickly as possible.

For the lowest possible latency, we recommend hosting your trading bot or server in or near Frankfurt.

Do I need an API key or an account to use PumpApi?

No. You do not need an API key, account, or sign-up to use PumpApi. You can connect to the Data Stream and start using the Trade API without creating an account.

Can I build a pump.fun trading bot with PumpApi?

Yes. PumpApi provides the real-time events and transaction API needed to build automated pump.fun trading bots, sniper bots, copy-trading tools, token launchers, wallet monitors, and analytics dashboards.

PumpApi also supports PumpSwap, Raydium, and Meteora, so the same bot can work across multiple Solana platforms through one API.

Should I build my own Pump.fun trading and Data Stream parser?

No. A complete custom implementation can take months of work and will still be slower than using PumpApi.

PumpApi handles a large amount of internal complexity for you. We understand the common requirements of Pump.fun bot developers and already handle problems such as incorrect event parsing, high latency, transactions that fail to land, program-specific errors, and changes to the underlying Solana programs. We monitor program updates so you do not have to continually update your own parser and transaction implementation.

Most of the infrastructure your bot needs is already available through PumpApi. Copy the complete PumpApi documentation into your coding AI and describe what you want it to build. For the shortest and simplest implementation, ask it to use Lightning mode.

It’s much easier to ask us to add a feature you need than to try to build it yourself.

How much does PumpApi cost?

The Data Stream and Historical Replay are FREE. Buy and sell transactions through the Trade API cost 0.25% of trade volume. See the Fees page for the current fees for all other operations.

What is the difference between Lightning and Local transactions?

With Lightning transactions, PumpApi builds, signs, and sends the transaction directly to Solana for you. Lightning mode requires you to provide the private key or apiKey of the dedicated trading wallet used by your bot. In return, PumpApi can handle the complete transaction flow, achieve maximum speed and a 100% landing rate, and keep your bot code clean and as short as possible. We recommend Lightning mode because it is the fastest and simplest option to integrate.

With Local transactions, PumpApi builds the transaction and returns it to your application. Local mode is slower because your application must sign and send the transaction itself, but you do not need to send your private key to PumpApi. Your private key stays in your own application, giving you full control over signing and RPC delivery. Usually this method is used by Web app builders - your users sign transactions themselves via wallet extensions (Phantom, Solflare, Backpack…). Request an unsigned transaction from us with the user's publicKey, pass it to the wallet extension for signing, then broadcast it.

Local transaction flow:

Your bot → PumpApi → Your bot receives an unsigned transaction → Solana (your bot signs and sends it through your RPC)

Lightning transaction flow:

Your bot → PumpApi → Solana

Do I need to send my private key to PumpApi?

Not when using Local transactions. Your application sends only the public key to PumpApi, receives the prepared transaction, and signs it locally. Your private key remains in your own application.

Lightning mode requires the private key or apiKey of the dedicated trading wallet used by your bot. This allows PumpApi to build, sign, and send the transaction directly to Solana, which provides maximum speed, a 100% landing rate, and much shorter and cleaner bot code. We recommend Lightning mode because it is the simplest and fastest workflow. Choose Local mode instead if keeping transaction signing entirely inside your application is a requirement.

How do I generate a new Solana wallet?

We recommend keeping your main wallet separate from the funds used for automated trading. Create a dedicated Solana wallet for your bot and transfer only the amount you intend to trade with.

Keep the generated private key secret. Anyone who has it can control the wallet and its funds.

Python

Install the dependency:

pip install solders

Generate the wallet:

from solders.keypair import Keypair

keypair = Keypair()

print("Your Solana base58 private key:", keypair)
print("Your Solana base58 public key:", keypair.pubkey())

JavaScript

Install the dependencies:

npm install @solana/web3.js bs58

Generate the wallet:

const { Keypair } = require('@solana/web3.js');
const bs58 = require('bs58').default;

const keypair = Keypair.generate();

console.log('Your Solana base58 private key:', bs58.encode(keypair.secretKey));
console.log('Your Solana base58 public key:', keypair.publicKey.toBase58());

Rust

Add the dependencies to Cargo.toml:

[dependencies]
solana-sdk = "2"
bs58 = "0.5"

Generate the wallet:

use solana_sdk::signature::{Keypair, Signer};

fn main() {
    let keypair = Keypair::new();
    let private_key = bs58::encode(keypair.to_bytes()).into_string();

    println!("Your Solana base58 private key: {}", private_key);
    println!("Your Solana base58 public key: {}", keypair.pubkey());
}

Go

Install the dependency:

go get github.com/gagliardetto/solana-go

Generate the wallet:

package main

import (
    "fmt"
    "log"

    solana "github.com/gagliardetto/solana-go"
)

func main() {
    privateKey, err := solana.NewRandomPrivateKey()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Your Solana base58 private key:", privateKey.String())
    fmt.Println("Your Solana base58 public key:", privateKey.PublicKey().String())
}

What is Historical Replay?

Historical Replay is a FREE archive of past Data Stream events. You can use it to backtest trading strategies, replay previous market conditions, research token launches, and test your bot before using it in live trading.

Read the Historical Replay documentation.

Which pools do you support?

We support the following platforms for both trading and data stream APIs:

• pump.fun
• pump-amm
• Raydium Launchpad (including Bonk)
• Raydium CPMM
• Meteora Launchpad (including Bags, moonshot)
• Meteora DAMM V1
• Meteora DAMM V2
• Meteora DLMM

In addition, we also support:

• Native Solana (SOL) transfers
• Token transfers

How can I have more than 2 connections to the data stream?

We send a very large number of transactions, so to avoid overloading our server, there is a strict limit of 1 connection per IP address.

You can use ZeroMQ (highly recommended; it's extremely simple to use). The idea is straightforward:

You run a single instance that receives all transactions from our server. Then, from that instance, you share each transaction using the PUB/SUB method.

Here's how it works: You send data to a specific port, for example, 8939. Then the SUB (subscribers — your two, three, or more bots) connect to this port and receive all the transactions.

This way, you only have one connection for all three bots. ZeroMQ is currently the most efficient solution (latency is practically nonexistent — measured in nanoseconds). But you can also use WebSockets to stream locally (a bit slower — latency in microseconds). This method may be better because you only need to change one URL from "wss://stream.pumpapi.io" to "ws://127.0.0.1:9999":

Here's an example of the data stream sender (just run it and do not close it):

ZeroMQ method. Super fast. Requires a few changes on the bot side

Python

import asyncio
import websockets
import zmq # pip install pyzmq 
import sys

ctx = zmq.Context()

if sys.platform == "win32":
    sock = ctx.socket(zmq.PUB)
    sock.bind("tcp://127.0.0.1:8939")
else:
    sock = ctx.socket(zmq.PUB)
    sock.bind("ipc://8939")  # On Linux, IPC is slightly faster than TCP

async def connect_pumpapi_stream():
    while True:
        try:
            async with websockets.connect("wss://stream.pumpapi.io") as ws:
                while True:
                    msg = await ws.recv()
                    sock.send(msg)
        except Exception as e:
            print(e)
            await asyncio.sleep(1)

asyncio.run(connect_pumpapi_stream())

JavaScript

const WebSocket = require('ws');
const zmq = require('zeromq');

async function createStreamer() {
    const sock = new zmq.Publisher();
    
    if (process.platform === 'win32') {
        await sock.bind('tcp://127.0.0.1:8939');
    } else {
        await sock.bind('ipc://8939'); // On Linux, IPC is slightly faster than TCP
    }
    
    async function connectPumpApiStream() {
        while (true) {
            try {
                const ws = new WebSocket('wss://stream.pumpapi.io');
                
                ws.on('message', async (msg) => {
                    await sock.send(msg);
                });
                
                ws.on('error', (error) => {
                    console.error(error);
                });
                
                ws.on('close', () => {
                    console.log('Connection closed, reconnecting...');
                });
                
                // Wait for connection to close
                await new Promise((resolve) => {
                    ws.on('close', resolve);
                });

                await new Promise(resolve => setTimeout(resolve, 1000));
                
            } catch (error) {
                console.error(error);
                await new Promise(resolve => setTimeout(resolve, 1000));
            }
        }
    }
    
    connectPumpApiStream();
}

createStreamer();

Rust

use tokio_tungstenite::{connect_async, tungstenite::Message};
use zmq::{Context, Socket, PUB};
use futures_util::{SinkExt, StreamExt};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let context = Context::new();
    let sock = context.socket(PUB).unwrap();
    
    if cfg!(target_os = "windows") {
        sock.bind("tcp://127.0.0.1:8939").unwrap();
    } else {
        sock.bind("ipc://8939").unwrap(); // On Linux, IPC is slightly faster than TCP
    }
    
    connect_pumpapi_stream(sock).await;
}

async fn connect_pumpapi_stream(sock: Socket) {
    loop {
        match connect_async("wss://stream.pumpapi.io").await {
            Ok((ws_stream, _)) => {
                let (mut write, mut read) = ws_stream.split();
                
                while let Some(msg) = read.next().await {
                    match msg {
                        Ok(Message::Text(text)) => {
                            if let Err(e) = sock.send(&text, 0) {
                                eprintln!("Error sending message: {}", e);
                            }
                        }
                        Ok(Message::Binary(data)) => {
                            if let Err(e) = sock.send(&data, 0) {
                                eprintln!("Error sending message: {}", e);
                            }
                        }
                        Err(e) => {
                            eprintln!("WebSocket error: {}", e);
                            break;
                        }
                        _ => {}
                    }
                }
            }
            Err(e) => {
                eprintln!("Connection error: {}", e);
                tokio::time::sleep(Duration::from_secs(1)).await;
            }
        }
    }
}

Go

package main

import (
    "context"
    "fmt"
    "log"
    "runtime"
    "time"
    
    "github.com/gorilla/websocket"
    "github.com/pebbe/zmq4"
)

func main() {
    ctx, err := zmq4.NewContext()
    if err != nil {
        log.Fatal(err)
    }
    defer ctx.Term()
    
    sock, err := ctx.NewSocket(zmq4.PUB)
    if err != nil {
        log.Fatal(err)
    }
    defer sock.Close()
    
    if runtime.GOOS == "windows" {
        err = sock.Bind("tcp://127.0.0.1:8939")
    } else {
        err = sock.Bind("ipc://8939") // On Linux, IPC is slightly faster than TCP
    }
    if err != nil {
        log.Fatal(err)
    }
    
    connectPumpApiStream(sock)
}

func connectPumpApiStream(sock *zmq4.Socket) {
    for {
        conn, _, err := websocket.DefaultDialer.Dial("wss://stream.pumpapi.io", nil)
        if err != nil {
            fmt.Printf("Connection error: %v\n", err)
            time.Sleep(1 * time.Second)
            continue
        }
        
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                fmt.Printf("Read error: %v\n", err)
                conn.Close()
                break
            }
            
            _, err = sock.SendBytes(message, 0)
            if err != nil {
                fmt.Printf("Send error: %v\n", err)
            }
        }
        
        time.Sleep(1 * time.Second)
    }
}

Here's an example of your bot that receives transactions (the getter):

Python

Synchronous version:

import zmq # there's also asynchonios package zmq.asyncio
import sys
import orjson # or json

ctx = zmq.Context()
if sys.platform == "win32":
    sock = ctx.socket(zmq.SUB)
    sock.connect("tcp://127.0.0.1:8939")
else:
    sock = ctx.socket(zmq.SUB)
    sock.connect("ipc://8939") #  On Linux, IPC is slightly faster than TCP

sock.setsockopt_string(zmq.SUBSCRIBE, "")

while True:
    msg = sock.recv()
    msg = orjson.loads(msg)
    print(msg)

Asynchronous version:

import zmq.asyncio
import sys
import orjson
import asyncio

ctx = zmq.asyncio.Context()
if sys.platform == "win32":
    sock = ctx.socket(zmq.SUB)
    sock.connect("tcp://127.0.0.1:8939")
else:
    sock = ctx.socket(zmq.SUB)
    sock.connect("ipc://8939") # On Linux, IPC is slightly faster than TCP

sock.setsockopt_string(zmq.SUBSCRIBE, "")

async def runner():
    while True:
        msg = await sock.recv()
        msg = orjson.loads(msg)
        print(msg)

asyncio.run(runner())

JavaScript

Synchronous version:

const zmq = require('zeromq');

async function createClient() {
    const sock = new zmq.Subscriber();
    
    if (process.platform === 'win32') {
        sock.connect('tcp://127.0.0.1:8939');
    } else {
        sock.connect('ipc://8939'); // On Linux, IPC is slightly faster than TCP
    }
    
    sock.subscribe(''); // Subscribe to all messages
    
    for await (const [msg] of sock) {
        const data = JSON.parse(msg.toString());
        console.log(data);
    }
}

createClient();

Promise-based version:

const zmq = require('zeromq');

async function createAsyncClient() {
    const sock = new zmq.Subscriber();
    
    if (process.platform === 'win32') {
        sock.connect('tcp://127.0.0.1:8939');
    } else {
        sock.connect('ipc://8939'); // On Linux, IPC is slightly faster than TCP
    }
    
    sock.subscribe(''); // Subscribe to all messages
    
    while (true) {
        try {
            const [msg] = await sock.receive();
            const data = JSON.parse(msg.toString());
            console.log(data);
        } catch (error) {
            console.error('Error receiving message:', error);
        }
    }
}

createAsyncClient();

Rust

Synchronous version:

use zmq::{Context, SUB};
use serde_json::Value;

fn main() {
    let context = Context::new();
    let sock = context.socket(SUB).unwrap();
    
    if cfg!(target_os = "windows") {
        sock.connect("tcp://127.0.0.1:8939").unwrap();
    } else {
        sock.connect("ipc://8939").unwrap(); // On Linux, IPC is slightly faster than TCP
    }
    
    sock.set_subscribe(b"").unwrap(); // Subscribe to all messages
    
    loop {
        let msg = sock.recv_bytes(0).unwrap();
        let data: Value = serde_json::from_slice(&msg).unwrap();
        println!("{}", data);
    }
}

Asynchronous version:

use tokio_zmq::{prelude::*, Sub};
use serde_json::Value;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let mut sock = Sub::new().unwrap();
    
    if cfg!(target_os = "windows") {
        sock.connect("tcp://127.0.0.1:8939").unwrap();
    } else {
        sock.connect("ipc://8939").unwrap(); // On Linux, IPC is slightly faster than TCP
    }
    
    sock.set_subscribe("").unwrap(); // Subscribe to all messages
    
    let mut stream = sock.stream();
    
    while let Some(msg) = stream.next().await {
        match msg {
            Ok(multipart) => {
                if let Some(data) = multipart.get(0) {
                    match serde_json::from_slice::<Value>(data) {
                        Ok(parsed) => println!("{}", parsed),
                        Err(e) => eprintln!("JSON parse error: {}", e),
                    }
                }
            }
            Err(e) => eprintln!("Receive error: {}", e),
        }
    }
}

Go

Synchronous version:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "runtime"
    
    "github.com/pebbe/zmq4"
)

func main() {
    ctx, err := zmq4.NewContext()
    if err != nil {
        log.Fatal(err)
    }
    defer ctx.Term()
    
    sock, err := ctx.NewSocket(zmq4.SUB)
    if err != nil {
        log.Fatal(err)
    }
    defer sock.Close()
    
    if runtime.GOOS == "windows" {
        err = sock.Connect("tcp://127.0.0.1:8939")
    } else {
        err = sock.Connect("ipc://8939") // On Linux, IPC is slightly faster than TCP
    }
    if err != nil {
        log.Fatal(err)
    }
    
    err = sock.SetSubscribe("") // Subscribe to all messages
    if err != nil {
        log.Fatal(err)
    }
    
    for {
        msg, err := sock.RecvBytes(0)
        if err != nil {
            log.Printf("Receive error: %v", err)
            continue
        }
        
        var data interface{}
        if err := json.Unmarshal(msg, &data); err != nil {
            log.Printf("JSON parse error: %v", err)
            continue
        }
        
        fmt.Println(data)
    }
}

Goroutine-based version:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "runtime"
    "time"
    
    "github.com/pebbe/zmq4"
)

func main() {
    ctx, err := zmq4.NewContext()
    if err != nil {
        log.Fatal(err)
    }
    defer ctx.Term()
    
    sock, err := ctx.NewSocket(zmq4.SUB)
    if err != nil {
        log.Fatal(err)
    }
    defer sock.Close()
    
    if runtime.GOOS == "windows" {
        err = sock.Connect("tcp://127.0.0.1:8939")
    } else {
        err = sock.Connect("ipc://8939") // On Linux, IPC is slightly faster than TCP
    }
    if err != nil {
        log.Fatal(err)
    }
    
    err = sock.SetSubscribe("") // Subscribe to all messages
    if err != nil {
        log.Fatal(err)
    }
    
    // Message processing goroutine
    go func() {
        for {
            msg, err := sock.RecvBytes(0)
            if err != nil {
                log.Printf("Receive error: %v", err)
                time.Sleep(100 * time.Millisecond)
                continue
            }
            
            var data interface{}
            if err := json.Unmarshal(msg, &data); err != nil {
                log.Printf("JSON parse error: %v", err)
                continue
            }
            
            fmt.Println(data)
        }
    }()
    
    // Keep main goroutine alive
    select {}
}

WebSockets method. Fast. No changes required. You just need to change the link on the bot side to ws://127.0.0.1:9999.

Python

import asyncio
import websockets

clients = set()

async def client_handler(websocket):
    clients.add(websocket)
    try:
        await websocket.wait_closed()
    finally:
        clients.remove(websocket)

async def relay():
    print("Relay started.")
    while True:
        try:
            async with websockets.connect("wss://stream.pumpapi.io") as ws:
                async for msg in ws:
                    for client in list(clients):
                        asyncio.create_task(client.send(msg))
        except Exception as e:
            print(e)
            await asyncio.sleep(0.2)
            print("Reconnecting...")

async def main():
    server = await websockets.serve(client_handler, "localhost", 9999)
    await relay()

asyncio.run(main())

JavaScript

const WebSocket = require('ws');

const clients = new Set();

const server = new WebSocket.Server({ port: 9999, host: 'localhost' });

server.on('connection', (ws) => {
    clients.add(ws);
    
    ws.on('close', () => {
        clients.delete(ws);
    });
});

async function relay() {
    console.log('Relay started.');
    
    while (true) {
        try {
            const ws = new WebSocket('wss://stream.pumpapi.io');
            
            ws.on('message', (msg) => {
                for (const client of clients) {
                    if (client.readyState === WebSocket.OPEN) {
                        client.send(msg);
                    }
                }
            });
            
            await new Promise((resolve, reject) => {
                ws.on('close', resolve);
                ws.on('error', reject);
            });
            
        } catch (e) {
            console.log(e);
            await new Promise(resolve => setTimeout(resolve, 200));
            console.log('Reconnecting...');
        }
    }
}

relay();

Rust

use tokio_tungstenite::{connect_async, tungstenite::Message, WebSocketStream};
use tokio::net::{TcpListener, TcpStream};
use tokio_tungstenite::accept_async;
use std::collections::HashSet;
use std::sync::Arc;
use tokio::sync::Mutex;
use futures_util::{SinkExt, StreamExt};
use std::time::Duration;

type Clients = Arc<Mutex<HashSet<tokio_tungstenite::WebSocketStream<TcpStream>>>>;

#[tokio::main]
async fn main() {
    let clients: Clients = Arc::new(Mutex::new(HashSet::new()));
    let clients_clone = Arc::clone(&clients);
    
    tokio::spawn(async move {
        let listener = TcpListener::bind("127.0.0.1:9999").await.unwrap();
        
        while let Ok((stream, _)) = listener.accept().await {
            let clients = Arc::clone(&clients_clone);
            tokio::spawn(async move {
                if let Ok(ws_stream) = accept_async(stream).await {
                    {
                        let mut clients_lock = clients.lock().await;
                        clients_lock.insert(ws_stream);
                    }
                }
            });
        }
    });
    
    relay(clients).await;
}

async fn relay(clients: Clients) {
    println!("Relay started.");
    
    loop {
        match connect_async("wss://stream.pumpapi.io").await {
            Ok((ws_stream, _)) => {
                let (mut write, mut read) = ws_stream.split();
                
                while let Some(msg) = read.next().await {
                    match msg {
                        Ok(Message::Text(text)) => {
                            let mut clients_lock = clients.lock().await;
                            for client in clients_lock.iter_mut() {
                                let _ = client.send(Message::Text(text.clone())).await;
                            }
                        }
                        Ok(Message::Binary(data)) => {
                            let mut clients_lock = clients.lock().await;
                            for client in clients_lock.iter_mut() {
                                let _ = client.send(Message::Binary(data.clone())).await;
                            }
                        }
                        Err(e) => {
                            println!("{}", e);
                            break;
                        }
                        _ => {}
                    }
                }
            }
            Err(e) => {
                println!("{}", e);
                tokio::time::sleep(Duration::from_millis(200)).await;
                println!("Reconnecting...");
            }
        }
    }
}

Go

package main

import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
    
    "github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool)
var clientsMutex sync.Mutex

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func handleClient(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    
    clientsMutex.Lock()
    clients[conn] = true
    clientsMutex.Unlock()
    
    defer func() {
        clientsMutex.Lock()
        delete(clients, conn)
        clientsMutex.Unlock()
        conn.Close()
    }()
    
    for {
        _, _, err := conn.ReadMessage()
        if err != nil {
            break
        }
    }
}

func relay() {
    fmt.Println("Relay started.")
    
    for {
        conn, _, err := websocket.DefaultDialer.Dial("wss://stream.pumpapi.io", nil)
        if err != nil {
            fmt.Println(err)
            time.Sleep(200 * time.Millisecond)
            fmt.Println("Reconnecting...")
            continue
        }
        
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                fmt.Println(err)
                conn.Close()
                break
            }
            
            clientsMutex.Lock()
            for client := range clients {
                go func(c *websocket.Conn) {
                    c.WriteMessage(websocket.TextMessage, message)
                }(client)
            }
            clientsMutex.Unlock()
        }
        
        time.Sleep(200 * time.Millisecond)
        fmt.Println("Reconnecting...")
    }
}

func main() {
    http.HandleFunc("/", handleClient)
    
    go func() {
        log.Fatal(http.ListenAndServe(":9999", nil))
    }()
    
    relay()
}

Why do you send all transactions through the Data Stream? Can my computer handle that?

Some users worry that we're sending too many transactions — but in reality, it’s not as much as it might sound. We send around 300-400 transactions per second, covering all events across all pools and all solana and token transfers, and each transaction is very small in size.

Even older processors can easily handle this load. In fact, most modern servers, desktops, and laptops would be capable of processing over 30,000 of these lightweight events per second without any special optimization. So there's no need to worry — your machine can handle it just fine.

We designed it this way to ensure faster delivery and greater flexibility. Instead of requiring you to query us for updates or specific token transfers, you receive everything in real time — instantly, and with much less complexity on your side.

Where is your server located? I want the lowest possible latency!

Our server is located in Frankfurt am Main, close to the Solana RPC infrastructure (68% of validators are in Europe, most of them in Frankfurt). This helps ensure the lowest possible latency for trading and data stream. Your server location is very important: if it's in America, you can lose up to 200 ms.

If you're running infrastructure or bots, we recommend hosting them as close to Frankfurt as possible for the best performance.

Even if you're not in Frankfurt — or your server isn't — don’t worry! Thanks to efficient message delivery and lightweight transactions, performance will still be very fast and more than sufficient for most use cases.

Have a question? Ask us in our Telegram group