Copy-trade signals for any Solana wallet you choose

Show me

One rule, one wallet buy, one signal

The full path for a single trade. Field names are the real request and payload keys; values are illustrative and the frames are abridged.

1. 1 · Write the rule

   Name the source wallets (any valid Solana addresses; the two here are examples), a size floor, the side, a market cap band, how to size the follow and where to deliver. The response returns webhook_secret once.

   Create a rule

   POST /api/v1/copytrade/subscriptions
   Authorization: Bearer msk_...
   Content-Type: application/json
   
   {
     "name": "two wallets, early buys",
     "source_wallets": ["CyaE...n5Lb", "4BdK...9sQe"],
     "min_trade_sol": 1,
     "only_action": "buy",
     "min_mc_usd": 20000,
     "max_mc_usd": 2000000,
     "sizing_mode": "proportional",
     "sizing_amount": 0.1,
     "delivery_mode": "both",
     "webhook_url": "https://bot.example.com/hooks/copytrade"
   }

2. 2 · A followed wallet buys

   MadeOnSol parses the swap with the market cap at the trade and hands it to the rule engine. This example wallet happens to be a tracked KOL, so the same swap also appears on kol:trades with its KOL name. A wallet that is not a KOL is checked the same way and its signal carries kol_name null.

   kol:trades frame (abridged)

   {
     "id": "kol:trade:5K7j...",
     "seq": 184219,
     "channel": "kol:trades",
     "event": "kol:trade",
     "data": {
       "kol_name": "Cented",
       "wallet_address": "CyaE...n5Lb",
       "token_mint": "8vdc...pump",
       "token_symbol": "NEW",
       "action": "buy",
       "sol_amount": 5.27,
       "token_amount": 18400000,
       "tx_signature": "5K7j...",
       "slot": 449476688,
       "traded_at": "2026-09-23T10:00:35.000Z",
       "market_cap_usd_at_trade": 28430,
       "liquidity_usd_at_trade": 9120,
       "primary_dex": "pumpfun"
     },
     "ts": 1790157635000
   }

3. 3 · The rule fires

   5.27 SOL clears the floor, the entry sits inside the band, and 0.1 of the source trade's size becomes suggested_sol_amount. A webhook receives the same data inside { event, data, timestamp }.

   copytrade:signals frame (abridged)

   {
     "id": "copytrade:signal:77120",
     "seq": 184220,
     "channel": "copytrade:signals",
     "event": "copytrade:signal",
     "data": {
       "signal_id": 77120,
       "subscription_id": 41,
       "subscription_name": "two wallets, early buys",
       "fired_at": "2026-09-23T10:00:36.120Z",
       "source_wallet": "CyaE...n5Lb",
       "kol_name": "Cented",
       "action": "buy",
       "token_mint": "8vdc...pump",
       "token_symbol": "NEW",
       "source_sol_amount": 5.27,
       "suggested_sol_amount": 0.527,
       "tx_signature": "5K7j...",
       "traded_at": "2026-09-23T10:00:35.000Z",
       "market_cap_usd_at_trade": 28430,
       "price_usd_at_trade": 0.0000284
     },
     "ts": 1790157636120
   }

4. 4 · Your bot takes over

   Handle it on the stream, or verify the webhook signature over timestamp.body with the rule's secret. Everything after this line is your code.

   TypeScript · madeonsol-x402 + webhook check

   import crypto from "node:crypto";
   import { MadeOnSolREST } from "madeonsol-x402";
   
   // Option A: WebSocket (delivery_mode "websocket" or "both")
   const rest = new MadeOnSolREST({ apiKey: process.env.MADEONSOL_API_KEY! });
   const stream = rest.stream();
   stream.on("copytrade:signal", (s) => myBot.consider(s)); // your sizing caps, your signer
   stream.subscribe(["copytrade:signals"]);
   
   // Option B: webhook (delivery_mode "webhook" or "both")
   // rawBody:   the exact request bytes (never re-serialized JSON)
   // secret:    the webhook secret exactly as the API returned it (do not hex-decode)
   function verifyMadeOnSol(rawBody: Buffer | string, timestamp: string | undefined, signature: string | undefined, secret: string): boolean {
     // X-MadeOnSol-Timestamp: unix milliseconds, fresh on every retry
     if (typeof timestamp !== "string" || !/^\d{1,16}$/.test(timestamp)) return false;
     // Replay window: your choice, the server does not enforce one
     if (Math.abs(Date.now() - Number(timestamp)) > 5 * 60_000) return false;
     // X-MadeOnSol-Signature: 64 hex characters, bare (no algorithm prefix)
     if (typeof signature !== "string" || !/^[0-9a-f]{64}$/i.test(signature)) return false;
     const expected = crypto
       .createHmac("sha256", secret)
       .update(`${timestamp}.`)
       .update(rawBody)
       .digest();
     // Both sides are exactly 32 bytes here, so this compares in constant time and cannot throw
     return crypto.timingSafeEqual(expected, Buffer.from(signature, "hex"));
   }
   
   // In your raw-body route handler (webhook_secret is returned once at create):
   // verifyMadeOnSol(rawBody, headers["x-madeonsol-timestamp"],
   //                 headers["x-madeonsol-signature"], process.env.RULE_WEBHOOK_SECRET!)
   // body: { "event": "copytrade:signal", "data": { ...same fields, no signal_id }, "timestamp": "..." }
   // dedupe webhook retries on data.subscription_id + data.tx_signature

From rule to signal

What happens between a wallet's trade and your bot

Each stage reads one part of your rule and one part of the source wallet's trade. The first seven run on MadeOnSol; the last one is yours.

1. 01 · MadeOnSol

   Scope

   source_walletsvswallet_address

   Every qualifying swap by a wallet one of your active rules lists is checked against that rule, whether or not the wallet is a known KOL. KOL status only adds kol_name to the signal. A trade that arrives more than 10 seconds after it landed on chain is not signalled.

2. 02 · MadeOnSol

   Size floor

   min_trade_solvssol_amount

   Trades below your floor are dropped. The default floor is 0. USDC and USDT legs are converted to SOL first; a swap by a non-KOL wallet quoted in another token is skipped rather than sized wrong.

3. 03 · MadeOnSol

   Side

   only_actionvsaction

   buy, sell or both. A rule created without it follows buys only (buy).

4. 04 · MadeOnSol

   Market cap band

   min_mc_usdmax_mc_usdvsmarket_cap_usd_at_trade

   The source trade's entry must sit inside your band. When a band is set and the trade's market cap is unknown, no signal fires.

5. 05 · MadeOnSol

   Size

   sizing_modesizing_amountvssol_amount

   fixed returns sizing_amount as SOL. proportional and percent_source both multiply the source trade's SOL amount by sizing_amount. The result is suggested_sol_amount.

6. 06 · MadeOnSol

   Once per trade

   subscription_idvstx_signature

   One signal per rule per transaction. A trade replayed after a reconnect or restart does not fire the rule twice.

7. 07 · MadeOnSol

   Delivery

   delivery_modewebhook_url

   webhook posts to your URL signed with the rule's own secret, up to 3 attempts. websocket publishes to copytrade:signals for your connections only. both does both.

8. 08 · Your bot

   Execution

   suggested_sol_amount

   Your code decides: cap the size, check the token, then build, sign and send the swap with your own wallet and RPC.

Filled chips are rule fields, outlined chips are fields of the source trade or the signal. Copy-trade API reference

Compared

A wallet webhook vs a copy-trade signal

A plain address webhook tells you something touched a wallet. A copy-trade signal tells you a wallet your rule follows made a trade your rule accepts. Seeing every transaction a wallet makes, not only qualifying swaps, is what wallet tracking events are for.

Plans

Which plan each step needs

Compare plans for the number of rules and wallets per rule.

Architecture

From a wallet's trade to your signer

1. 1 · Source

   Chain activity

   Transactions and program events

3. 2 · MadeOnSol

   Data and intelligence layer

   • Source wallets from your rules
   • Parsed swaps, KOL names when known
   • Rule checks and sizing

5. 3 · Delivery

   • Webhooksper-rule secret · copytrade:signal
   • WebSocket streamscopytrade:signals · kol:trades
   • REST API/copytrade/* · /kol/*

7. 4 · Yours

   Your caps, checks and signer

   Keys and business logic stay server-side

9. 5 · Users

   Your copy-trading product

• Copy-trading bots with your own risk limits
• Paper-trading and backtest harnesses
• Wallet follow alerts for your users
• Trader shortlists and scorecards
• Multi-KOL confirmation filters

Showing MadeOnSol data to your own users requires a Business plan. See pricing