NaxosDataNaxosData

Open-Source Tooling · MIT Licensed

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

High-performance Python SDKs, discrete event-driven backtesting harnesses, and cross-venue execution blueprints. Open-source under MIT, built for quantitative researchers and algorithmic traders replaying multi-venue prediction market order books.

Zero-Lockin SDK

Engineered for speed, composability, and clean schemas.

Switch effortlessly between live WebSocket subscriptions, local Parquet tape replays, 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
TS / JSnpm i @naxosdata/sdk
Pythonpip install naxosdata
// 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

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.

TypeScript 5.0+ · Node 18+ · Dual ESM/CJS · NPM
52873

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
Python 3.10+ · AsyncIO · PyPI
41258

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, 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
Event-Driven · Discrete Replay · Invariants
685114

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

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.