Build an AI Agent That Buys Solana KOL Signals in 20 Lines of Python (x402)

A walk-through of wiring an autonomous AI agent to MadeOnSol's x402 endpoints. The agent pays $0.005 USDC per KOL trade lookup from its own Solana wallet — no API key, no signup, no monthly subscription. Production-ready in under 20 lines.

MadeOnSol·May 14, 2026· 8 min read

Build an AI Agent That Buys Solana KOL Signals in 20 Lines of Python (x402)

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.

Trojan on Solana

Telegram trading bot for Solana — snipe new tokens, set limit orders, auto-sell, and copy trade with built-in MEV protection

Solana Agent Kit MCP

MCP server powered by Solana Agent Kit for on-chain actions

Solana Playground

Get this data via API

Stream real-time KOL trades, PnL rankings, and coordination signals programmatically.

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" });

// Real-time KOL trades
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });

// KOL convergence signals
const { tokens } = await client.kol.coordination({ min_kols: 3 });

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

Power Your AI Trading Agent with Solana Data: MCP vs Agent-Kit vs x402 (2026)

An AI agent is only as sharp as the data it can reach. This guide compares the three ways to wire live Solana memecoin intelligence — KOL flow, rug scores, deployer reputation — into an agent: the MCP server for Claude and Cursor, the solana-agent-kit plugin for autonomous JS agents, and x402 micropayments where the agent's wallet IS the API key. With the decision table, code-free setup for each, and the safety line that matters: the data layer never executes trades.

5 minJuly 5, 2026

Developer Tools

Build a Solana Trading Research Agent with LangChain and MadeOnSol Python SDK

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

Cost math

The KOL feed is the cheapest endpoint at $0.005/call. At 30-second polling that's:

120 calls/hour = $0.60/hour
2,880 calls/day = $14.40/day
~$432/month at continuous polling

That looks high until you realize: this is the unfiltered behavior. In practice the agent doesn't need to poll every 30s — it can use the response's next_before cursor for pagination, watch the WebSocket stream for fresh events, or poll once per minute and still catch every meaningful trade. Drop polling to once per 2 minutes and you're at $28/month for a fully live agent. That's still less than the Pro API tier's monthly fee, and you only pay it when the agent is running.

Want to scale up? Bump limit to 100 (each call returns 100 trades instead of 20 — same price). Or use /api/x402/kol/coordination ($0.02/call) for tighter alpha signals at 5-minute polling instead.

Beyond the basics

The same SDK exposes every x402 endpoint with the same auto-pay flow:

# Tighter alpha: tokens with multiple KOLs piling in within a 15-min window
clusters = agent.kol_coordination(period="1h", min_kols=4, min_score=70)
# Cost: $0.02

# Real-time alerts when tier-graded Pump.fun deployers launch new tokens
alerts = agent.deployer_hunter_alerts(limit=50, tier="elite")
# Cost: $0.01

# Tokens with the most KOL buy volume right now
trending = agent.kol_tokens_trending(period="15m", min_kols=3)
# Cost: $0.01

Stack these in a LangChain Tool and you have an agent that can autonomously discover, evaluate, and act on Solana memecoin signals without ever asking a human for an API key.

from langchain.agents import Tool

def get_fresh_kol_clusters(_):
    return agent.kol_coordination(period="1h", min_kols=3, min_score=65)

cluster_tool = Tool(
    name="solana_kol_clusters",
    description="Fetch KOL coordination clusters on Solana memecoins from the last hour. "
                "Returns tokens being co-bought by multiple high-winrate KOLs. "
                "Each call costs the agent $0.02 USDC from its own wallet.",
    func=get_fresh_kol_clusters,
)

Drop that tool into a ReAct agent or a CrewAI crew and let the LLM decide when to call it — the cost is bounded to the per-call price, and the agent's wallet shows exactly what was spent.

ElizaOS variant

If you're building on ElizaOS, the same x402 flow is exposed as a plugin:

{
  "plugins": ["@madeonsol/plugin-madeonsol"],
  "settings": {
    "MADEONSOL_X402_PRIVATE_KEY": "<agent base58 secret>"
  }
}

The plugin auto-routes data calls through x402 when no MadeOnSol API key is configured. The agent character can describe its capabilities ("I can fetch fresh KOL trades for $0.005") and the LLM will use the tool when relevant.

What x402 does in one paragraph

x402 is a reactivation of the long-dormant HTTP 402 "Payment Required" status code into a real payment protocol. An agent calls an API. The server returns 402 with a PAYMENT-REQUIRED header describing the price (USDC), the recipient (a Solana wallet), and the network (Solana mainnet). The agent signs a USDC transfer from its own Solana wallet, base64-encodes the payload as a PAYMENT-SIGNATURE header, retries the request. The server verifies + settles on-chain (about 1 second), returns the data. One round trip; no signup ever happens.

If you want the longer version, read our Solana AI Agents & x402 guide. For this post, that one paragraph is enough.

What you're going to build

A Python script that:

Watches MadeOnSol's KOL trade feed every 30 seconds

Filters for trades by high-winrate KOLs (≥65% over the last 7 days)

Logs each match (and pays $0.005 USDC for the call from the agent's own Solana wallet)

That's it — the simplest useful agent. From here you can plug it into LangChain, ElizaOS, a copy-trade bot, or a Telegram alerter.

Prerequisites

Python 3.10+ with pip

A Solana wallet the agent owns. Generate one with solana-keygen new --outfile agent.json if you don't have one, or use any existing keypair.

About $5 of USDC in that wallet (covers ~1,000 calls of the cheapest endpoint, or 250 of the priciest). Bridge to Solana mainnet via Phantom, Jupiter, or your bridge of choice.

Optional: a small SOL balance is NOT needed — MadeOnSol's facilitator (PayAI) sponsors transaction fees.

The agent — full source

import os, time from madeonsol_x402 import MadeOnSolClient agent = MadeOnSolClient(private_key=os.environ["AGENT_SOLANA_KEY"]) seen = set() while True: feed = agent.kol_feed(limit=20, min_kol_winrate=65, action="buy") for trade in feed["trades"]: sig = trade["tx_signature"] if sig in seen: continue seen.add(sig) print( f"[{trade['traded_at']}] {trade['kol_name']} bought " f"{trade['token_symbol']} for {trade['sol_amount']} SOL " f"@ ${trade['market_cap_usd_at_trade']:,} MC " f"(winrate {trade['kol_winrate_7d']:.0f}%)" ) time.sleep(30)

That's the whole thing. 20 lines including imports and whitespace. Run it:

export AGENT_SOLANA_KEY="<your base58 private key>" python agent.py

The first time the SDK hits kol_feed(), it will:

Send a GET to https://madeonsol.com/api/x402/kol/feed?limit=20&min_kol_winrate=65&action=buy.

Receive HTTP 402 with a payment challenge ($0.005 USDC, payTo 88xSdW…cycVU, Solana mainnet, USDC mint).

Build a USDC transfer transaction, sign it with the keypair from AGENT_SOLANA_KEY.

Base64-encode the signed payload as a PAYMENT-SIGNATURE header, retry the request.

MadeOnSol calls the PayAI facilitator (facilitator.payai.network) to verify + settle the payment on-chain.

On success, returns the KOL trade data plus a PAYMENT-RESPONSE header containing the settlement transaction signature (your audit trail).

Total time end-to-end: about 1.0–1.5 seconds for the first call. Every 30 seconds after that, another call, another $0.005, another batch of trades.

What you'll see

[2026-05-14T16:42:11Z] @cented7 bought PEPECAT for 5.27 SOL @ $287,000 MC (winrate 71%) [2026-05-14T16:42:23Z] @somealpha bought MOONDOG for 2.4 SOL @ $94,200 MC (winrate 68%) [2026-05-14T16:42:54Z] @profittaker bought CATGPT for 8.1 SOL @ $412,800 MC (winrate 65%)

Each line cost the agent half a cent. The agent's Solana wallet shows the on-chain USDC outflows in real time — clean accounting, no invoices to reconcile.

Endpoint	Price	What it returns
`/api/x402/kol/feed`	$0.005	Real-time KOL trade feed
`/api/x402/kol/leaderboard`	$0.005	KOL rankings by PnL / winrate / profit factor
`/api/x402/kol/tokens/hot`	$0.01	Tokens with accelerating KOL interest
`/api/x402/kol/tokens/trending`	$0.01	Tokens by raw KOL buy volume
`/api/x402/deployer-hunter/alerts`	$0.01	Real-time Pump.fun deployer launches
`/api/x402/kol/coordination`	$0.02	Multi-KOL clusters on the same token
`/api/x402/kol/pairs`	$0.02	KOL co-trading affinity matrix

Build an AI Agent That Buys Solana KOL Signals in 20 Lines of Python (x402)

Compare features and read reviews.

Trojan on Solana

Solana Agent Kit MCP

Solana Playground

More from the blog.

Power Your AI Trading Agent with Solana Data: MCP vs Agent-Kit vs x402 (2026)

Build a Solana Trading Research Agent with LangChain and MadeOnSol Python SDK

Explore the live data.

Cost math

Beyond the basics

ElizaOS variant

MetaMask Solana Snap

OpenSVM Solana MCP

Solana AI Agents & x402: How AI Pays on the Blockchain (2026)

What Is a KOL in Crypto? Key Opinion Leaders Explained (2026)

Free vs Paid KOL Trackers on Solana: When the Free Tools Stop Being Enough

Cielo vs Birdeye vs Solscan: Best Solana Wallet Tracker for Copying Smart Money (2026)

What x402 does in one paragraph

What you're going to build

Prerequisites

Install

The agent — full source

What you'll see

Why this beats traditional auth for agents

Endpoints available right now

Resources