Kalshi is the only CFTC-regulated prediction market exchange in the United States, and its REST API supports full automation from market scanning to order execution. This guide ranks every verified Kalshi trading bot available in 2026 — open-source repos with real GitHub activity, confirmed SaaS tools, and honest assessments of what each one actually does.

What Makes Kalshi Different for Bots

Before evaluating specific bots, these platform differences from Polymarket directly affect bot design:

FeatureKalshiPolymarket
RegulationCFTC-regulated (US-legal)Decentralized (non-US)
CurrencyUSD (cents)USDC on Polygon
Price format1-99 cents0.00-1.00 USDC
AuthenticationRSA key pairsHMAC signature
Order amendmentSupported (modify price/size in-place)Not supported (cancel + replace)
Order book formatBids only (compute asks)Bids + asks
Demo environmentYes (demo-api.kalshi.co)No official sandbox
Python SDKkalshi_python_syncpy-clob-client

These differences mean most bots need platform-specific adapters. Cross-platform tools like pmxt handle this internally.

Quick Rankings

BotTypePriceGitHub StarsBest For
ryanfrigo/kalshi-ai-trading-botMulti-model AI ensembleFree (OSS)162Serious AI-driven trading with consensus logic
OctagonAI/kalshi-deep-trading-botDeep research + structured bettingFree (OSS)117Research-heavy fundamental analysis
Kalshi News BotNews sentiment + Claude AIFree (OSS)Learning, customization, simple deployment
Kalshi-Quant-TeleBotTelegram-controlled quant botFree (OSS)Monitoring and control via mobile
kalshi-genai-trading-botMinimal Grok-powered botFree (OSS)Beginners, rapid prototyping
AlphascopeAI research + signal platformFreemiumN/A (SaaS)Non-developers, manual trading with AI signals
pmxtUnified cross-platform SDKFree (OSS)47Building custom cross-platform bots

Multi-Model AI Bots

The highest-activity Kalshi bots on GitHub use multiple LLMs in ensemble configurations, only entering trades when the models reach consensus. This approach reduces the risk of any single model hallucinating a probability estimate.

ryanfrigo/kalshi-ai-trading-bot

GitHub: ryanfrigo/kalshi-ai-trading-bot | 162 stars, 74 forks | MIT License | Python 3.12+

The most popular open-source Kalshi trading bot by GitHub activity. It runs five frontier LLMs (Claude Sonnet 4.5, GPT-5.4, Gemini 3.1 Pro, DeepSeek V3.2, Grok 4.1 Fast) through OpenRouter, with each model independently evaluating a trade. The system only enters positions when the models agree.

Architecture:

INGEST          →  DECIDE (Multi-Agent)  →  EXECUTE  →  TRACK
Kalshi REST API    5 LLMs via OpenRouter     Kalshi     SQLite DB
WebSocket Stream   Weighted consensus        Orders     P&L Dashboard

Key features:

  • Five-model consensus with weighted scoring (Grok-4 at 30% as primary forecaster)
  • Kelly Criterion sizing (fractional 0.25x) for position management
  • SQLite database for trade logging with P&L, win rate, and Sharpe ratio tracking
  • Paper trading mode for risk-free strategy testing
  • CLI dashboard for real-time monitoring
  • Category enforcement and risk guardrails (the README notes these were added after live trading losses)

Requirements: Python 3.12+, Kalshi API key with RSA private key, OpenRouter API key.

Honest assessment: Well-structured codebase with 12 commits and clear documentation. The multi-model consensus approach is sound in theory, but LLM probability estimates remain noisy — the README is transparent about this being experimental. The guardrails added from real trading experience add credibility.

Best for: Developers comfortable with Python who want a production-quality starting point for AI-driven Kalshi trading.

OctagonAI/kalshi-deep-trading-bot

GitHub: OctagonAI/kalshi-deep-trading-bot | 117 stars, 39 forks | 67 commits

A CLI-first trading bot that uses Octagon Deep Research for fundamental market analysis and OpenAI for structured betting decisions. Unlike the multi-model ensemble approach above, this bot focuses on depth of research per market rather than model consensus.

Key features:

  • Deep fundamental research via Octagon AI (generates independent probability estimates)
  • OpenAI structured outputs for trade decisions
  • 5-gate risk engine before any trade executes
  • Kelly Criterion sizing with edge computation against live order books
  • JSON-structured CLI output for scripting and automation
  • Supports market search, analysis, and automated execution

Example workflow:

# 1. Search for markets
MARKETS=$(bun start search crypto --json | jq '.data')

# 2. Analyze a specific market
bun start analyze KXBTC-26APR-B95000 --json

# 3. Returns modelProb, marketProb, edge, confidence, and drivers

Honest assessment: The 67-commit history and active development suggest real iteration. The CLI-first design makes it easy to integrate into larger systems. Octagon Deep Research is a paid API, which adds cost beyond just LLM inference. The 5-gate risk engine is a mature design pattern.

Best for: Traders who want deep, research-backed analysis on individual markets rather than broad scanning.

Sentiment & Signal Bots

Kalshi’s event-driven markets — Fed rate decisions, hurricane landfalls, company IPOs — are ideal for sentiment-driven bots. News breaks, odds shift, and the fastest bot wins.

Kalshi News Bot (Free, Open-Source)

The Kalshi News Bot is an open-source Python bot that uses Claude AI to analyze breaking news and identify mispriced events on Kalshi. At approximately 300 lines of code, it is the simplest functional Kalshi trading bot available.

Strengths:

  • Free and fully open-source
  • Uses Claude for news analysis — high-quality reasoning about event probabilities
  • Minimal setup — one of the fastest paths to a working Kalshi bot
  • Clean, readable codebase ideal for learning and customization

Limitations:

  • No built-in backtesting
  • Single-strategy (news sentiment only)
  • Requires your own Anthropic API key (Claude inference costs apply)
  • No web dashboard — terminal-only

Best for: Developers who want a working, understandable Kalshi bot to study, customize, and extend. The small codebase makes it the best starting point for learning how prediction market bots work.

yllvar/Kalshi-Quant-TeleBot

GitHub: yllvar/Kalshi-Quant-TeleBot

A more complex bot with a Telegram interface for remote monitoring and control. The architecture separates the trading engine (Python) from the user interface (JavaScript Telegram bot), connected via WebSocket.

Key features:

  • Python trading engine with pandas, numpy, and scikit-learn integration
  • Telegram bot UI with interactive commands, real-time notifications, and alerts
  • News sentiment analysis with event correlation to specific Kalshi markets
  • Multi-strategy support: sentiment-based, statistical arbitrage, and volatility patterns
  • Position sizing based on confidence levels, market volatility, and available capital
  • Multi-layered risk controls including stop-losses, position limits, and exposure management

Honest assessment: The dual-layer architecture (Python engine + JavaScript Telegram bot) adds complexity but solves a real problem — monitoring and controlling a trading bot from your phone. The event correlation analysis is a differentiated feature for Kalshi’s event-driven markets.

Best for: Traders who want mobile monitoring and control of their Kalshi bot without building a web dashboard.

ajwann/kalshi-genai-trading-bot

GitHub: ajwann/kalshi-genai-trading-bot

A minimal, “vibe-coded” trading bot that connects Grok (xAI) to Kalshi. The codebase was largely generated by LLMs, with the iteration prompts included in the /prompts directory.

Structure:

  • main.py — Entry point calling Kalshi and Grok clients
  • kalshi_client.py — API wrapper for Kalshi
  • grok_client.py — API wrapper for xAI’s Grok
  • Role prompting tells the LLM it is a professional prediction market trader

Honest assessment: This is a learning tool, not production infrastructure. The included prompt iteration history is genuinely useful for understanding how to instruct LLMs for trading decisions. The simple architecture makes the entire system easy to understand in an afternoon.

Best for: Beginners who want to understand the minimal viable architecture of an LLM-powered trading bot.

AI Research & Intelligence Tools

These tools provide the intelligence layer without handling execution directly. They complement any of the bots above.

Alphascope

Website: alphascope.app | SaaS | Free tier available

Alphascope is an AI-powered research platform built specifically for prediction market traders on both Kalshi and Polymarket. It provides probability estimates, news impact analysis, and cross-platform arbitrage detection — the intelligence layer that most trading bots lack.

Key features:

  • AI probability estimates for individual Kalshi and Polymarket markets
  • News impact scoring — ranks breaking stories by which markets they affect
  • Cross-platform price comparison (Kalshi vs Polymarket) for arbitrage detection
  • Interactive price charts with news event markers
  • Market analysis with confidence scores and reasoning transparency

How traders use it: Submit a Kalshi market URL, receive an AI probability estimate with rationale, and compare against the live market price. When Alphascope’s estimate diverges significantly from the market price, that is a potential trading signal.

Honest assessment: Alphascope is a research tool, not an execution bot. It does not place trades for you. The value is in its cross-platform market views and AI probability estimates — useful as an input signal for any of the open-source bots above. The founder has publicly documented trading $10 into Kalshi using only Alphascope signals, providing transparency about real-world performance.

Best for: Traders who want AI-powered market research without building their own analysis pipeline. Pairs well with any execution bot.

pmxt — Unified Cross-Platform SDK

AgentBets guide: pmxt Python Library Tutorial

pmxt is the CCXT for prediction markets — one Python SDK to read data and trade across Polymarket, Kalshi, Limitless, Probable, and Baozi. If you are building a custom bot that needs to scan or trade across multiple prediction market exchanges, pmxt eliminates the need to write platform-specific adapters.

Why it matters for Kalshi bots: pmxt handles the authentication differences (RSA for Kalshi vs HMAC for Polymarket), price format conversion (cents vs USDC), and order book normalization automatically. A bot built on pmxt can scan for arbitrage across platforms with a single API call pattern.

Best for: Developers building custom cross-platform bots, especially for arbitrage between Kalshi and Polymarket.

Real-World Kalshi Bot Lessons

Building a Kalshi bot is straightforward. Making it profitable is hard. A few documented lessons from the community:

Latency matters in live sports markets. A developer built a real-time Kalshi NFL trading bot that monitored ESPN win probability, planning to buy before the market adjusted. The result: professional sports bettors and market makers had access to data feeds at least 30 seconds faster than the unofficial ESPN API. The bot could not compete on speed in live sports markets. The full writeup is on Hacking the Markets.

Guardrails come from real losses. The ryanfrigo/kalshi-ai-trading-bot README explicitly states that category enforcement and risk guardrails were added after live trading without them led to significant losses. This is a common pattern — the first version of every trading bot loses money.

LLM probability estimates are noisy. Multiple bot authors note that LLM probability estimates diverge widely between models and across runs. The multi-model consensus approach (only trade when models agree) is a response to this noise, not a guarantee of accuracy.

Building Your Own Kalshi Bot

Kalshi’s developer tools for building custom bots:

Kalshi Authentication Quick Start

import kalshi_python

config = kalshi_python.Configuration(
    host="https://api.elections.kalshi.com/trade-api/v2"
)

with open('path/to/private_key.pem', 'r') as f:
    config.private_key_pem = f.read()

config.api_key_id = "your-api-key-id"
client = kalshi_python.KalshiClient(config)

# Check balance
balance = client.get_balance()
print(f"Available: ${balance.balance / 100:.2f}")

Marketplace Reviews

For deeper dives into specific bot strategies on Kalshi, see the individual marketplace reviews:

See Also


Rankings updated April 2026. Every bot listed has been verified against a live GitHub repository or production website. Not financial advice. Built for builders.