Stop Building Crypto Data Pipelines.
Start Trading.

AlgoTick is the outsourced quantitative engineering team for AI Agents and Delta-Neutral Quants. We normalize the firehoses, calculate the Greeks, and maintain the state — so you can just call the API.

Get API Key ($299/mo) Read the llms.txt →

You could build this yourself. But why would you?

Connecting to a free WebSocket is easy. Building a trading business on top of one is a nightmare.

💥 The Normalization Nightmare
4 Schemas, 4 Timestamp Formats
Binance, Hyperliquid, Solana AMMs, and EVM DEXs use completely different JSON schemas, timestamp formats (seconds, milliseconds, nanoseconds), and connection protocols. We normalize everything into one predictable Universal Payload.
🧠 The Stateful Math Problem
GEX, Imbalance, Regime — Pre-Calculated
To calculate Dealer Gamma Exposure, your bot must hold the entire Deribit options chain in memory, apply Black-Scholes, and sum across all strikes — 10x/sec. We did the math already. Just call /v3/signals/gamma-exposure and get a single number.
🔒 The Uptime Tax
46% of Ticks Are Duplicates
Free WebSockets drop frames during peak volatility — exactly when you need data most. Our Go multiplexer runs 3 redundant connections per chain and deduplicates in real-time. You get a bulletproof stream. Zero dropped ticks.

We handle the infrastructure. You get the Alpha.

AlgoTick's Go-based data citadel sits in Frankfurt, ingesting, deduplicating, and mathematically transforming the heaviest data streams in crypto.

🧠 AI-Ready Derived Signals
Skip the Math. Call the Endpoint.
Don't download raw options chains. Just hit /v3/signals/gamma-exposure and get the live GEX integer. Hit /v4/signals/liquidity-voids for orderbook thin-zone detection. Hit /v4/signals/mempool-congestion for Ethereum gas + MEV pressure.
⚡ Normalized Cross-Chain WebSocket
One Connection. Every Chain.
Stream Solana DEX swaps, Ethereum Mempool pressure, Flashbots MEV bids, and Hyperliquid trades through a single wss://ws.algotick.dev connection. Every message follows our Universal Payload schema. No dropped frames.
🗃 The Institutional R2 Data Lake
Backtest Against the Past. Instantly.
Your API key grants access to our Cloudflare R2 archive: months of normalized, ZSTD-compressed, Hive-partitioned Parquet files. DuckDB-native. Polars-ready. SELECT * FROM 's3://algotick/.../chain=solana/*/*.parquet'

From zero to live trading signals in 60 seconds

pip install algotick   # or copy algotick.py into your project

import asyncio
from algotick import AlgoTickClient

async def main():
    client = AlgoTickClient(api_key="sk_live_...")

    # 1. Check macro safety — is the market stable?
    gex = await client.get_gamma_exposure()
    if gex["aggregate_gex"] < -50:
        print("Market unstable. Halting.")
        return

    # 2. Stream normalized cross-chain events
    async def on_event(data):
        print(f"{data['stream_type']} on {data['chain']}: {data['data']}")

    await client.stream(
        channels=["solana.swaps", "ethereum.flashbots_bids"],
        callback=on_event
    )

asyncio.run(main())

That's it. No WebSocket reconnection logic. No JSON schema parsing. No deduplication code. Install the SDK, pass your API key, and get back to writing alpha.

How AlgoTick Compares

ProviderWhat They SellYour CostAlgoTick Difference
Tardis.dev / DatabentoRaw recorded exchange WebSocket CSVs$100–1,000/moWe add derived signals (GEX, Imbalance, Regime) on top of the raw ticks
Glassnode / CoinMetricsOn-chain data (free if you run a node)$1,000+/moWe cover DeFi firehoses (DEX swaps, LP events, MEV bids) — not just chain metrics
Artemis.xyzSmart contract activity aggregation$500+/moWe provide real-time WebSocket streams, not just daily REST snapshots
Custom BuildYour own Go/Python pipeline3–6 months eng timeWe maintain 12 streamers across 5 chains so you don't have to

The Nightmare You're Avoiding

Binance WS Hyperliquid WS Deribit WS Solana RPC ×3 Base RPC Arbitrum RPC Ethereum RPC Flashbots Relay ×4 Pyth Oracle Polymarket
Frankfurt Data Citadel
12 Go Streamers • Dedup Engine • Black-Scholes • ClickHouse • Redis Pub/Sub
{"stream_type": "dex_swap", "chain": "solana", "timestamp_ms": 1710362694000, "data": {...}}

You get one clean JSON stream. We handle the 10 connections, the deduplication, the math, and the archival.

REST API Endpoints

MethodEndpointDescription
GET/v1/snapshotReal-time market snapshot with 39 metrics
GET/v1/signals/volatilityRealized volatility and regime per coin
GET/v1/signals/spreadsCross-venue spreads and funding rates
GET/v1/signals/compositeMulti-factor composite trading signal
GET/v1/signals/correlationCross-asset correlation matrix
GET/v1/signals/whale-flowWhale order flow and imbalance
GET/v1/signals/depthOrder book depth bands
GET/v1/signals/imbalanceOrder book bid/ask imbalance
GET/v1/signals/liquidationsLiquidation alerts and thresholds
GET/v1/signals/priority-gasEthereum gas prices and congestion
GET/v3/signals/regimeHMM market regime classification
GET/v3/signals/squeezeShort squeeze probability and direction
GET/v3/signals/arbitrageArbitrage opportunities and yields
GET/v3/signals/smart-moneySmart money wallet tracking
GET/v3/signals/safetyCross-signal coherence and safety
GET/v3/signals/gamma-exposureLive Dealer Gamma Exposure (GEX)
GET/v3/analytics/queryHistorical data query (ClickHouse)
GET/v4/signals/liquidity-voidsOrderbook liquidity void detection
GET/v4/signals/mempool-congestionEthereum mempool congestion score
GET/v4/reference/symbologyToken symbol ↔ contract address mapping

WebSocket Channels

Connect to wss://ws.algotick.dev/v1/stream?api_key=YOUR_KEY and subscribe to any combination of channels.

TypeChannelDescription
Streamsolana.swapsReal-time Solana DEX swaps (Raydium, Orca, Jupiter)
Streamethereum.swapsEthereum DEX swaps (Uniswap V3)
Streambase.swapsBase L2 DEX swaps (Aerodrome, Uniswap)
Streamarbitrum.swapsArbitrum DEX swaps (Uniswap V3)
Streamethereum.lp_eventsLP Mint/Burn events across EVM DEXs
Streamethereum.flashbots_bidsFlashbots MEV builder bid stream
Streamhyperliquid.tradesHyperliquid perpetual trades
Streamhyperliquid.liquidationsHyperliquid liquidation events
Streamsignals.*All derived alpha signals (GEX, imbalance, regime)

Quick Start

# Get your API key and start querying in seconds

# 1. Market snapshot — 39 real-time metrics
curl https://algotick.dev/v1/snapshot?api_key=YOUR_KEY

# 2. Dealer Gamma Exposure (pre-calculated Black-Scholes)
curl https://algotick.dev/v3/signals/gamma-exposure?api_key=YOUR_KEY

# 3. Orderbook liquidity void detection
curl https://algotick.dev/v4/signals/liquidity-voids?coin=BTC&api_key=YOUR_KEY

# 4. Flashbots MEV congestion score
curl https://algotick.dev/v4/signals/mempool-congestion?api_key=YOUR_KEY

R2 Data Lake — Backtest the Past

🗃 Hive-Partitioned Parquet
DuckDB & Polars Native
Time-sorted, ZSTD-compressed, Hive-partitioned Parquet files. Query directly from R2 with DuckDB — no download required. We pre-sort by timestamp for 10x faster min/max chunk filtering.
📂 Events vs. States
Clean Backtest Architecture
/events/ = trades, liquidations, DEX swaps, LP events, MEV bids. /states/ = L2 book snapshots, GEX metrics, oracle prices. Load each into its own DataFrame, then asof_merge to backtest execution slippage perfectly.
# Query 3 months of Solana DEX swaps directly from R2 (no download)
import duckdb

conn = duckdb.connect()
df = conn.sql("""
    SELECT * FROM read_parquet(
        's3://algotick-data-lake/events/swaps/chain=solana/year=2026/month=*/day=*/data.parquet'
    ) WHERE amount_usd > 10000
    ORDER BY timestamp_ms
""").df()

print(f"{len(df):,} whale swaps found")

Pricing

🤖 Solo Quant
$299/mo
• All REST API endpoints
• WebSocket stream (100 msg/s)
• R2 Data Lake (90-day history)
• Python SDK
• Email support
🏆 Institutional
$1,500/mo
• Everything in Solo Quant
• Unlimited WebSocket rate
• R2 Data Lake (full history)
• Priority Slack channel
• Custom signal derivations
🛠 Enterprise
Custom
• Dedicated Frankfurt endpoint
• Co-located data delivery
• Custom chain integrations
• SLA guarantee
• Direct engineering access

Python SDK

pip install algotick or grab algotick-python from GitHub.

import asyncio
from algotick import AlgoTickClient

async def on_market_event(data):
    # Fires the millisecond a Solana swap or Hyperliquid trade happens
    print(f"{data['stream_type']} | {data['chain']} | {data['data']}")

async def main():
    client = AlgoTickClient(api_key="sk_live_12345")

    # 1. Check macro safety via REST
    gex = await client.get_gamma_exposure()
    if gex["aggregate_gex"] < -50:
        print("Market unstable. Halting execution.")
        return

    # 2. Stream normalized cross-chain events via Go WebSocket
    await client.stream(
        channels=["solana.swaps", "hyperliquid.liquidations"],
        callback=on_market_event
    )

asyncio.run(main())
🤖 Building an AI agent? We natively support Python, TypeScript, ElizaOS, and LangChain. Cookbook & Templates → llms.txt