NaxosDataNaxosData

Open-Source Tooling · 12 Production Repositories · MIT Licensed

Open-source quantitative tooling,
powered by synchronized market data.

Autonomous cross-venue arbitrage engines, Avellaneda-Stoikov market makers, Model Context Protocol (MCP) AI integrations, and zero-dependency client SDKs. 100% open-source under MIT, built for quantitative researchers and algorithmic traders replaying multi-venue prediction market order books.

Zero-Lockin SDKs & Tooling

Engineered for speed, composability, and clean schemas.

Switch effortlessly between live WebSocket subscriptions, local Parquet tape replays, AI MCP servers, and discrete event backtesting. All data objects adhere to standard Apache Arrow tables with zero proprietary wrappers.

Strict position lifecycle invariant proofs
Sub-millisecond binary message parsing
Polars & PyArrow native zero-copy exports
Install Official Client Libraries & MCP
TS / JSnpm i @naxosdata/sdk
Pythonpip install naxosdata
MCPnpx -y polymarket-mcp-server
// 1. Install official TypeScript & JavaScript SDK:
// npm install @naxosdata/sdk

import { NaxosClient, Venue, StrategyType } from "@naxosdata/sdk";

// Initialize client with authenticated API key
const client = new NaxosClient({
  apiKey: process.env.NAXOS_API_KEY || "nx_live_...",
});

// 1. Search active prediction markets across venues
const markets = await client.markets.list({
  venue: Venue.POLYMARKET,
  status: "ACTIVE",
  onlyRecorded: true,
});
console.log(`Found ${markets.data.length} active recorded markets.`);

// 2. Fetch full historical L2 snapshot at millisecond timestamp
const snapshot = await client.orderbooks.snapshot({
  venue: Venue.POLYMARKET,
  marketId: "poly-fed-nov-2026",
  timestampMs: 1730000000300,
});
console.log(`Spread: ${snapshot.spread_bps} bps | Best Bid: $${snapshot.best_bid} | Best Ask: $${snapshot.best_ask}`);

// 3. Query cross-venue matched arbitrage pairs
const pairs = await client.pairs.list({ minFungibility: 80, onlyRecorded: true });
for (const pair of pairs.data.slice(0, 3)) {
  console.log(`[${pair.pair_id}] ${pair.venue_long} -> ${pair.venue_short} | Net ROI: +${pair.net_roi_pct}%`);
}

// 4. Solve Kalshi quadratic taker fee & breakeven counterpart price
const breakeven = client.tools.solveBreakeven({
  primaryPrice: 0.635,
  targetRoiPct: 1.5,
  contracts: 1000,
});
console.log(`Max Counterpart NO Price: $${breakeven.maxCounterpartPrice}`);
Node.js 18+ · TypeScript · Zero-deps · Dual ESM/CJS
MIT License

Open Source Ecosystem

12 Production modules. Zero proprietary lock-in.

Every tool in the NaxosData ecosystem is published under the permissive MIT license. Audit the wire deserializers, inspect the orderbook matching rules, or contribute custom exchange adapters.

Universal 7-VenueTypeScript / Node

nexosdata/naxos-sdk-ts

Zero-dependency TypeScript & JavaScript SDK for L2 feeds, SSE & backtesting

Official universal client library for Node.js, Bun, Deno, and modern browsers. Features end-to-end typed schemas for all 7 prediction market venues, real-time Server-Sent Events (SSE) orderbook streaming, closed-form quadratic fee solvers, and deterministic backtesting.

Zero runtime dependencies — 100% web standard fetch & AsyncIterable
Real-time sub-second orderbook delta streaming via SSE
Built-in closed-form quadratic solver for Kalshi taker fee & breakeven ROI
Full TypeScript definitions matching NaxosData wire protocols
npm install @naxosdata/sdk
Universal 7-VenuePython 3.10+

nexosdata/naxos-py

High-throughput AsyncIO SDK with zero-copy binary feeds

Typed asynchronous client library engineered for real-time WebSocket tick ingestion, binary Parquet partition streaming, and automatic reciprocal normalization across Polymarket, Kalshi, ForecastEx, Limitless, PredictIt, Drift BET, and Smarkets.

Sub-millisecond WebSocket streaming with auto-reconnect
Reciprocal outcome inversion (YES ↔ NO) for dual-leg parity
Native Polars & PyArrow table serialization with zero copy
Type-safe Pydantic v2 schemas matching NaxosData wire spec
pip install naxosdata
Polymarket + KalshiTypeScript / Node

nexosdata/polymarket-kalshi-arbitrage-bot

Cross-venue arbitrage scanner & dual-leg execution simulator

Autonomous arbitrage engine scanning live Polymarket and Kalshi order books for mispricings. Models exact CFTC quadratic taker fees and features emergency scratch-unwind protection to prevent unhedged directional tail risk.

Real-time pair discovery via NaxosData API (/api/v1/pairs)
Exact CFTC quadratic taker fee modeling & closed-form root solver
Dual-leg IOC routing simulator with latency and slippage guards
Emergency scratch-unwind safeguard on leg failure or liquidity drop
npx polymarket-kalshi-arbitrage-bot
Polymarket & AI IDEsTypeScript / Node

nexosdata/polymarket-mcp-server

Official Model Context Protocol (MCP) server for Claude & Cursor

Zero-dependency stdio JSON-RPC 2.0 MCP server connecting AI models (Claude Desktop, Cursor) directly to live prediction market order books, cross-venue arbitrage scanners, whale trade alerts, and universal search.

Full Model Context Protocol (MCP) specification 2024-11-05 compliance
5 native tools: orderbooks, arbitrage scanner, fee math, whale alerts, search
Instant 60-second setup for Claude Desktop and Cursor IDE
Dual transport framing (newline-delimited and Content-Length HTTP/stdio)
npx -y @naxosdata/polymarket-mcp-server
Kalshi CFTC & AI IDEsTypeScript / Node

nexosdata/kalshi-mcp-server

Official Model Context Protocol (MCP) server for Kalshi prediction markets

Zero-dependency stdio JSON-RPC 2.0 MCP server connecting Claude Desktop and Cursor directly to Kalshi Level 2 order books (Fed rates, CPI, elections, weather) and CFTC fee solvers.

MCP 2024-11-05 spec with 5 native tools: orderbooks, fees, search, payouts, spreads
Instant 60-second setup for Claude Desktop and Cursor IDE
CFTC Rule 40.2 fee calculator & quadratic breakeven solver
Dual transport framing (newline-delimited and Content-Length HTTP/stdio)
npx -y kalshi-mcp-server
Polymarket On-ChainPython 3.10+

nexosdata/polymarket-whale-tracker

Real-time block trade monitor, whale wallet tracker & alerts

Institutional trade telemetry engine monitoring prediction markets for smart-money accumulations, large block executions, and whale wallet movements with instant Discord and Telegram notifications.

Real-time streaming trade tape via NaxosData /api/v1/trades
Institutional block detection & customizable notional thresholds
Rich Discord embed webhooks & Telegram HTML notifications with PolygonScan links
Cumulative whale wallet leaderboard with CSV and JSON exports
pip install polymarket-whale-tracker
Polymarket CLOBPython 3.10+

nexosdata/polymarket-market-maker-bot

Avellaneda-Stoikov market maker bot with inventory skew & OBI

High-frequency market making bot engineered specifically for binary prediction market microstructure. Solves reservation prices using risk-aversion inventory penalty and order book imbalance (OBI) drift.

Avellaneda-Stoikov reservation price model bounded for [0, 1] contracts
Order Book Imbalance (OBI) micro-price drift forecasting
Inventory skew penalty preventing toxic adverse selection runs
Discrete execution simulator with fill probability & PnL telemetry
pip install polymarket-market-maker-bot
Kalshi CFTCPython 3.10+

nexosdata/kalshi-market-maker-bot

Avellaneda-Stoikov market maker bot for Kalshi CFTC prediction markets

Automated liquidity engine engineered for Kalshi discrete cent ticks ($0.01 - $0.99). Models exact CFTC Rule 40.2 quadratic taker fees, state-dependent binary volatility, and dynamic inventory skewing.

Avellaneda-Stoikov reservation pricing adapted for Kalshi binary odds
Exact CFTC quadratic taker fee modeling & maker rebate schedules
Order Book Imbalance (OBI) drift-adjusted micro-price forecasting
Poisson arrival matching simulation with FIFO queue depth tracking
git clone https://github.com/nexosdata/kalshi-market-maker-bot.git
Kalshi CFTCPython 3.10+

nexosdata/kalshi-python-sdk

High-throughput async Python SDK, quantitative models & fee solvers

AsyncIO and Synchronous Python client for Kalshi markets with Pydantic v2 schemas, analytical digital option implied volatility inversion, hazard rate term structures, and NaxosData L2 order book streaming.

Pydantic v2 typed models for Kalshi markets, orderbooks, and trades
Black-Scholes digital call IV inversion & probability term structure
Analytic closed-form quadratic order sizing solver under Kyle's lambda
Full CLI suite: markets, orderbook, fee calculator, and CSV/JSON export
pip install kalshi-python-sdk
Cross-Venue Delta NeutralPython 3.10+

nexosdata/kalshi-polymarket-hedger

Cross-venue delta-neutral hedging & statistical risk manager

Continuous rebalancing daemon monitoring delta exposure on Kalshi and executing optimal offsetting hedges on Polymarket (and vice versa) with reciprocal outcome mapping and quadratic fee budgeting.

Real-time delta risk monitoring and configurable drift threshold triggers
Reciprocal outcome parity mapping (Kalshi YES ↔ Polymarket NO)
Quadratic CFTC fee & Polygon gas budget optimization
Simulated paper-trading fill engine with terminal ASCII delta gauge
pip install kalshi-polymarket-hedger
Polymarket + Kalshi ArchivesPython 3.10+ / DuckDB

nexosdata/polymarket-historical-data-downloader

Level 2 prediction market tick archive downloader with DuckDB

Production CLI tool for downloading complete historical Level 2 tick archives into Hive-partitioned Parquet (ZSTD), CSV, or JSONL, with instant zero-copy analytical queries using embedded DuckDB.

Incremental partitioned batch downloads (data/venue=*/date=*/market=*.parquet)
High-compression Parquet ZSTD for high-throughput quantitative backtests
Zero-copy embedded DuckDB views for depth-weighted VWAP & spread analysis
Robust CLI with resume caching, exponential backoff, and rate-limit recovery
git clone https://github.com/nexosdata/polymarket-historical-data-downloader.git
Universal Simulation EnginePython 3.10+

nexosdata/naxos-arb-backtester

Discrete event-driven multi-venue backtester & invariant checker

Deterministic simulation harness that replays chronological Level 2 order book snapshots against multi-venue fee tiers (Hobbyist to Institutional Pro), slippage curves, synthetic network wire latency, and rigorous position lifecycle invariant proofs.

Invariant proof: Positions Opened = Early Exits + Expirations + Scratches + Open
Multi-venue cash pool isolation with $0.00 bankruptcy guard
Fee tier scaling: 0 bps Polymarket maker/taker, tiered Kalshi contracts
Full microstructural telemetry: scale-in tranches, sweeps & unwinds
git clone https://github.com/nexosdata/naxos-arb-backtester.git

Design Philosophy

Built on mathematical invariants and open data standards.

Zero Vendor Lock-In

Stored in standard Apache Parquet with ZSTD compression. Query directly using DuckDB, Polars, ClickHouse, or Pandas without custom ingestion daemons.

Deterministic Replay

Order book events are sequenced with strict nanosecond timestamps. Replays are 100% deterministic and reproducible across multiple execution runs.

Position Lifecycle Proofs

Every trade is reconciled by the invariant equation: Positions Opened = Early Exits + Expirations + Scratch Unwinds + Open Remaining. Zero position leakage.

Modular Venue Adapters

Plug in new prediction market venues by implementing a single Abstract Venue Connector interface for order placement, cancel, and tick deserialization.

Contribute & Collaborate

Join quantitative engineers building the open prediction market infrastructure.

Whether you are developing automated market-making algorithms, statistical arbitrage models, or new venue connectors, we welcome pull requests, issue reports, and research discussions.