STRATEGY

TWAP Execution Algorithm in Python: Minimise Market Impact on LMEX

Q: How many slices should I use?

5-20 is a reasonable range. Fewer slices is faster but more impactful. More slices is smoother but takes longer and adds latency. For most retail orders, 10 slices over 10-30 minutes is the sweet spot.

Q: What's the optimal TWAP duration?

Depends on order size relative to typical volume. Rule of thumb: spread execution over a window where total volume is 50-100x your order size. For a 10 BTC order on BTC-PERP, that's typically 15-60 minutes.

Q: Can I cancel a TWAP partway through?

Yes — track the order IDs and cancel any unfilled ones. The bot above doesn't support this natively, but adding a kill-switch flag that breaks the loop is straightforward.

Q: Does LMEX have built-in TWAP support?

Not natively as a single API call. You implement it client-side using the standard order endpoints. The advantage: you have full control over slicing logic and can customize for specific strategies.

June 18, 2026 · 7 min read · LMEX.AI

Placing a large order all at once moves the market against you. TWAP — Time-Weighted Average Price — splits it into smaller pieces over a defined time window, smoothing your fill price and reducing market impact.

This article walks through what TWAP is, when to use it, how to implement it on LMEX in Python, and the variants worth considering.

The market impact problem

Place a market buy for 10 BTC on LMEX. Even on a liquid pair, the order walks up the book consuming liquidity. The first 1 BTC fills near the best ask; the last 1 BTC fills 10-50 basis points higher. Average fill is meaningfully worse than the original best ask.

For institutional-size orders, this slippage can dwarf the strategy's edge. A signal that says "go long" might be worth 30 basis points of expected return. If you slip 50 basis points entering, the trade is unprofitable before it starts.

The solution: don't place the whole order at once. Split it into smaller pieces, executed over time. The smaller pieces each cause minimal impact; the cumulative average fill price tracks the time-weighted average market price closely.

TWAP vs VWAP vs POV

Three common execution algorithms:

**TWAP (Time-Weighted Average Price)** — split the order into equal pieces, execute at regular intervals. Simplest. Works well in steady markets, struggles when volume is uneven.

**VWAP (Volume-Weighted Average Price)** — split proportional to expected volume. Trade more during high-volume periods (typically market open/close), less during quiet periods. More sophisticated but requires accurate volume forecasts.

**POV (Percent of Volume)** — execute as a fixed percentage of real-time volume. Adapts dynamically. Best for very large orders where you want minimal footprint.

For most retail and small institutional orders, TWAP is the right choice. It's simple, transparent, and effective.

Python implementation

A working TWAP execution algo for LMEX:

import ccxt
import time
from datetime import datetime, timedelta

exchange = ccxt.lmex({'apiKey': '...', 'secret': '...'})

def execute_twap(symbol, side, total_qty, duration_minutes, num_slices=10):
    """
    Execute a TWAP order.
    
    Args:
        symbol: 'BTC-PERP', 'ETH-PERP', etc.
        side: 'buy' or 'sell'
        total_qty: total quantity to execute (in base currency)
        duration_minutes: total time window for execution
        num_slices: number of pieces to split into
    """
    slice_qty = total_qty / num_slices
    slice_qty = float(exchange.amount_to_precision(symbol, slice_qty))
    interval_seconds = (duration_minutes * 60) / num_slices
    
    fills = []
    for i in range(num_slices):
        try:
            order = exchange.create_order(symbol, 'market', side, slice_qty)
            
            # Fetch actual fill details
            time.sleep(1)
            filled = exchange.fetch_order(order['id'], symbol)
            avg_price = filled.get('average', None) or order.get('price')
            
            fills.append({
                'slice': i + 1,
                'qty': slice_qty,
                'price': avg_price,
                'timestamp': datetime.utcnow().isoformat()
            })
            
            print(f"Slice {i+1}/{num_slices}: {side} {slice_qty} @ {avg_price}")
            
            if i < num_slices - 1:
                time.sleep(interval_seconds)
        except Exception as e:
            print(f"Slice {i+1} failed: {e}")
            time.sleep(interval_seconds)
    
    # Calculate average fill price
    total_filled = sum(f['qty'] for f in fills if f['price'])
    weighted_sum = sum(f['qty'] * f['price'] for f in fills if f['price'])
    avg_fill = weighted_sum / total_filled if total_filled > 0 else None
    
    return {
        'fills': fills,
        'total_filled': total_filled,
        'average_price': avg_fill,
    }

# Usage: buy 1 BTC over 30 minutes, in 10 slices
result = execute_twap('BTC-PERP', 'buy', 1.0, duration_minutes=30, num_slices=10)
print(f"Filled {result['total_filled']} @ avg {result['average_price']}")

The bot places 10 market orders of 0.1 BTC each, spaced 3 minutes apart. Total execution time: 30 minutes. Average fill should be close to the 30-minute volume-weighted average price.

Slippage considerations

A naive TWAP using market orders still incurs some slippage per slice. To minimise this, use limit orders at slightly aggressive prices (e.g., the bid for buys, the ask for sells with a small offset):

def execute_twap_aggressive_limit(symbol, side, total_qty, duration_minutes, num_slices=10, offset_bps=2):
    """
    TWAP using aggressive limit orders (bid for buys, ask for sells).
    Adds small offset to ensure quick fills.
    """
    slice_qty = total_qty / num_slices
    slice_qty = float(exchange.amount_to_precision(symbol, slice_qty))
    interval_seconds = (duration_minutes * 60) / num_slices
    
    fills = []
    for i in range(num_slices):
        try:
            ticker = exchange.fetch_ticker(symbol)
            if side == 'buy':
                # Place above ask by offset to ensure fill
                limit_price = ticker['ask'] * (1 + offset_bps / 10000)
            else:
                limit_price = ticker['bid'] * (1 - offset_bps / 10000)
            
            limit_price = float(exchange.price_to_precision(symbol, limit_price))
            order = exchange.create_order(symbol, 'limit', side, slice_qty, limit_price)
            
            # Wait briefly for fill
            time.sleep(5)
            filled = exchange.fetch_order(order['id'], symbol)
            
            if filled['status'] != 'closed':
                # Cancel and retry with more aggressive price
                exchange.cancel_order(order['id'], symbol)
                order = exchange.create_order(symbol, 'market', side, slice_qty)
            
            fills.append({'slice': i + 1, 'qty': slice_qty, 'price': filled.get('average', limit_price)})
            
            if i < num_slices - 1:
                time.sleep(interval_seconds - 5)
        except Exception as e:
            print(f"Slice {i+1} failed: {e}")
    
    return fills

This is more efficient — limit orders cross the spread less aggressively than market orders, capturing better fills. The fallback to market order on no-fill prevents stuck orders.

For very small orders (< 0.1% of order book depth), market orders are fine. For larger orders, limit-based TWAP saves meaningful basis points.

Variations and randomisation

A pure TWAP at exact intervals is predictable. Sophisticated counterparties can detect it and front-run. To avoid this, add randomisation:

import random

def execute_twap_randomized(symbol, side, total_qty, duration_minutes, num_slices=10, 
                            qty_jitter=0.2, time_jitter=0.3):
    """
    TWAP with random variation in slice sizes and timing.
    qty_jitter: +/- this fraction of slice qty
    time_jitter: +/- this fraction of interval seconds
    """
    base_slice = total_qty / num_slices
    base_interval = (duration_minutes * 60) / num_slices
    remaining = total_qty
    
    fills = []
    for i in range(num_slices):
        if i == num_slices - 1:
            slice_qty = remaining
        else:
            jitter = 1 + random.uniform(-qty_jitter, qty_jitter)
            slice_qty = base_slice * jitter
            slice_qty = min(slice_qty, remaining)
        
        slice_qty = float(exchange.amount_to_precision(symbol, slice_qty))
        order = exchange.create_order(symbol, 'market', side, slice_qty)
        fills.append(order)
        remaining -= slice_qty
        
        if i < num_slices - 1:
            interval_jitter = 1 + random.uniform(-time_jitter, time_jitter)
            time.sleep(base_interval * interval_jitter)
    
    return fills

Random qty and timing make the order pattern much harder to detect or game.

When TWAP isn't the right answer

TWAP isn't universal. A few situations where it's wrong:

**Small orders** — for orders under 0.1% of order book depth, TWAP adds latency without meaningful improvement. Just market order.

**Urgent execution** — if a strategy signal is time-sensitive (breakout entry, stop-out exit), the price drift during TWAP execution can exceed the slippage savings. Use direct market orders.

**Trending markets** — TWAP averages your fill across time, which is great in chop but bad in trends. A 30-minute buy TWAP during a sharp rally fills you at progressively worse prices. Consider VWAP (front-loaded execution) instead.

**Illiquid markets** — TWAP relies on continuous liquidity during the execution window. In illiquid markets, individual slices can themselves cause material impact. Spread the order over hours/days rather than minutes.

Frequently Asked Questions