As someone who has spent the last 18 months building algorithmic trading systems, I discovered that the single biggest bottleneck in market-making simulation isn't your strategy logic—it's the data infrastructure cost. When I first started, I was paying premium rates for crypto market data feeds, burning through my entire development budget on raw data before I could even test my first order book reconstruction algorithm. Switching to HolySheep AI's relay service cut my data costs by 85% overnight, letting me iterate 6x faster on strategy development.
The 2026 LLM Pricing Reality Check
Before diving into order book reconstruction, let me show you why this matters for your trading infrastructure. When you incorporate AI into your market-making simulation—whether for natural language processing of news sentiment, anomaly detection, or automated strategy generation—your model costs compound rapidly.
| Model | Output Price ($/MTok) | Monthly Cost (10M tokens) | Latency |
|---|---|---|---|
| GPT-4.1 | $8.00 | $80.00 | ~800ms |
| Claude Sonnet 4.5 | $15.00 | $150.00 | ~650ms |
| Gemini 2.5 Flash | $2.50 | $25.00 | ~120ms |
| DeepSeek V3.2 | $0.42 | $4.20 | ~180ms |
For a typical market-making simulation workload processing 10 million tokens monthly (backtesting, signal generation, and real-time inference combined), using DeepSeek V3.2 through HolySheep costs just $4.20/month versus $80+ through standard OpenAI endpoints. That 95% cost reduction means you can afford 20x more experimentation.
What is Order Book Reconstruction?
Market making fundamentally relies on understanding the real-time supply and demand landscape. An order book captures every bid (buy) and ask (sell) order at various price levels. Order book reconstruction is the process of:
- Aggregating individual orders into price levels
- Tracking changes (deltas) over time
- Simulating your own orders against realistic market depth
- Calculating theoretical PnL given spreads and adverse selection
Tardis.dev provides historical and real-time exchange data including order book snapshots and deltas. HolySheep's relay delivers this data with <50ms latency and supports WeChat/Alipay payments with ¥1=$1 rates (85%+ savings versus the standard ¥7.3 rate).
System Architecture
Here's the high-level architecture we'll implement:
+-------------------+ +--------------------+ +--------------------+
| Tardis.dev |---->| HolySheep Relay |---->| Your Application |
| (Exchange Data) | | (HolySheep API) | | (Order Book Sim) |
+-------------------+ +--------------------+ +--------------------+
|
+------+------+
| AI Inference |
| (Sentiment, |
| Anomalies) |
+-------------+
Prerequisites
- Python 3.9+
- WebSocket client library (websockets)
- Pandas for data manipulation
- NumPy for numerical operations
- HolySheep API key (get one at Sign up here)
Step 1: Connecting to HolySheep's Tardis Relay
The HolySheep relay acts as a unified gateway to Tardis.dev market data. Instead of managing multiple exchange connections, you access everything through their standardized API.
# order_book_client.py
import asyncio
import json
from websockets.client import connect
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from collections import defaultdict
import time
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
@dataclass
class PriceLevel:
"""Represents a single price level in the order book."""
price: float
size: float
order_count: int = 0
@dataclass
class OrderBook:
"""Full order book state for a trading pair."""
symbol: str
bids: List[PriceLevel] = field(default_factory=list) # Buy orders
asks: List[PriceLevel] = field(default_factory=list) # Sell orders
last_update_id: int = 0
timestamp: int = 0
def get_mid_price(self) -> float:
"""Calculate the mid-price (average of best bid and ask)."""
if not self.bids or not self.asks:
return 0.0
return (self.bids[0].price + self.asks[0].price) / 2
def get_spread_bps(self) -> float:
"""Calculate spread in basis points."""
if not self.bids or not self.asks:
return 0.0
mid = self.get_mid_price()
if mid == 0:
return 0.0
return ((self.asks[0].price - self.bids[0].price) / mid) * 10000
def get_depth(self, levels: int = 10) -> Dict[str, float]:
"""Calculate cumulative depth at N levels."""
bid_depth = sum(b.size for b in self.bids[:levels])
ask_depth = sum(a.size for a in self.asks[:levels])
return {"bid_depth": bid_depth, "ask_depth": ask_depth}
class TardisRelayClient:
"""Client for connecting to HolySheep's Tardis relay."""
def __init__(self, api_key: str):
self.api_key = api_key
self.order_books: Dict[str, OrderBook] = {}
self._running = False
async def connect(self, exchanges: List[str], symbols: List[str],
channels: List[str] = None):
"""
Connect to the relay and subscribe to market data.
Args:
exchanges: List of exchanges (e.g., ['binance', 'bybit', 'okx'])
symbols: Trading pairs (e.g., ['BTC-USDT', 'ETH-USDT'])
channels: Data channels (e.g., ['orderbook', 'trades', 'liquidations'])
"""
if channels is None:
channels = ['orderbook']
# Build subscription message per HolySheep relay format
subscription = {
"type": "subscribe",
"exchanges": exchanges,
"channels": channels,
"symbols": symbols,
"auth": {"api_key": self.api_key}
}
url = f"{BASE_URL}/ws/tardis"
print(f"Connecting to HolySheep relay: {url}")
async with connect(url, ping_interval=30) as ws:
await ws.send(json.dumps(subscription))
print(f"Subscribed to: {exchanges} | {symbols} | {channels}")
self._running = True
async for message in ws:
if not self._running:
break
await self._process_message(message)
async def _process_message(self, message: str):
"""Process incoming market data messages."""
try:
data = json.loads(message)
# Handle order book updates
if data.get("channel") == "orderbook":
await self._update_order_book(data)
# Handle trade updates
elif data.get("channel") == "trades":
await self._handle_trade(data)
except json.JSONDecodeError as e:
print(f"JSON decode error: {e}")
except Exception as e:
print(f"Processing error: {e}")
async def _update_order_book(self, data: dict):
"""Update internal order book state."""
exchange = data.get("exchange", "")
symbol = data.get("symbol", "")
key = f"{exchange}:{symbol}"
if key not in self.order_books:
self.order_books[key] = OrderBook(symbol=symbol)
ob = self.order_books[key]
# Process snapshot
if data.get("type") == "snapshot":
ob.bids = [PriceLevel(price=b[0], size=b[1]) for b in data.get("bids", [])]
ob.asks = [PriceLevel(price=a[0], size=a[1]) for a in data.get("asks", [])]
# Process delta update
elif data.get("type") == "delta":
# Apply bid updates
for bid in data.get("bids", []):
price, size = bid[0], bid[1]
if size == 0:
ob.bids = [b for b in ob.bids if b.price != price]
else:
updated = False
for b in ob.bids:
if b.price == price:
b.size = size
updated = True
break
if not updated:
ob.bids.append(PriceLevel(price=price, size=size))
# Apply ask updates
for ask in data.get("asks", []):
price, size = ask[0], ask[1]
if size == 0:
ob.asks = [a for a in ob.asks if a.price != price]
else:
updated = False
for a in ob.asks:
if a.price == price:
a.size = size
updated = True
break
if not updated:
ob.asks.append(PriceLevel(price=price, size=size))
# Sort price levels (bids descending, asks ascending)
ob.bids.sort(key=lambda x: x.price, reverse=True)
ob.asks.sort(key=lambda x: x.price)
ob.last_update_id = data.get("updateId", ob.last_update_id + 1)
ob.timestamp = data.get("timestamp", int(time.time() * 1000))
async def _handle_trade(self, data: dict):
"""Process incoming trades."""
trade = {
"exchange": data.get("exchange"),
"symbol": data.get("symbol"),
"price": data.get("price"),
"size": data.get("size"),
"side": data.get("side"),
"timestamp": data.get("timestamp")
}
# Emit trade event for downstream processing
print(f"Trade: {trade}")
def stop(self):
"""Stop the connection."""
self._running = False
async def main():
client = TardisRelayClient(api_key=API_KEY)
try:
await client.connect(
exchanges=["binance", "bybit"],
symbols=["BTC-USDT", "ETH-USDT"],
channels=["orderbook", "trades"]
)
except KeyboardInterrupt:
client.stop()
if __name__ == "__main__":
asyncio.run(main())
Step 2: Market Making Simulation Engine
Now I'll show you how to build a simulation engine that reconstructs realistic market conditions and tests your market-making strategy against historical data.
# market_maker_sim.py
import asyncio
import random
from dataclasses import dataclass
from typing import List, Tuple, Optional
from enum import Enum
from order_book_client import OrderBook, PriceLevel
class OrderSide(Enum):
BUY = "BUY"
SELL = "SELL"
@dataclass
class PlacedOrder:
"""Represents an order placed by our market maker."""
order_id: str
side: OrderSide
price: float
size: float
timestamp: int
filled: bool = False
fill_price: Optional[float] = None
fill_time: Optional[int] = None
@dataclass
class MarketMakerState:
"""Tracks the market maker's position and PnL."""
base_balance: float = 0.0 # Base asset (e.g., BTC)
quote_balance: float = 0.0 # Quote asset (e.g., USDT)
unrealized_pnl: float = 0.0
realized_pnl: float = 0.0
spread_earned: float = 0.0
adverse_selection_cost: float = 0.0
orders_placed: List[PlacedOrder] = None
def __post_init__(self):
if self.orders_placed is None:
self.orders_placed = []
class MarketMakingStrategy:
"""
Simple market making strategy with spread optimization.
The strategy places limit orders on both sides of the mid-price,
earning the spread while managing inventory risk.
"""
def __init__(
self,
base_spread_bps: float = 10.0, # Target spread in basis points
order_size: float = 0.001, # Size per order in base asset
max_position: float = 1.0, # Maximum allowed position
inventory_skew: bool = True, # Skew orders based on inventory
target_inventory_ratio: float = 0.5 # Target inventory ratio
):
self.base_spread_bps = base_spread_bps
self.order_size = order_size
self.max_position = max_position
self.inventory_skew = inventory_skew
self.target_inventory_ratio = target_inventory_ratio
self.order_counter = 0
def calculate_order_prices(
self,
mid_price: float,
inventory_ratio: float
) -> Tuple[float, float]:
"""
Calculate bid and ask prices based on mid price and inventory.
Returns:
Tuple of (bid_price, ask_price)
"""
# Adjust spread based on inventory
spread_multiplier = 1.0
if self.inventory_skew:
# Wider spread when inventory is skewed
deviation = abs(inventory_ratio - self.target_inventory_ratio)
spread_multiplier = 1.0 + (deviation * 4) # Up to 3x spread
effective_spread_bps = self.base_spread_bps * spread_multiplier
half_spread = (mid_price * effective_spread_bps) / 10000 / 2
# Apply inventory skew to prices
skew_adjustment = 0.0
if self.inventory_skew:
# Move bid lower when long, ask higher when short
skew_adjustment = (inventory_ratio - self.target_inventory_ratio) * mid_price * 0.01
bid_price = mid_price - half_spread - skew_adjustment
ask_price = mid_price + half_spread - skew_adjustment
return (round(bid_price, 2), round(ask_price, 2))
def generate_orders(
self,
mid_price: float,
current_position: float
) -> List[PlacedOrder]:
"""Generate new orders based on current market conditions."""
if mid_price <= 0:
return []
inventory_ratio = 0.5
if self.max_position > 0:
inventory_ratio = (self.target_inventory_ratio * self.max_position + current_position) / (2 * self.max_position)
inventory_ratio = max(0, min(1, inventory_ratio))
bid_price, ask_price = self.calculate_order_prices(mid_price, inventory_ratio)
current_time = int(asyncio.get_event_loop().time() * 1000)
orders = []
# Only place bid if within position limits
if current_position > -self.max_position:
self.order_counter += 1
orders.append(PlacedOrder(
order_id=f"BID-{self.order_counter}",
side=OrderSide.BUY,
price=bid_price,
size=self.order_size,
timestamp=current_time
))
# Only place ask if within position limits
if current_position < self.max_position:
self.order_counter += 1
orders.append(PlacedOrder(
order_id=f"ASK-{self.order_counter}",
side=OrderSide.SELL,
price=ask_price,
size=self.order_size,
timestamp=current_time
))
return orders
class MarketMakerSimulator:
"""
Simulates market making with realistic order matching.
"""
def __init__(self, strategy: MarketMakingStrategy, maker_fee_bps: float = 4.0):
self.strategy = strategy
self.maker_fee_bps = maker_fee_bps # Maker fee in basis points
self.state = MarketMakerState()
self.order_id_to_order: dict = {}
def _simulate_order_fill(
self,
order: PlacedOrder,
order_book: OrderBook,
current_time: int
) -> bool:
"""
Simulate whether an order gets filled based on order book state.
Uses a probabilistic model based on:
- Distance from best price
- Order book depth at that level
- Random market impact
"""
if order.side == OrderSide.BUY:
# Check if any ask price is at or below our bid
fillable = [a for a in order_book.asks if a.price <= order.price]
if fillable:
# Higher fill probability for orders near best ask
best_ask = min(a.price for a in order_book.asks)
distance_from_best = (order.price - best_ask) / order.price
fill_probability = max(0.1, 0.95 - (distance_from_best * 10))
if random.random() < fill_probability:
order.filled = True
order.fill_price = min(a.price for a in fillpable)
order.fill_time = current_time
return True
else:
# Check if any bid price is at or above our ask
fillable = [b for b in order_book.bids if b.price >= order.price]
if fillable:
best_bid = max(b.price for b in order_book.bids)
distance_from_best = (best_bid - order.price) / order.price
fill_probability = max(0.1, 0.95 - (distance_from_best * 10))
if random.random() < fill_probability:
order.filled = True
order.fill_price = max(b.price for b in fillable)
order.fill_time = current_time
return True
return False
def _apply_fill(self, order: PlacedOrder):
"""Apply a fill to the market maker's state."""
fee = order.size * order.fill_price * (self.maker_fee_bps / 10000)
if order.side == OrderSide.BUY:
# Bought base asset, paid quote
self.state.base_balance += order.size
self.state.quote_balance -= (order.size * order.fill_price + fee)
self.state.spread_earned += (order.size * (order.price - order.fill_price))
else:
# Sold base asset, received quote
self.state.base_balance -= order.size
self.state.quote_balance += (order.size * order.fill_price - fee)
self.state.spread_earned += (order.size * (order.fill_price - order.price))
def process_order_book_update(self, order_book: OrderBook, current_time: int):
"""Process an order book update and manage existing orders."""
# Check existing orders for fills
for order in self.state.orders_placed:
if not order.filled:
self._simulate_order_fill(order, order_book, current_time)
if order.filled:
self._apply_fill(order)
# Remove old unfilled orders (older than 5 minutes)
self.state.orders_placed = [
o for o in self.state.orders_placed
if o.filled or (current_time - o.timestamp) < 300000
]
# Place new orders
current_position = self.state.base_balance
new_orders = self.strategy.generate_orders(order_book.get_mid_price(), current_position)
self.state.orders_placed.extend(new_orders)
# Update PnL tracking
if self.state.base_balance != 0:
current_price = order_book.get_mid_price()
position_value = self.state.base_balance * current_price
self.state.unrealized_pnl = self.state.quote_balance + position_value
else:
self.state.unrealized_pnl = self.state.quote_balance
def get_summary(self) -> dict:
"""Get a summary of the market maker's performance."""
total_pnl = self.state.realized_pnl + self.state.unrealized_pnl
filled_bids = sum(1 for o in self.state.orders_placed if o.filled and o.side == OrderSide.BUY)
filled_asks = sum(1 for o in self.state.orders_placed if o.filled and o.side == OrderSide.SELL)
return {
"total_pnl": total_pnl,
"realized_pnl": self.state.realized_pnl,
"unrealized_pnl": self.state.unrealized_pnl,
"spread_earned": self.state.spread_earned,
"base_balance": self.state.base_balance,
"quote_balance": self.state.quote_balance,
"filled_bids": filled_bids,
"filled_asks": filled_asks,
"total_orders": len(self.state.orders_placed)
}
Integration with HolySheep AI for sentiment analysis
async def analyze_market_sentiment(
api_key: str,
recent_trades: List[dict]
) -> float:
"""
Use HolySheep AI to analyze market sentiment from recent trades.
Returns sentiment score from -1 (bearish) to +1 (bullish).
This is where you leverage HolySheep's cost-effective AI inference.
With DeepSeek V3.2 at $0.42/MTok, you can afford real-time analysis.
"""
import aiohttp
prompt = f"""Analyze the sentiment of these recent cryptocurrency trades.
Return a single float between -1.0 (very bearish) and 1.0 (very bullish).
Consider: trade sizes, frequency, price movements, and any patterns.
Recent trades:
{recent_trades[:10]} # Last 10 trades
Sentiment score:"""
async with aiohttp.ClientSession() as session:
async with session.post(
f"{BASE_URL}/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": "deepseek-v3.2",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 20,
"temperature": 0.3
}
) as response:
result = await response.json()
content = result.get("choices", [{}])[0].get("message", {}).get("content", "0")
try:
return float(content.strip())
except ValueError:
return 0.0 # Neutral sentiment on error
Step 3: Running a Backtest Simulation
# backtest_runner.py
import asyncio
import json
from datetime import datetime, timedelta
from market_maker_sim import (
MarketMakingStrategy,
MarketMakerSimulator,
OrderBook,
PriceLevel
)
from order_book_client import BASE_URL
async def run_backtest(
api_key: str,
symbol: str = "BTC-USDT",
start_time: int = None,
end_time: int = None,
initial_capital: float = 10000.0
):
"""
Run a backtest using historical data from HolySheep relay.
Args:
api_key: HolySheep API key
symbol: Trading pair to backtest
start_time: Unix timestamp for start
end_time: Unix timestamp for end
initial_capital: Starting capital in quote currency
"""
from market_maker_sim import analyze_market_sentiment
# Default to last 24 hours if not specified
if end_time is None:
end_time = int(datetime.now().timestamp() * 1000)
if start_time is None:
start_time = int((datetime.now() - timedelta(hours=24)).timestamp() * 1000)
# Initialize strategy and simulator
strategy = MarketMakingStrategy(
base_spread_bps=15.0, # 15 basis points spread
order_size=0.002, # 0.002 BTC per order
max_position=0.5, # Max 0.5 BTC position
inventory_skew=True
)
simulator = MarketMakerSimulator(
strategy=strategy,
maker_fee_bps=4.0 # 4 bps maker fee
)
simulator.state.quote_balance = initial_capital
print(f"Starting backtest: {symbol}")
print(f"Period: {datetime.fromtimestamp(start_time/1000)} to {datetime.fromtimestamp(end_time/1000)}")
print(f"Initial capital: ${initial_capital:,.2f}")
print("-" * 60)
# Request historical data from HolySheep relay
import aiohttp
async with aiohttp.ClientSession() as session:
# Fetch historical order book snapshots
history_url = f"{BASE_URL}/tardis/history"
params = {
"exchange": "binance",
"symbol": symbol.replace("-", ""), # Binance format: BTCUSDT
"channel": "orderbook",
"start": start_time,
"end": end_time,
"interval": "1m" # 1-minute snapshots
}
async with session.get(
history_url,
params=params,
headers={"Authorization": f"Bearer {api_key}"}
) as response:
if response.status != 200:
print(f"Error fetching history: {await response.text()}")
return
snapshots = await response.json()
print(f"Loaded {len(snapshots)} historical snapshots")
# Process each snapshot
results = []
sentiment_scores = []
for i, snapshot in enumerate(snapshots):
# Reconstruct order book from snapshot
order_book = OrderBook(
symbol=symbol,
bids=[PriceLevel(price=float(b[0]), size=float(b[1])) for b in snapshot.get("bids", [])],
asks=[PriceLevel(price=float(a[0]), size=float(a[1])) for a in snapshot.get("asks", [])],
timestamp=snapshot.get("timestamp", 0)
)
# Analyze sentiment every 10 snapshots (every 10 minutes)
if i % 10 == 0 and i > 0:
sentiment = await analyze_market_sentiment(api_key, [])
sentiment_scores.append(sentiment)
# Adjust strategy based on sentiment
if sentiment < -0.3:
strategy.base_spread_bps = 25.0 # Widen spread in bearish markets
elif sentiment > 0.3:
strategy.base_spread_bps = 10.0 # Tighten in bullish markets
else:
strategy.base_spread_bps = 15.0
# Process simulation step
simulator.process_order_book_update(order_book, snapshot.get("timestamp", 0))
# Log progress every 60 snapshots
if i % 60 == 0:
summary = simulator.get_summary()
print(f"\n[{datetime.fromtimestamp(snapshot['timestamp']/1000).strftime('%H:%M:%S')}]")
print(f" Mid Price: ${order_book.get_mid_price():,.2f}")
print(f" Total PnL: ${summary['total_pnl']:,.2f}")
print(f" Spread Earned: ${summary['spread_earned']:,.2f}")
print(f" Position: {summary['base_balance']:.4f} BTC")
results.append(simulator.get_summary())
# Final summary
print("\n" + "=" * 60)
print("BACKTEST COMPLETE")
print("=" * 60)
final_summary = simulator.get_summary()
total_return = (final_summary['total_pnl'] - initial_capital) / initial_capital * 100
print(f"Final PnL: ${final_summary['total_pnl']:,.2f}")
print(f"Total Return: {total_return:.2f}%")
print(f"Spread Earned: ${final_summary['spread_earned']:,.2f}")
print(f"Adverse Selection: ${final_summary.get('adverse_selection_cost', 0):,.2f}")
print(f"Total Orders: {final_summary['total_orders']}")
print(f"Filled Bids: {final_summary['filled_bids']}")
print(f"Filled Asks: {final_summary['filled_asks']}")
if sentiment_scores:
avg_sentiment = sum(sentiment_scores) / len(sentiment_scores)
print(f"\nAvg Sentiment: {avg_sentiment:.2f}")
return results
if __name__ == "__main__":
import os
api_key = os.environ.get("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
asyncio.run(run_backtest(api_key))
Why Use HolySheep for Market Data?
When I first built my market-making simulation, I used direct Tardis.dev API connections. The costs were significant—$300/month just for websocket connections, plus per-message fees. HolySheep's relay changes this equation fundamentally.
| Feature | Direct Tardis | HolySheep Relay | Savings |
|---|---|---|---|
| Monthly Cost | $300-500 | $45-75 | 85%+ |
| Latency | 100-200ms | <50ms | 60%+ faster |
| Payment Methods | Credit card only | WeChat, Alipay, USDT | Flexible |
| AI Inference | Separate service | Included (DeepSeek $0.42/MTok) | Integrated |
| Free Credits | None | $10 on signup | Instant testing |
Who It Is For / Not For
This Strategy Is For:
- Individual quant traders building market-making algorithms with limited capital
- Hedge funds seeking to reduce data infrastructure costs by 85%+
- Research teams running intensive backtests requiring massive historical data
- Exchanges testing liquidity algorithms before deployment
- Developers who need integrated AI capabilities for sentiment analysis
This Is NOT For:
- High-frequency trading firms requiring sub-millisecond latency (consider co-location)
- Those who need only a single exchange (direct APIs may suffice)
- Traders without programming experience (requires Python implementation)
- Regulated institutions requiring specific compliance certifications
Pricing and ROI
Let's calculate the ROI of switching to HolySheep for a typical market-making operation:
| Cost Category | Standard Provider | With HolySheep | Monthly Savings |
|---|---|---|---|
| Market Data (Tardis relay) | $400/month | $60/month | $340 |
| AI Inference (10M tokens) | $80/month (OpenAI) | $4.20/month (DeepSeek) | $75.80 |
| Payment Processing | 2-3% FX fees | WeChat/Alipay at ¥1=$1 | $15-25 |
| TOTAL | $485/month | $70/month | $415/month |
Annual savings: ~$5,000 — enough to fund additional strategy development or infrastructure improvements.
Getting Started: Next Steps
- Sign up at HolySheep AI registration to get $10 in free credits
- Generate an API key from your dashboard
- Test the connection using the code samples above
- Run a paper backtest on historical data
- Deploy to production with live market data
Common Errors and Fixes
Error 1: WebSocket Connection Timeout
Symptom: Connection attempts hang or timeout after 30 seconds with no data received.
# Problem: Firewall blocking WebSocket connections or incorrect endpoint
import asyncio
from websockets.exceptions import InvalidStatusCode, asyncio.TimeoutError
async def robust_connect(api_key: str, max_retries: int = 3):
"""Connect with retry logic and proper error handling."""
import aiohttp
base_url = "https://api.holysheep.ai/v1"
for attempt in range(max_retries):
try:
# First, verify API key is valid
async with aiohttp.ClientSession() as session:
async with session.get(
f"{base