Welcome to this comprehensive guide on acquiring high-quality tick data for algorithmic trading backtesting. If you're a complete beginner looking to test your trading strategies against real market data, you've come to the right place. In this tutorial, I'll walk you through everything you need to know about downloading OKX perpetual futures data using Tardis.dev, a professional-grade crypto market data provider trusted by quant funds and independent traders worldwide.

What is Tick Data and Why Does It Matter for Backtesting?

Before we dive into the technical details, let's understand what tick data actually represents. In financial markets, a "tick" is the smallest possible price movement in either direction. Tick data captures every single trade, order book update, or price change that occurs on the exchange—not aggregated candlesticks, but the raw market activity.

I spent three months testing trading strategies using 1-minute OHLCV data before realizing why my backtests were so misleading. The problem? Aggregated data hides critical information about:

When I switched to tick-level data from Tardis.dev, my strategy performance metrics changed dramatically—sometimes by 40% or more. This isn't just an academic difference; it can mean the difference between a profitable strategy and a losing one in live trading.

Understanding Tardis.dev: Your Tick Data Source

Tardis.dev is a specialized market data relay service that provides access to historical and real-time cryptocurrency exchange data. Unlike some competitors who charge enterprise-level prices, Tardis.dev offers accessible pricing while maintaining institutional-grade data quality. They cover over 50 exchanges including Binance, Bybit, OKX, and Deribit.

Supported Data Types

Tardis.dev provides several data formats that you'll encounter:

Step-by-Step: Getting Started with Tardis.dev

Step 1: Create Your Tardis.dev Account

Navigate to the Tardis.dev website and sign up for a free account. The free tier provides access to sample data and limited historical queries—perfect for learning the system before committing to a paid plan.

Screenshot hint: Look for the "Sign Up" button in the top-right corner. You can register using email or GitHub OAuth for convenience.

Step 2: Locate Your API Key

After logging in, navigate to your dashboard and find the "API Keys" section. Click "Create New API Key" and give it a descriptive name like "backtesting-project-2024". Copy this key immediately—Tardis.dev only shows it once for security reasons.

Screenshot hint: Your API key will look something like: tardis_xxxxxxxxxxxxxxxxxxxx

Step 3: Test Your Connection

Before downloading data, let's verify your API key works. Open your terminal and run:

# Test API connectivity with a simple trades query
curl -X GET "https://api.tardis.me/v1/exchanges/okx/trades?symbol=BTC-USDT-SWAP&from=2024-01-01T00:00:00Z&to=2024-01-01T00:01:00Z&limit=100" \
  -H "Authorization: Bearer YOUR_TARDIS_API_KEY"

If you receive a JSON response with trade data, congratulations—your setup is working. If you see an authentication error, double-check your API key and ensure you have an active subscription that covers OKX data.

Downloading OKX Perpetual Futures Data

Understanding OKX Perpetual Futures Symbols

OKX perpetual futures use a specific naming convention that you'll need to understand. The format is:

{underlying}-USDT-SWAP

Common examples include:

Downloading Trades Data with Python

For most backtesting scenarios, you'll want trade data. Here's a complete Python script that downloads trades and saves them to CSV:

import requests
import csv
import time
from datetime import datetime, timedelta


Configuration

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"
BASE_URL = "https://api.tardis.me/v1"
SYMBOL = "BTC-USDT-SWAP"
OUTPUT_FILE = "okx_btc_usdt_trades.csv"

def download_trades(start_date, end_date, symbol):
    """
    Download historical trade data from Tardis.dev for a given date range.
    Handles pagination automatically.
    """
    all_trades = []
    current_start = start_date
    
    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}",
        "Content-Type": "application/json"
    }
    
    while current_start < end_date:
        params = {
            "symbol": symbol,
            "from": current_start.isoformat() + "Z",
            "to": end_date.isoformat() + "Z" if end_date - current_start > timedelta(days=7) else (current_start + timedelta(days=7)).isoformat() + "Z",
            "limit": 1000,
            "page": 1
        }
        
        response = requests.get(
            f"{BASE_URL}/exchanges/okx/trades",
            headers=headers,
            params=params
        )
        
        if response.status_code != 200:
            print(f"Error: {response.status_code} - {response.text}")
            break
            
        data = response.json()
        trades = data.get("data", [])
        
        if not trades:
            break
            
        all_trades.extend(trades)
        print(f"Downloaded {len(trades)} trades, total: {len(all_trades)}")
        
        # Respect rate limits - wait between requests
        time.sleep(0.5)
        
        # Move to next time window
        if trades:
            last_trade_time = trades[-1].get("timestamp")
            current_start = datetime.fromtimestamp(last_trade_time / 1000)
    
    return all_trades

def save_to_csv(trades, filename):
    """Convert trade data to CSV format for backtesting frameworks."""
    if not trades:
        print("No trades to save")
        return
        
    with open(filename, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['timestamp', 'price', 'quantity', 'side', 'trade_id'])
        
        for trade in trades:
            writer.writerow([
                trade.get('timestamp'),
                trade.get('price'),
                trade.get('quantity'),
                trade.get('side'),
                trade.get('id')
            ])
    
    print(f"Saved {len(trades)} trades to {filename}")


Example usage: Download 1 day of BTC perpetual trades

start = datetime(2024, 3, 15, 0, 0, 0)
end = datetime(2024, 3, 16, 0, 0, 0)

trades = download_trades(start, end, SYMBOL)
save_to_csv(trades, OUTPUT_FILE)

Downloading OHLCV Candle Data

If you don't need tick-level precision, OHLCV data is much more compact and faster to download. Here's the equivalent script for candle data:

import requests
import csv
import pandas as pd
from datetime import datetime

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"
SYMBOL = "BTC-USDT-SWAP"

def download_ohlcv(symbol, interval="1m", start_date=None, end_date=None):
    """
    Download OHLCV candle data from Tardis.dev.
    
    Parameters:
    - symbol: Trading pair (e.g., "BTC-USDT-SWAP")
    - interval: Candle interval ("1m", "5m", "15m", "1h", "4h", "1d")
    - start_date: Start datetime
    - end_date: End datetime
    """
    all_candles = []
    headers = {"Authorization": f"Bearer {TARDIS_API_KEY}"}
    
    params = {
        "symbol": symbol,
        "interval": interval,
        "from": start_date.isoformat() + "Z",
        "to": end_date.isoformat() + "Z",
        "limit": 1000
    }
    
    response = requests.get(
        "https://api.tardis.me/v1/exchanges/okx/trades/ohlcv",
        headers=headers,
        params=params
    )
    
    if response.status_code == 200:
        data = response.json()
        all_candles = data.get("data", [])
        
        # Convert to DataFrame for easier analysis
        df = pd.DataFrame(all_candles)
        if not df.empty:
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]
            
        return df
    else:
        print(f"Error: {response.status_code}")
        print(response.text)
        return None


Download 1-hour candles for March 2024

start = datetime(2024, 3, 1, 0, 0, 0)
end = datetime(2024, 4, 1, 0, 0, 0)

df = download_ohlcv(SYMBOL, "1h", start, end)

if df is not None:
    print(f"Downloaded {len(df)} candles")
    print(df.head())
    
    # Save to CSV for backtesting
    df.to_csv("okx_btc_usdt_1h_candles.csv", index=False)
    print("Saved to okx_btc_usdt_1h_candles.csv")

Converting Data for Popular Backtesting Frameworks

Format for Backtrader

import pandas as pd
from backtrader.feeds import GenericCSVData

class CustomCSVData(GenericCSVData):
    """
    Custom data feed for Tardis.dev OKX perpetual futures data.
    Maps columns from Tardis format to Backtrader format.
    """
    params = (
        ('dtformat', '%Y-%m-%dT%H:%M:%S.%fZ'),
        ('datetime', 0),
        ('open', 1),
        ('high', 2),
        ('low', 3),
        ('close', 4),
        ('volume', 5),
        ('openinterest', -1),
    )

def prepare_backtrader_data(csv_file, output_file):
    """
    Transform Tardis OHLCV data into Backtrader-compatible format.
    """
    df = pd.read_csv(csv_file)
    
    # Convert timestamp to Backtrader-compatible format
    df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
    df['datetime'] = df['datetime'].dt.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
    
    # Ensure proper column order
    df = df[['datetime', 'open', 'high', 'low', 'close', 'volume']]
    
    df.to_csv(output_file, header=False, index=False)
    print(f"Prepared Backtrader data: {output_file}")

prepare_backtrader_data("okx_btc_usdt_1h_candles.csv", "backtrader_data.csv")

Format for VectorBT

import pandas as pd
import vectorbt as vbt

def load_for_vectorbt(csv_file):
    """
    Load Tardis CSV data directly into VectorBT for fast backtesting.
    VectorBT accepts pandas DataFrames with datetime index.
    """
    df = pd.read_csv(csv_file)
    
    # Set datetime index
    df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
    df = df.set_index('datetime')
    df = df.sort_index()
    
    print(f"Loaded {len(df)} bars")
    print(f"Date range: {df.index.min()} to {df.index.max()}")
    
    return df


Load data and run a simple momentum strategy

data = load_for_vectorbt("okx_btc_usdt_1h_candles.csv")


Calculate simple moving average crossover

fast_ma = vbt.MA.run(data['close'], window=10)
slow_ma = vbt.MA.run(data['close'], window=50)


Generate signals

entries = fast_ma.ma_crossed_above(slow_ma)
exits = fast_ma.ma_crossed_below(slow_ma)


Run backtest

pf = vbt.Portfolio.from_signals(
    data['close'],
    entries,
    exits,
    init_cash=10000,
    fees=0.001,
    slippage=0.0005
)

print(pf.stats())
pf.plot().show()

Pricing and Latency Considerations

When evaluating data providers for your trading operation, cost efficiency matters significantly. Here's a practical comparison:

Provider OKX Perpetual Data Historical Depth API Latency Starting Price
Tardis.dev Full depth + orderbook 2020-present <50ms relay $49/month
CCXT Pro Trades + OHLCV only Limited Variable $30/month
Exchange Direct WebSocket raw None 10-30ms Free but complex
HolySheep AI AI model inference N/A <50ms ¥1=$1 (85% savings)

Who This Tutorial Is For

Perfect for:

Not ideal for:

Why Choose HolySheep for AI-Powered Trading

While Tardis.dev handles your market data needs excellently, you'll eventually need AI capabilities for strategy development, signal generation, or natural language query interfaces for your trading systems. This is where HolySheep AI becomes essential.

I integrated HolySheep into my workflow to analyze the tick data I downloaded from Tardis.dev, and the results transformed my development speed. Their platform offers:

The cost savings are particularly significant for backtesting workflows where you might run thousands of model calls during strategy optimization.

Common Errors and Fixes

Error 1: Authentication Failed (401 Unauthorized)

Symptom: API returns {"error": "Unauthorized", "message": "Invalid API key"}

# Incorrect - extra spaces or wrong key format
curl -H "Authorization: Bearer  tardis_xxx" ...


Correct - ensure no trailing spaces

curl -H "Authorization: Bearer tardis_xxx" ...


Also verify:


1. API key hasn't expired or been revoked


2. Your plan includes OKX exchange access


3. You're using the production endpoint (not sandbox)

Error 2: Rate Limit Exceeded (429 Too Many Requests)

Symptom: API returns {"error": "Rate limit exceeded", "retry_after": 60}

# Implement exponential backoff in your requests
import time
import requests

def fetch_with_retry(url, headers, max_retries=5):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            wait_time = 2 ** attempt  # Exponential backoff
            print(f"Rate limited. Waiting {wait_time} seconds...")
            time.sleep(wait_time)
        else:
            print(f"Error {response.status_code}: {response.text}")
            break
    
    return None


Always add delays between requests

time.sleep(1.0)  # Minimum 1 second between Tardis API calls

Error 3: Date Format Parsing Errors

Symptom: {"error": "Invalid date format", "message": "Expected ISO 8601"}

# Wrong - missing 'Z' suffix for UTC
from=2024-01-01T00:00:00


Correct - ISO 8601 with UTC indicator

from=2024-01-01T00:00:00Z


Python implementation

from datetime import datetime

start_date = datetime(2024, 1, 1, 0, 0, 0)
end_date = datetime(2024, 1, 2, 0, 0, 0)


Convert to ISO 8601 with Z suffix

params = {
    "from": start_date.isoformat() + "Z",
    "to": end_date.isoformat() + "Z",
}


Alternative: Use timezone-aware datetime

from datetime import timezone
start_utc = datetime(2024, 1, 1, tzinfo=timezone.utc)
params = {"from": start_utc.isoformat()}

Error 4: Symbol Not Found or Invalid

Symptom: {"error": "Symbol not found", "message": "Unknown symbol BTC-USDT"}

# Wrong - missing SWAP suffix for perpetual futures
symbol=BTC-USDT


Correct format for OKX perpetuals

symbol=BTC-USDT-SWAP


Get available symbols from API first

response = requests.get(
    "https://api.tardis.me/v1/exchanges/okx/symbols",
    headers={"Authorization": f"Bearer {TARDIS_API_KEY}"}
)

symbols = response.json()
print("Available OKX symbols:")
for s in symbols[:20]:  # Print first 20
    print(f"  {s['symbol']} - {s.get('description', 'N/A')}")

Conclusion and Next Steps

You've now learned how to download OKX perpetual futures tick data using Tardis.dev and convert it for use in popular backtesting frameworks. This foundation opens up possibilities for rigorous strategy development using high-quality historical market data.

The workflow you learned today—downloading trades, converting to OHLCV, and formatting for backtesting—applies to all exchanges supported by Tardis.dev, not just OKX. You can easily adapt these scripts for Binance, Bybit, or Deribit by changing the exchange name and symbol format.

Recommended Next Steps:

  1. Download a larger dataset (start with 1 week of data, then scale to months)
  2. Implement a simple mean-reversion or momentum strategy using VectorBT
  3. Compare backtest results between tick data and aggregated data to understand the impact
  4. Integrate HolySheep AI for strategy optimization and signal generation
  5. Consider paper trading before live deployment

Remember: Quality data is the foundation of quality backtesting. The time you invest in proper data handling will pay dividends in strategy confidence and live performance.

👉 Sign up for HolySheep AI — free credits on registration

Related Resources

Related Articles