Building Solana Trading Bots in Rust: The `madeonsol` Crate, Async-First on `tokio` + `rustls`

The official MadeOnSol Rust SDK ships on crates.io. Full API surface parity with the TypeScript SDK, built on tokio + reqwest + rustls — no OpenSSL, cross-compiles cleanly, and the right fit for latency-sensitive Solana trading bots.

MadeOnSol·April 23, 2026· 8 min read

Building Solana Trading Bots in Rust: The `madeonsol` Crate, Async-First on `tokio` + `rustls`

Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.

Building a product on Solana data?

Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.

See Business pricing

Tools mentioned

Compare features and read reviews.

Live health scores, average ratings, and direct links on MadeOnSol.

extrnode

Decentralized Solana RPC gateway with auto-failover across a node cluster

GetBlock

Multi-chain RPC provider with free and paid Solana nodes — shared and dedicated endpoints for dApps, bots, and analytics

Ankr

Decentralized Web3 infrastructure with Solana RPC endpoints

Build your own trading bot

KOL copy-trading, deployer sniping, and DEX trade streaming — all via API.

New customers try Pro free for 5 days — card, cancel anytime.

Start free

import { MadeOnSol } from "madeonsol";

const client = new MadeOnSol({ apiKey: "msk_your_key" });

// Mirror KOL trades in real-time
const { trades } = await client.kol.feed({ action: "buy" });

// Set up webhooks for instant alerts
const webhook = await client.webhooks.create({
  url: "https://your-bot.com/hook",
  events: ["kol:trade", "deployer:alert"],
});

npm install madeonsolFull API docs

Building a product on Solana data?

MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.

Signals you'd otherwise build

KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.

Keep reading

More from the blog.

All API Guides

Developer Tools

Copy-Trade Solana KOL Wallets: Build a Paper-Trading Bot in 5 Minutes

Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.

4 minJuly 5, 2026

API Guides

Solana Deployer API: Track 182,000+ Token Creators by Bonding Rate

The MadeOnSol Deployer Hunter API gives you programmatic access to 182,000+ Pump.fun token deployers scored by historical bonding rate, tier, and trajectory — plus real-time alerts when elite deployers launch. Here's the full endpoint surface.

Enjoyed this article?

Explore the live data.

Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.

Open the KOL Tracker

API reference Start free Browse all articles

Explore more

Top 10 API Platforms Top 10 RPC Deployer Hunter KOL Tracker Compare Yields Solana Glossary

Workflow sketches

The shape of the client is simple: one type per endpoint group, methods returning typed responses. Specifics (method names, option structs) are on docs.rs/madeonsol — I won't invent names here. What's worth showing is how Rust changes the architecture of your bot loop.

Pattern 1: Streaming decision loop

The hottest path on most Solana trading bots is: get signal → score it → decide. In Rust that loop runs without GC hitches:

use tokio::time::{sleep, Duration};

async fn decide_loop(client: &madeonsol::Client) -> anyhow::Result<()> {
    loop {
        let feed = client.kol_feed()
            .limit(20)
            .action("buy")
            .min_sol(1.0)
            .await?;

        for trade in &feed.trades {
            if should_act(trade) {
                spawn_execution(trade.token_mint.clone()).await;
            }
        }
        sleep(Duration::from_secs(10)).await;
    }
}

tokio::spawn lets you fan out per-trade analysis onto the runtime without blocking the poll loop. In Node you'd use Promise.all and hope the GC doesn't chew through the cold loop you just queued.

Pattern 2: WebSocket stream with reconnect

For push-delivery (copy-trade signals, KOL trades, coordination alerts), the idiomatic Rust pattern pairs the SDK's REST calls for token generation with tokio-tungstenite for the WS layer:

use futures_util::{SinkExt, StreamExt};
use tokio_tungstenite::connect_async;

async fn run_stream(client: &madeonsol::Client, channels: Vec<&str>) -> anyhow::Result<()> {
    let mut backoff = Duration::from_secs(2);
    loop {
        match connect_and_listen(client, &channels).await {
            Ok(()) => backoff = Duration::from_secs(2),
            Err(e) => {
                eprintln!("stream err {e:?}; reconnect in {backoff:?}");
                tokio::time::sleep(backoff).await;
                backoff = (backoff * 3 / 2).min(Duration::from_secs(60));
            }
        }
    }
}

See the stream-token reconnect guide for the full pattern. While connected, the server now rotates the token in-band (a token_refresh frame), so a healthy stream rides through the 24h boundary untouched — you only fetch a fresh token on an actual disconnect, which in Rust is a single client.stream_token().await? before each reconnect. Same pattern the TS and Python SDKs use, just statically typed.

Pattern 3: Trade execution alongside signal detection

This is where Rust actually earns the rewrite. In a Node bot, the signal-detection loop and the tx-signing loop typically live in separate processes with IPC between them — the signing library (@solana/web3.js) has such different performance characteristics from the signal polling that you can't fairly share an event loop.

When Rust actually matters for Solana bots

For most people building around the MadeOnSol API — KOL alert bots, dashboards, trade journaling — TypeScript or Python is fine. You're bound by network latency, not by local compute. A Node-based bot sniping pump.fun will not be materially slower to signal than a Rust one.

Rust becomes the right choice in a few specific scenarios:

Co-located execution. You're running tx signing + jito bundle submission from the same process as your alpha detection. Rust + solana-sdk + jito-sdk-rust keeps everything in one memory space and one tight async loop, often inside a single digit ms.

Memory-constrained deployments. A Rust binary on a $5 VPS consumes 20–40 MB. The equivalent Node deployment runs 120+ MB with ws alone. For horizontal scaling (one bot per watched deployer, for example) that's the difference between 1 box and 8.

Deterministic latency. No GC pauses, no event-loop stalls under GC pressure. If your bot occasionally drops trades because the garbage collector spiked at the wrong moment, Rust fixes that permanently.

Cross-compilation. Shipping the bot to an ARM VPS, a RISC-V edge node, or a Docker image without node_modules is a cargo build --release --target=... away.

Outside those cases, stick with the TypeScript SDK. It's faster to iterate and the runtime difference isn't where your bot will win or lose.

What's in the crate

cargo add madeonsol

Design choices worth noting:

tokio async runtime. All methods return Futures — no blocking calls, no separate sync/async client split.

reqwest HTTP client with rustls. No OpenSSL dependency. Cross-compiles to Alpine containers, ARM boards, and static binaries without system-library pain.

Typed response structs. Every endpoint returns a concrete type that mirrors the live REST payload. Serde deserialization, so field mismatches fail at compile time (for required fields) or at parse time (for optionals).

Structured errors. Server-side error bodies are surfaced as typed variants, not just HTTP status codes. If a call fails because your tier is insufficient, you get that specific reason.

Same msk_ Bearer auth as every other SDK. One key across TS, Python, Rust, MCP, ElizaOS.

The covered surface: KOL endpoints (feed, leaderboard, coordination, pairs, hot, trending, entry-order, timing, PnL, compare, wallet profile), deployer-hunter (alerts, leaderboards, profiles, trajectory, best-tokens, recent-bonds), wallet tracker (watchlist CRUD, trades, summary), alpha wallet intelligence (leaderboard, wallet profile, linked wallets), token intel, and x402 discovery. Copy-trade CRUD ships via the REST surface on parity.

Install and auth

Add to Cargo.toml:

[dependencies] madeonsol = "1" # check crates.io for latest tokio = { version = "1", features = ["full"] } anyhow = "1"

Bootstrap the client:

use madeonsol::Client; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new(std::env::var("MADEONSOL_API_KEY")?); // ... use the client Ok(()) }

Grab an msk_ key from the developer portal — free tier gives you 200/day to prototype without a credit card.

Building Solana Trading Bots in Rust: The `madeonsol` Crate, Async-First on `tokio` + `rustls`

Compare features and read reviews.

extrnode

GetBlock

Ankr

More from the blog.

Copy-Trade Solana KOL Wallets: Build a Paper-Trading Bot in 5 Minutes

Solana Deployer API: Track 182,000+ Token Creators by Bonding Rate

Explore the live data.

Workflow sketches

Pattern 1: Streaming decision loop

Pattern 2: WebSocket stream with reconnect

Pattern 3: Trade execution alongside signal detection

ProxyGate

RPC Fast

DexScreener API Alternative: 5 Things It Can't Do (That MadeOnSol Can)

What Is a Solana API? A Developer's Guide to Building on Solana Data (2026)

BonkBot Review 2026: Is the Original Solana Telegram Bot Still Worth It?

Mizar Review 2026: Multi-Chain Copy Trading and DCA Bots — Including Solana

When Rust actually matters for Solana bots

What's in the crate

Install and auth

Error handling in practice

Deployment footprint

SDK version compatibility

When not to use Rust

Resources