Live market structure signals — CFTC COT + CME settlements

Futures Market Structure,
Developer-Ready.

Open interest, COT positioning, term structure, and roll pressure — the signals traders actually need, delivered as clean, typed API responses. Not another data feed. A signal engine.

See the Code → View Pricing
576+
Tests Passing
6
Signal Types
<50ms
Cached Response
3-Tier
Access Control
ES Smart Money Z-Score +2.1σ CL Term Structure Backwardated NQ Retail Contrarian Bullish GC Roll Pressure Elevated ES Contango Alert Active CL OI Decay -12.3% NQ Composite Signal Strong Long ES Smart Money Z-Score +2.1σ CL Term Structure Backwardated NQ Retail Contrarian Bullish GC Roll Pressure Elevated ES Contango Alert Active CL OI Decay -12.3% NQ Composite Signal Strong Long
// Capabilities

Everything a Futures Trader Needs

Six signal engines working together. Each produces structured, typed responses — not raw data dumps. Built for systematic traders, quants, and developers who need clean signals, not cleanup work.

📊
Positioning Signals
Smart money Z-scores, retail contrarian signals, and composite direction from CFTC COT data. Rolling lookback windows with percentile rankings.
📈
Term Structure
Contango/backwardation detection, polynomial curve fitting, calendar spread ratios, and slope metrics across the full futures curve.
🔄
Roll Pressure
OI decay analysis, roll impact scoring, volume shift estimation, and expected slippage modeling. Know when rolls create dislocations.
📅
Roll Calendar
Automatic contract expiry calculation, roll window estimation, roll urgency scoring, and historical roll pattern analysis.
⚡
Real-time WebSocket
Tier-gated streaming signals over WebSocket. Subscribe by contract and signal type. Auto-reconnect, heartbeat, and Redis pub/sub for scale.
🔍
Data Quality
Staleness checks, gap detection, completeness scoring, and validation pipelines. Trust your data before trusting your signals.
// Signal Engine

Six Signals. One API.

Each signal type is computed from raw CFTC and CME data, validated, and served as a structured response. No parsing, no cleaning, no guesswork.

🎯
Smart Money
Commercial Z-score & percentile
LIVE
👥
Retail Contrarian
Non-reportable positioning
LIVE
🧭
Composite Direction
Multi-factor signal fusion
LIVE
📉
Contango/Backwardation
Curve classification + alerts
LIVE
⚙️
Roll Pressure Index
OI decay + impact scoring
LIVE
📐
Term Structure Slope
Curve gradient + spread ratios
LIVE
📊
COT Raw + Metrics
Full CFTC reports + Z-scores
SCHEDULED
🔔
Contango Alerts
State change detection
LIVE
// Developer Experience

Clean Code, Zero Friction

Python SDK with sync and async clients. Builder pattern. Typed responses. WebSocket streaming client with auto-reconnect. Get signals in 5 lines.

# Install
$ pip install openinterest-lens

# Get positioning signals in 5 lines
from openinterest_lens import OpenInterestLensClient

client = OpenInterestLensClient(api_key="oil_sk_live_...")
signal = client.get_signals("ES", signal_type="positioning")

print(signal.smart_money.z_score)      # 2.14
print(signal.smart_money.percentile)   # 96.5
print(signal.composite.direction)      # "long"
print(signal.composite.confidence)     # 0.87
# Get term structure
curl -H "X-API-Key: oil_sk_live_..." \
     "https://api.openinterestlens.melabuilt.ai/v1/term-structure/ES"

# Get COT data with Z-scores
curl -H "X-API-Key: oil_sk_live_..." \
     "https://api.openinterestlens.melabuilt.ai/v1/cot/CL?start_date=2026-01-01"

# Get roll pressure
curl -H "X-API-Key: oil_sk_live_..." \
     "https://api.openinterestlens.melabuilt.ai/v1/roll-pressure/NQ"
# Stream signals in real-time
import asyncio
from openinterest_lens.websocket import AsyncSignalStream

async def main():
    stream = AsyncSignalStream(
        api_key="oil_sk_live_...",
        contracts=["ES", "CL"],
        signal_types=["positioning", "term_structure"],
    )
    async for signal in stream:
        print(f"{signal['contract']}: {signal['signal_type']}")

asyncio.run(main())
# Async client with retry + builder pattern
from openinterest_lens import ClientBuilder

client = (
    ClientBuilder()
        .api_key("oil_sk_live_...")
        .base_url("https://api.openinterestlens.melabuilt.ai")
        .timeout(30)
        .max_retries(3)
        .retry_delay(1.5)
        .build_async()
)

async for signal in client.stream_signals(contracts=["ES"]):
    print(signal.composite.direction)
// Architecture

Built for Production

FastAPI + SQLAlchemy 2.0 + Redis + TimescaleDB. Async from top to bottom. Docker-ready with CI/CD pipeline.

Data Source
CFTC + CME
→
Ingestion
Scheduler + Validators
→
Storage
TimescaleDB
→
Signal Engine
6 Compute Modules
→
Cache
Redis
→
Delivery
REST + WebSocket
// Pricing

Start Free. Scale Up.

Tiered access with real rate limits. No fake "enterprise" walls — just clear, honest pricing for developers and trading firms.

Free
$0
For exploring and building.
  • ES, NQ, CL contracts
  • 60 requests/hour
  • 4 weeks historical data
  • Positioning signals
  • Roll pressure
  • WebSocket streaming
  • Historical term structure
Start Free
Pro
$49/mo
Full signal coverage for traders.
  • All 50+ contracts
  • 600 requests/hour
  • 2 years historical data
  • Roll pressure + term structure
  • WebSocket streaming
  • Contango/backwardation alerts
  • Priority support
  • Custom data exports
Start Pro Trial
Enterprise
Custom
Dedicated infrastructure and support.
  • Unlimited contracts
  • 6,000 requests/hour
  • 5 years historical data
  • All signal types
  • Priority WebSocket feeds
  • Custom data exports
  • Dedicated support
  • SLA guarantees
Contact Sales