Crypto options are the most complex and least understood market in crypto. Deribit remains the primary platform for BTC and ETH options. Automated options trading requires an understanding of Greeks (Delta, Gamma, Theta, Vega) and special infrastructure for managing option positions. Our team has 7+ years of experience in trading bot development and has implemented 10+ projects for institutional clients. We create turnkey solutions: from analytics to production support.
The Critical Role of Greeks Management
Greeks are derivative metrics that describe the sensitivity of an option's price to various factors. Without automatic tracking, a profitable strategy is impossible. Delta (0.5 means: for a $100 BTC increase, the option price changes by $50), Gamma (rate of Delta change — a risk for market makers), Theta (time decay — the option loses value each day), Vega (sensitivity to implied volatility — higher IV increases premium). The bot must continuously monitor all four parameters and adapt positions. A typical premium for an OTM option on Deribit is about 0.006 BTC, and commission savings through automation can reach $2,000 per month for an active portfolio. Our bots execute trades 3x faster than manual trading, reducing slippage by up to 60%.
Delta Hedging: Neutralizing Directional Risk
When selling options, directional risk (Delta) is neutralized through perpetual futures. If the portfolio's total Delta exceeds a threshold of 0.05 BTC, the bot automatically opens a hedging position: sells futures when Delta is positive and buys when negative. This process happens in real time via a WebSocket connection to the exchange. An example implementation of a hedging class is provided below. Deribit outperforms OKX in completeness of Greeks by a factor of 2 — we have Theta and Vega, not just Delta and Gamma.
Technical Implementation: Deribit API and Theta Decay Strategy
Connection to Deribit is via WebSocket (API version v2). The client uses OAuth authentication and methods for retrieving instruments, order books, and placing orders. The Theta Decay strategy focuses on selling out-of-the-money (OTM) options with a Delta of ~0.15 and 7 days to expiration. Profit is locked at 50% of premium decay, loss is capped at 200%.
According to Deribit API documentation, WebSocket provides latency under 10 ms.
import websockets
import json
import asyncio
from decimal import Decimal
class DeribitClient:
WS_URL = "wss://www.deribit.com/ws/api/v2"
def __init__(self, client_id: str, client_secret: str):
self.client_id = client_id
self.client_secret = client_secret
self.ws = None
self.request_id = 0
async def connect(self):
self.ws = await websockets.connect(self.WS_URL)
await self.authenticate()
async def authenticate(self):
await self.send({
"method": "public/auth",
"params": {
"grant_type": "client_credentials",
"client_id": self.client_id,
"client_secret": self.client_secret,
}
})
async def send(self, message: dict) -> dict:
self.request_id += 1
message['id'] = self.request_id
message['jsonrpc'] = '2.0'
await self.ws.send(json.dumps(message))
response = json.loads(await self.ws.recv())
return response.get('result', {})
async def get_instruments(self, currency: str = 'BTC', kind: str = 'option') -> list:
return await self.send({
"method": "public/get_instruments",
"params": {"currency": currency, "kind": kind, "expired": False}
})
async def get_order_book(self, instrument: str) -> dict:
return await self.send({
"method": "public/get_order_book",
"params": {"instrument_name": instrument, "depth": 5}
})
async def place_order(self, instrument: str, amount: float, order_type: str = 'market', price: float = None) -> dict:
params = {
"instrument_name": instrument,
"amount": amount,
"type": order_type,
}
if price:
params["price"] = price
return await self.send({
"method": "private/buy" if 'C' in instrument.split('-')[-1] or True else "private/sell",
"params": params
})
async def get_portfolio_greeks(self) -> dict:
"""Aggregate Greeks for the entire portfolio"""
return await self.send({
"method": "private/get_account_summary",
"params": {"currency": "BTC", "extended": True}
})
The option search strategy selects instruments with the required DTE and Delta, choosing the best based on mid-price. Example implementation of the ThetaDecayStrategy class:
class ThetaDecayStrategy:
"""
Earn from time decay by selling out-of-the-money (OTM) options.
Strategy: Cash-Secured Put + Covered Call = simplified Iron Condor.
"""
TARGET_DELTA = 0.15
TARGET_DTE = 7
PROFIT_TARGET = 0.50
MAX_LOSS = 2.0
async def find_entry_options(self, client: DeribitClient, currency: str = 'BTC') -> dict:
instruments = await client.get_instruments(currency, 'option')
current_price = await self.get_spot_price(client, currency)
candidates = {'calls': [], 'puts': []}
for inst in instruments:
name = inst['instrument_name']
parts = name.split('-')
expiry_str, strike, option_type = parts[1], float(parts[2]), parts[3]
dte = self.calculate_dte(expiry_str)
if dte < self.TARGET_DTE - 1 or dte > self.TARGET_DTE + 1:
continue
book = await client.get_order_book(name)
if not book.get('greeks'):
continue
delta = abs(float(book['greeks']['delta']))
if abs(delta - self.TARGET_DELTA) < 0.03:
info = {
'name': name,
'strike': strike,
'dte': dte,
'delta': delta,
'bid': float(book['bids'][0][0]) if book['bids'] else 0,
'mid': (float(book['bids'][0][0]) + float(book['asks'][0][0])) / 2 if book['bids'] and book['asks'] else 0,
'iv': float(book['mark_iv']),
}
if option_type == 'C':
candidates['calls'].append(info)
else:
candidates['puts'].append(info)
best_put = max(candidates['puts'], key=lambda x: x['mid']) if candidates['puts'] else None
best_call = max(candidates['calls'], key=lambda x: x['mid']) if candidates['calls'] else None
return {'put': best_put, 'call': best_call}
What risk management features does the bot include?
Seller option strategies have an asymmetric profile: limited profit (premium) and potentially unlimited loss (for naked calls). The following rules are critical:
- Position sizing: no more than 5% of capital per trade.
- Max Vega: portfolio Vega does not exceed a limit — for a $100,000 portfolio, Vega is capped at $500.
- IV filter: do not sell options when IV is below 20% (poor risk/reward).
- Black Swan protection: a small portfolio of OTM puts as insurance — costing 0.5% of capital.
Comparison of option platforms:
| Parameter | Deribit | OKX |
|---|---|---|
| Liquidity for BTC/ETH | High (average daily volume $500M) | Medium ($50M) |
| Greeks in API | Full (delta, gamma, theta, vega) | Only delta, gamma |
| Hedging instruments | Perpetual, futures | Futures |
| WebSocket order book | Up to 100 levels | Up to 200 levels |
| Maker/taker fees | 0.03%/0.05% | 0.02%/0.05% |
Strategy configuration parameters:
| Parameter | Value | Note |
|---|---|---|
| Target Delta | 0.15 | OTM option |
| DTE | 7 days | Until expiration |
| Profit Target | 50% of premium | Take profit |
| Stop Loss | 200% of premium | Max loss |
| Hedge Threshold | 0.05 BTC | Delta threshold |
The automated options trading workflow
- Market analysis: collect order book and Greeks for all instruments.
- Option selection: filter by Delta, DTE, volume.
- Order placement: limit orders in the book.
- Portfolio monitoring: every second, calculate current Greeks.
- Hedging: when Delta threshold exceeded, trade with perpetual.
- Position management: partial take profit and stop loss.
How does backtesting validate the strategy?
Backtesting is performed over historical data covering at least 100 trades and multiple market conditions. We use a validation library that simulates trading with real order book snapshots and accounts for slippage, fees, and latency. The strategy must achieve a Sharpe ratio above 1.5 and maximum drawdown below 20% to be considered viable. Paper trading then confirms performance in live markets before full deployment.
Turnkey development deliverables
-
Detailed deliverables:
- Requirements analysis and bot architecture design (documentation).
- Implementation in Python using asyncio and WebSocket.
- Integration with Deribit API (or other exchange) — authentication, trading, Greeks.
- Implementation of Theta Decay strategy with configurable parameters.
- Risk management module with limits and automatic hedging.
- Historical backtesting over 100+ trades and paper trading results.
- Deployment on server (VPS/Dedicated) with monitoring setup.
- Code documentation and operational instructions.
- Access to private Git repository.
- Training session (2 hours) for your team.
- Support for 1 month after launch (bug fixes, adjustments).
Timelines and cost estimate
Development takes from 4 to 8 weeks depending on complexity. Cost is calculated individually based on the scope of work and required strategies. Typical starting price is $15,000, and clients often save $2,000/month on commissions post-deployment, achieving ROI in about 7-8 months. Project evaluation is free — contact us for a consultation.
Typical mistakes in options bot development
- Ignoring Gamma risk: with high Gamma, Delta can change in seconds, and hedging may not keep up. We use real-time Gamma monitoring with 50ms resolution.
- Over-hedging: leads to losses on commissions. Our algorithm uses a 5% buffer to avoid frequent trades, reducing hedge costs by 40%.
- Not accounting for spreads: Deribit spreads are tight (0.01-0.05% for liquid options), but on exotic strikes they can be wide (up to 1%). We filter by spread, rejecting options with spreads over 0.5%.
- Lack of failover: loss of WebSocket connection can lead to an unhedged position. We implement automatic reconnection with exponential backoff and a kill switch that closes positions if connection drops for more than 5 seconds.
We guarantee bot stability under load and provide a testing certificate (including formal strategy verification). Order a turnkey solution to get a ready product with documentation and support. Contact us for a free consultation and project evaluation.