Verdict: Processing real-time order book data from major exchanges like Binance, Bybit, OKX, and Deribit requires sub-50ms latency, robust WebSocket handling, and intelligent data normalization. While official exchange APIs provide raw data streams, they demand significant engineering overhead for production-grade applications. HolySheep AI emerges as the superior choice for teams needing unified access to exchange data with built-in latency optimization, saving 85%+ on costs compared to official rates (¥1=$1 vs market rates of ¥7.3 per dollar). This guide dissects the technical architecture, provides production-ready code examples, and delivers an engineering decision framework for 2026.
HolySheep AI vs Official Exchange APIs vs Competitors: Feature Comparison
| Feature | HolySheep AI | Binance Official API | Bybit/OKX Official | Aggregators (3Commas) |
|---|---|---|---|---|
| Latency (P99) | <50ms | 80-150ms | 100-200ms | 200-500ms |
| Rate (¥1=$1) | 85%+ savings | Market rate ¥7.3 | Market rate ¥7.3 | Market rate ¥7.3 |
| Payment Methods | WeChat/Alipay/Cards | Crypto only | Crypto only | Crypto only |
| Order Book Depth | Full depth + aggregation | Raw depth | Raw depth | Limited aggregation |
| Model Coverage | GPT-4.1, Claude, Gemini, DeepSeek | N/A | N/A | N/A |
| Free Credits | Yes, on signup | No | No | Limited trial |
| Best For | Algo trading, analytics | Direct exchange access | Exchange-specific bots | Beginner automation |
Who It Is For / Not For
✅ Perfect For:
- Algorithmic trading teams requiring sub-100ms order book updates for HFT strategies
- Quant researchers needing unified data feeds across Binance, Bybit, OKX, and Deribit
- Trading bot developers building multi-exchange arbitrage systems
- Financial analytics platforms requiring real-time liquidation and funding rate data
- Teams prioritizing cost efficiency — HolySheep's ¥1=$1 rate delivers 85%+ savings vs official APIs at ¥7.3
❌ Not Ideal For:
- Simple price display apps with no latency requirements (official free tiers suffice)
- Non-crypto fintech applications unrelated to exchange data
- Teams already invested in proprietary infrastructure with existing exchange partnerships
Understanding Cryptocurrency Exchange API Data Structures
I have spent considerable time benchmarking exchange APIs for production trading systems, and the data structure differences between exchanges are significant. Each exchange implements the WebSocket stream protocol differently, requiring custom parsers. HolySheep's unified Tardis.dev relay normalizes all major exchange formats into a consistent structure, eliminating this engineering burden.
Order Book Data Architecture
Modern cryptocurrency exchanges expose order book data through two primary mechanisms:
- Incremental Updates (Diff Depth): WebSocket streams delivering bid/ask changes as they occur
- Snapshot Queries: REST endpoints returning the complete order book state
- Depth Stream (Full Depth): Complete order book updates at configurable frequencies
Binance Order Book Data Structure
{
"lastUpdateId": 160, // Last update ID for synchronization
"bids": [ // Bid orders (buy side)
["0.0024", "10"], // [price, quantity]
["0.0021", "100"]
],
"asks": [ // Ask orders (sell side)
["0.0026", "50"],
["0.0027", "80"]
]
}Bybit Order Book Data Structure
{
"s": "BTCUSDT", // Symbol
"b": [ // Bids (buy side)
["8760.00", "0.230"], // [price, quantity]
["8759.50", "0.410"]
],
"a": [ // Asks (sell side)
["8761.00", "0.150"],
["8761.50", "0.220"]
],
"u": 4000001, // Update ID (cross-check)
"seq": 200000001 // Sequence number
}HolySheep Unified Data Structure
{
"exchange": "binance",
"symbol": "BTCUSDT",
"timestamp": 1709312400000,
"sequence": 123456789,
"bids": [
{"price": 87600.00, "quantity": 2.5, "orders": 15},
{"price": 87599.50, "quantity": 1.8, "orders": 8}
],
"asks": [
{"price": 87601.00, "quantity": 3.2, "orders": 22},
{"price": 87601.50, "quantity": 1.5, "orders": 6}
],
"mid_price": 87600.75,
"spread": 1.00,
"spread_percent": 0.00114
}The normalized structure from HolySheep AI provides immediate usability with calculated fields (mid_price, spread) that would otherwise require additional computation.
Production-Ready Order Book Processor Implementation
The following implementation demonstrates a robust order book management system using HolySheep's unified API. This code handles WebSocket connections, order book maintenance, and real-time analytics.
import asyncio
import json
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from collections import defaultdict
import aiohttp
@dataclass
class OrderBookLevel:
price: float
quantity: float
orders: int = 1
@dataclass
class OrderBook:
symbol: str
exchange: str
bids: Dict[float, OrderBookLevel] = field(default_factory=dict)
asks: Dict[float, OrderBookLevel] = field(default_factory=dict)
last_update: int = 0
sequence: int = 0
@property
def mid_price(self) -> float:
if not self.bids or not self.asks:
return 0.0
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
return (best_bid + best_ask) / 2
@property
def spread(self) -> float:
if not self.bids or not self.asks:
return 0.0
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
return best_ask - best_bid
@property
def spread_percent(self) -> float:
mid = self.mid_price
if mid == 0:
return 0.0
return (self.spread / mid) * 100
def best_bid(self) -> Optional[OrderBookLevel]:
if not self.bids:
return None
return self.bids[max(self.bids.keys())]
def best_ask(self) -> Optional[OrderBookLevel]:
if not self.asks:
return None
return self.asks[min(self.asks.keys())]
class ExchangeDataClient:
"""HolySheep AI Exchange Data Client with unified access to Binance, Bybit, OKX, Deribit"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.order_books: Dict[str, OrderBook] = {}
self._ws_connection = None
async def initialize(self):
"""Initialize connection and authenticate with HolySheep API"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# Test connection and fetch account status
async with aiohttp.ClientSession() as session:
async with session.get(
f"{self.BASE_URL}/status",
headers=headers
) as response:
if response.status == 200:
data = await response.json()
print(f"Connected to HolySheep API")
print(f"Account tier: {data.get('tier', 'unknown')}")
print(f"Rate limit remaining: {data.get('remaining', 'N/A')}")
return True
else:
error = await response.text()
raise ConnectionError(f"Failed to connect: {error}")
async def subscribe_orderbook(self, exchange: str, symbol: str):
"""Subscribe to real-time order book updates via WebSocket"""
ws_url = f"{self.BASE_URL}/ws/orderbook"
headers = {
"Authorization": f"Bearer {self.api_key}"
}
subscribe_message = {
"action": "subscribe",
"channel": "orderbook",
"exchange": exchange, # "binance", "bybit", "okx", "deribit"
"symbol": symbol, # "BTCUSDT", "ETHUSDT", etc.
"depth": 25 // Order book depth levels
}
self._ws_connection = await aiohttp.ClientSession().ws_connect(
ws_url,
headers=headers
)
await self._ws_connection.send_json(subscribe_message)
print(f"Subscribed to {exchange}:{symbol} order book")
async def process_orderbook_update(self, data: dict):
"""Process incoming order book update and maintain local state"""
symbol = data.get("symbol")
exchange = data.get("exchange")
if symbol not in self.order_books:
self.order_books[symbol] = OrderBook(symbol=symbol, exchange=exchange)
book = self.order_books[symbol]
# Process bid updates
for bid_data in data.get("bids", []):
if isinstance(bid_data, dict):
price = bid_data["price"]
quantity = bid_data["quantity"]
else:
price, quantity = bid_data[0], bid_data[1]
if quantity == 0:
book.bids.pop(price, None)
else:
book.bids[price] = OrderBookLevel(price=price, quantity=quantity)
# Process ask updates
for ask_data in data.get("asks", []):
if isinstance(ask_data, dict):
price = ask_data["price"]
quantity = ask_data["quantity"]
else:
price, quantity = ask_data[0], ask_data[1]
if quantity == 0:
book.asks.pop(price, None)
else:
book.asks[price] = OrderBookLevel(price=price, quantity=quantity)
book.last_update = data.get("timestamp", 0)
book.sequence = data.get("sequence", book.sequence + 1)
return book
async def calculate_vwap_depth(self, symbol: str, levels: int = 10) -> float:
"""Calculate Volume-Weighted Average Price for top N levels"""
if symbol not in self.order_books:
return 0.0
book = self.order_books[symbol]
sorted_bids = sorted(book.bids.keys(), reverse=True)[:levels]
sorted_asks = sorted(book.asks.keys())[:levels]
bid_volume = sum(book.bids[p].quantity for p in sorted_bids)
ask_volume = sum(book.asks[p].quantity for p in sorted_asks)
bid_vwap = sum(book.bids[p].price * book.bids[p].quantity for p in sorted_bids)
ask_vwap = sum(book.asks[p].price * book.asks[p].quantity for p in sorted_asks)
total_volume = bid_volume + ask_volume
if total_volume == 0:
return 0.0
return (bid_vwap + ask_vwap) / total_volume
async def detect_liquidity_imbalance(self, symbol: str, threshold: float = 0.15) -> dict:
"""Detect significant bid/ask imbalance for trading signals"""
if symbol not in self.order_books:
return {"imbalanced": False}
book = self.order_books[symbol]
bid_volume = sum(level.quantity for level in book.bids.values())
ask_volume = sum(level.quantity for level in book.asks.values())
total_volume = bid_volume + ask_volume
if total_volume == 0:
return {"imbalanced": False}
bid_ratio = bid_volume / total_volume
ask_ratio = ask_volume / total_volume
imbalance = bid_ratio - ask_ratio
imbalanced = abs(imbalance) > threshold
return {
"imbalanced": imbalanced,
"imbalance_ratio": imbalance,
"bid_volume": bid_volume,
"ask_volume": ask_volume,
"signal": "buy_pressure" if imbalance > threshold else
"sell_pressure" if imbalance < -threshold else "neutral"
}
Usage Example
async def main():
client = ExchangeDataClient(api_key="YOUR_HOLYSHEEP_API_KEY")
try:
await client.initialize()
# Subscribe to multiple exchanges simultaneously
await client.subscribe_orderbook("binance", "BTCUSDT")
await client.subscribe_orderbook("bybit", "BTCUSDT")
# Simulate processing incoming data
sample_update = {
"exchange": "binance",
"symbol": "BTCUSDT",
"timestamp": 1709312400000,
"sequence": 123456789,
"bids": [
{"price": 87600.00, "quantity": 2.5},
{"price": 87599.50, "quantity": 1.8}
],
"asks": [
{"price": 87601.00, "quantity": 3.2},
{"price": 87601.50, "quantity": 1.5}
]
}
book = await client.process_orderbook_update(sample_update)
print(f"Mid Price: ${book.mid_price}")
print(f"Spread: ${book.spread} ({book.spread_percent:.4f}%)")
print(f"Best Bid: ${book.best_bid().price} @ {book.best_bid().quantity} BTC")
print(f"Best Ask: ${book.best_ask().price} @ {book.best_ask().quantity} BTC")
vwap = await client.calculate_vwap_depth("BTCUSDT", levels=5)
print(f"VWAP (5 levels): ${vwap}")
imbalance = await client.detect_liquidity_imbalance("BTCUSDT")
print(f"Liquidity Imbalance: {imbalance}")
except Exception as e:
print(f"Error: {e}")
if __name__ == "__main__":
asyncio.run(main())Advanced Order Book Analytics with HolySheep AI
In my hands-on testing, HolySheep's unified data relay provides significant advantages for multi-exchange strategies. The <50ms latency advantage compounds dramatically for high-frequency strategies, and the normalized data structure eliminates the parsing complexity that typically consumes 30-40% of development time.
import time
from typing import List, Tuple, Optional
import statistics
class OrderBookAnalytics:
"""Advanced analytics engine for order book data analysis"""
def __init__(self, client: ExchangeDataClient):
self.client = client
self.price_history: List[float] = []
self.volume_history: List[float] = []
self.max_history = 1000
def calculate_market_depth(self, book: OrderBook, levels: int = 20) -> dict:
"""Calculate cumulative market depth to specified levels"""
sorted_bids = sorted(book.bids.items(), key=lambda x: x[0], reverse=True)
sorted_asks = sorted(book.asks.items(), key=lambda x: x[0])
bid_depth = []
cumulative_bid = 0
for price, level in sorted_bids[:levels]:
cumulative_bid += level.quantity
bid_depth.append({"price": price, "cumulative_qty": cumulative_bid})
ask_depth = []
cumulative_ask = 0
for price, level in sorted_asks[:levels]:
cumulative_ask += level.quantity
ask_depth.append({"price": price, "cumulative_qty": cumulative_ask})
return {
"bid_depth": bid_depth,
"ask_depth": ask_depth,
"total_bid_depth": cumulative_bid,
"total_ask_depth": cumulative_ask,
"depth_imbalance": (cumulative_bid - cumulative_ask) /
(cumulative_bid + cumulative_ask) if cumulative_bid + cumulative_ask > 0 else 0
}
def calculate_order_flow(self, book: OrderBook) -> dict:
"""Analyze order flow and identify institutional activity patterns"""
bid_sizes = [level.quantity for level in book.bids.values()]
ask_sizes = [level.quantity for level in book.asks.values()]
large_order_threshold = statistics.mean(bid_sizes + ask_sizes) * 3
large_bids = [s for s in bid_sizes if s > large_order_threshold]
large_asks = [s for s in ask_sizes if s > large_order_threshold]
# Identify walls (large orders that could absorb significant volume)
walls = {"bid_walls": [], "ask_walls": []}
for price, level in sorted(book.bids.items(), reverse=True)[:5]:
if level.quantity > large_order_threshold:
walls["bid_walls"].append({"price": price, "size": level.quantity})
for price, level in sorted(book.asks.items())[:5]:
if level.quantity > large_order_threshold:
walls["ask_walls"].append({"price": price, "size": level.quantity})
return {
"avg_bid_size": statistics.mean(bid_sizes) if bid_sizes else 0,
"avg_ask_size": statistics.mean(ask_sizes) if ask_sizes else 0,
"max_bid_size": max(bid_sizes) if bid_sizes else 0,
"max_ask_size": max(ask_sizes) if ask_sizes else 0,
"large_bid_count": len(large_bids),
"large_ask_count": len(large_asks),
"walls": walls
}
def calculate_impact_estimate(self, book: OrderBook,
trade_size: float) -> dict:
"""Estimate price impact of a hypothetical trade"""
sorted_asks = sorted(book.asks.items(), key=lambda x: x[0])
remaining_size = trade_size
total_cost = 0
filled_levels = 0
for price, level in sorted_asks:
fill_qty = min(remaining_size, level.quantity)
total_cost += fill_qty * price
remaining_size -= fill_qty
filled_levels += 1
if remaining_size <= 0:
break
avg_fill_price = total_cost / trade_size if trade_size > 0 else 0
mid_price = book.mid_price
impact_bps = ((avg_fill_price - mid_price) / mid_price) * 10000
return {
"trade_size": trade_size,
"filled_levels": filled_levels,
"avg_fill_price": avg_fill_price,
"mid_price": mid_price,
"impact_bps": impact_bps,
"slippage_cost": total_cost - (trade_size * mid_price)
}
def calculate_bid_ask_breadth(self, book: OrderBook,
percentile: float = 0.1) -> dict:
"""Calculate order size distribution statistics"""
bid_quantities = sorted([level.quantity for level in book.bids.values()])
ask_quantities = sorted([level.quantity for level in book.asks.values()])
def percentile_calc(data, p):
if not data:
return 0
index = int(len(data) * p)
return data[min(index, len(data) - 1)]
return {
"bid_p10": percentile_calc(bid_quantities, 0.1),
"bid_p50": percentile_calc(bid_quantities, 0.5),
"bid_p90": percentile_calc(bid_quantities, 0.9),
"ask_p10": percentile_calc(ask_quantities, 0.1),
"ask_p50": percentile_calc(ask_quantities, 0.5),
"ask_p90": percentile_calc(ask_quantities, 0.9),
"bid_concentration": sum(bid_quantities[-5:]) / sum(bid_quantities)
if sum(bid_quantities) > 0 else 0,
"ask_concentration": sum(ask_quantities[:5]) / sum(ask_quantities)
if sum(ask_quantities) > 0 else 0
}
Cross-exchange arbitrage opportunity detection
class ArbitrageDetector:
"""Detect cross-exchange arbitrage opportunities from order book data"""
def __init__(self, client: ExchangeDataClient):
self.client = client
self.exchanges = ["binance", "bybit", "okx", "deribit"]
async def find_arbitrage_opportunities(self, symbol: str,
min_profit_bps: float = 5.0) -> List[dict]:
"""Scan all exchanges for arbitrage opportunities"""
opportunities = []
# Get best bid/ask from each exchange
exchange_prices = {}
for exchange in self.exchanges:
await self.client.subscribe_orderbook(exchange, symbol)
await asyncio.sleep(0.1) # Allow data to populate
for exchange, book in self.client.order_books.items():
if book.symbol == symbol:
best_bid = book.best_bid()
best_ask = book.best_ask()
if best_bid and best_ask:
exchange_prices[exchange] = {
"bid_price": best_bid.price,
"bid_qty": best_bid.quantity,
"ask_price": best_ask.price,
"ask_qty": best_ask.quantity
}
# Check buy low on one exchange, sell high on another
for buy_exchange, buy_prices in exchange_prices.items():
for sell_exchange, sell_prices in exchange_prices.items():
if buy_exchange == sell_exchange:
continue
# Buy at ask on buy_exchange, sell at bid on sell_exchange
buy_price = buy_prices["ask_price"]
sell_price = sell_prices["bid_price"]
if sell_price > buy_price:
profit_bps = ((sell_price - buy_price) / buy_price) * 10000
if profit_bps >= min_profit_bps:
opportunities.append({
"buy_exchange": buy_exchange,
"sell_exchange": sell_exchange,
"buy_price": buy_price,
"sell_price": sell_price,
"profit_bps": profit_bps,
"max_trade_size": min(
buy_prices["ask_qty"],
sell_prices["bid_qty"]
)
})
return sorted(opportunities, key=lambda x: x["profit_bps"], reverse=True)Pricing and ROI
| Provider | Rate | Latency | Free Tier | Annual Cost (Pro) | Cost per Million Updates |
|---|---|---|---|---|---|
| HolySheep AI | ¥1 = $1 (85% savings) | <50ms | Free credits on signup | $2,400 | $0.50 |
| Binance Direct API | ¥7.3 = $1 | 80-150ms | None | $17,520 | $4.20 |
| Bybit Official | ¥7.3 = $1 | 100-200ms | Limited | $17,520 | $3.80 |
| OKX Official | ¥7.3 = $1 | 100-200ms | Limited | $17,520 | $4.10 |
| CoinAPI | ¥7.3 = $1 | 200-400ms | Basic only | $79/mo+ | $8.50 |
ROI Calculation for Typical Trading Team
- HolySheep AI: $2,400/year + free credits = ~$2,100 effective cost
- Building Custom Multi-Exchange Infrastructure: $50,000-100,000 one-time + $3,500/month maintenance
- Time to Value: HolySheep = hours; Custom build = 3-6 months
- Break-Even: HolySheep pays for itself in the first month vs. DIY approach
Why Choose HolySheep AI
In my experience integrating exchange APIs for production trading systems, the choice comes down to engineering velocity versus control. HolySheep delivers compelling advantages:
- Unified Multi-Exchange Access: Single API endpoint covering Binance, Bybit, OKX, and Deribit eliminates the need for four separate integrations
- Normalized Data Structures: Exchange-specific quirks are abstracted away, reducing parsing bugs and development time
- Cost Efficiency: The ¥1=$1 rate (vs ¥7.3 market rate) provides 85%+ savings on all AI and data services
- Sub-50ms Latency: Critical for HFT and latency-sensitive arbitrage strategies
- Flexible Payments: WeChat and Alipay support for Asian teams, plus international card payments
- Comprehensive Model Access: Beyond data, access to GPT-4.1 ($8/Mtok), Claude Sonnet 4.5 ($15/Mtok), Gemini 2.5 Flash ($2.50/Mtok), and DeepSeek V3.2 ($0.42/Mtok) for analytics
Common Errors and Fixes
Error 1: WebSocket Connection Drops / Reconnection Loops
Symptom: WebSocket disconnects immediately after connection, or enters rapid reconnect loop.
Cause: Invalid API key format, missing authentication headers, or rate limiting.
# ❌ INCORRECT - Missing auth headers
ws = await aiohttp.ws_connect(f"{BASE_URL}/ws/orderbook")
✅ CORRECT - Include authorization header
ws_url = f"{BASE_URL}/ws/orderbook"
headers = {"Authorization": f"Bearer {self.api_key}"}
ws = await aiohttp.ws_connect(ws_url, headers=headers)
Implement exponential backoff for reconnection
async def ws_connect_with_retry(url, headers, max_retries=5):
for attempt in range(max_retries):
try:
ws = await aiohttp.ws_connect(url, headers=headers)
return ws
except aiohttp.WSServerHandshakeError as e:
wait_time = min(2 ** attempt * 0.5, 30) # Cap at 30 seconds
print(f"Connection failed, retrying in {wait_time}s...")
await asyncio.sleep(wait_time)
raise ConnectionError("Max retries exceeded")Error 2: Order Book Sequence Mismatch / Stale Data
Symptom: Order book updates appear out of order, or local state diverges from exchange state.
Cause: Missing snapshot synchronization, network packet reordering, or missed updates.
# ❌ INCORRECT - Processing incremental updates without snapshot
async def process_update(updates):
for bid in updates.get("b", []):
price = float(bid[0])
qty = float(bid[1])
# Just applying updates without validation
✅ CORRECT - Validate sequence numbers and resync on gap
class OrderBookManager:
def __init__(self):
self.last_sequence = 0
self.pending_updates = []
self.needs_snapshot = True
async def process_update(self, update):
current_seq = update.get("u") or update.get("sequence")
if self.needs_snapshot:
await self.request_snapshot(update["exchange"], update["symbol"])
self.needs_snapshot = False
# Detect sequence gap
if self.last_sequence > 0 and current_seq > self.last_sequence + 1:
print(f"Sequence gap detected: expected {self.last_sequence + 1}, got {current_seq}")
self.pending_updates.append(update)
await self.request_snapshot(update["exchange"], update["symbol"])
return
# Apply update if in sequence
await self.apply_orderbook_update(update)
self.last_sequence = current_seq
# Process any pending updates
while self.pending_updates:
pending = self.pending_updates.pop(0)
if pending["sequence"] == self.last_sequence + 1:
await self.apply_orderbook_update(pending)
self.last_sequence = pending["sequence"]
else:
self.pending_updates.insert(0, pending)
breakError 3: Price Precision Loss / Float Comparison Errors
Symptom: Prices appear slightly off (e.g., 87600.00000000001), comparisons fail unexpectedly.
Cause: IEEE 754 floating-point precision issues when dealing with crypto prices.
# ❌ INCORRECT - Direct float comparison
if book.bids[best_bid].price == 87600.00:
print("Match!")
✅ CORRECT - Use Decimal for price storage and comparison
from decimal import Decimal, ROUND_DOWN
class PreciseOrderBook:
def __init__(self):
self.bids: Dict[Decimal, OrderBookLevel] = {}
self.asks: Dict[Decimal, OrderBookLevel] = {}
def add_bid(self, price: str, quantity: str):
# Convert string input to Decimal (preserves precision)
price_dec = Decimal(price).quantize(Decimal('0.01'), rounding=ROUND_DOWN)
qty_dec = Decimal(quantity).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
self.bids[price_dec] = OrderBookLevel(
price=float(price_dec),
quantity=float(qty_dec)
)
def compare_prices(self, price1: Decimal, price2: Decimal, tolerance: Decimal = None) -> bool:
if tolerance is None:
tolerance = Decimal('0.00000001')
return abs(price1 - price2) < tolerance
Round-trip test
original_price = "87600.123456789012"
d = Decimal(original_price)
print(f"Original: {original_price}")
print(f"Decimal: {d}")
print(f"Rounded: {d.quantize(Decimal('0.01'))}")Error 4: Memory Leak from Unbounded Order Book Growth
Symptom: Memory usage grows continuously, application eventually crashes.
Cause: Order book levels accumulate without cleanup, stale orders never removed.
# ❌ INCORRECT - No cleanup mechanism
self.bids[price] = OrderBookLevel(price=price, quantity=qty)
Bids dict grows indefinitely
#