Getting Started With Deriv API Automation
The Deriv API is WebSocket-based, which means it stays open and bidirectional. You send a request, get a response, and the connection remains active for push notifications. This is fundamentally different from REST APIs where you hammer the server every few seconds. If you're coming from polling-based systems, the first thing you need to do is rethink your architecture around event-driven callbacks instead of loops with sleep timers.The official documentation lives at api.deriv.com. The site has a test playground where you can send payloads live and see responses in real time. It's genuinely useful — I spent more time there than in any written doc. One thing they don't emphasize enough is that the API distinguishes between active symbols and available symbols. An active symbol is one currently tradable on the exchange. If you query for contract types without filtering by active status, you'll get responses full of products you can't actually trade right now. My workaround was to always call symbol_status first, cross-reference against my strategy's requested symbols, and discard anything marked inactive before building my order logic. That alone cut my failed launch attempts from roughly one in three to near zero. Let's talk about what the API actually lets you do. You can stream tick data for over 100 synthetic and market indices, place buy and sell orders, request account balance updates, and even subscribe to real-time market events like payout changes. The token-based authentication system uses short-lived access tokens that expire after an hour. You refresh them via a separate endpoint using your refresh token. I've seen too many bots that hardcode a single token and then spend twenty minutes debugging why their orders stopped working at 3 AM. Set up an automatic refresh cycle and log the token expiry time. It takes about five lines of code and saves you from panic calls. The pricing structure for API usage is based on request volume, not per-trade fees. Each API call counts toward your quota. A typical bot sending tick subscriptions every second across five symbols generates roughly 300 requests per minute. That's fine for testing but will burn through your free tier fast. If you're running a production bot, batch your subscriptions where possible. The API supports multiple symbol subscriptions in a single payload, which reduces request count by 60 to 70 percent compared to one-per-call.
Core Authentication And Connection Flow
Authentication starts with obtaining an authorization token. You can get this through the Deriv website login flow or by generating an API key from your account settings. Once you have it, the connection lifecycle looks like this: connect to the WebSocket endpoint, send an authorize request with your token, wait for the authenticated response, then begin sending your trading commands. Here's what the authorize payload looks like: authorize
req_id: 1
authorize: "your_api_token"
The response includes your account currency, balance, and available markets. Note that a single token can be associated with only one account. If you're managing multiple accounts, you need separate tokens and separate WebSocket connections. Trying to share one connection across accounts will give you inconsistent balance updates and sometimes silently route trades to the wrong account. I learned that the hard way on a Saturday morning. The WebSocket endpoint is wss://ws.derivws.com/websockets/v3. Make sure your code handles reconnection gracefully. Network drops happen. The API doesn't automatically reconnect. Your bot needs to detect closed connections, wait a few seconds, and re-establish the auth flow. A simple exponential backoff between retries works well. I use three attempts with delays of 2, 8, and 30 seconds before giving up and alerting.
Get the Full Details
Trading Mechanics And Order Placement
Placing a trade requires knowing your contract type, stake amount, duration, and underlying symbol. Deriv supports several contract types: (rise/fall), digits, multitrade, and others. Each has different parameter requirements. For a basic rise_fall contract, you need the symbol, stake, duration, duration_type, and direction. Duration_type can be seconds, minutes, hours, or timestamps. Using seconds for short-term trades and timestamps for specific expiry times gives you the most control. Here's a minimal buy request payload: buy
req_id: 2
buy: {
"symbol": "R_10",
"stake": 10,
"duration": 60,
"duration_type": "s",
"contract_type": "CALL"
}
The response comes back with a contract ID. That ID is what you use to track the trade's status. Don't skip storing it. I've seen bots that place orders and then have no way to know which contract won or lost because they didn't save the ID. The trade history endpoint can retrieve past trades, but relying on that for real-time management is slower and adds unnecessary requests. One counter-intuitive thing about Deriv's API: the payout displayed in your buy request isn't always the final payout. The actual payout depends on the symbol's current volatility at the moment the contract expires. For synthetic indices like Volatility 10, the payout is calculated based on the index movement during the contract period. If you're backtesting with static payout assumptions, your results will be optimistic. Real payouts can vary by 5 to 15 percent from your quoted estimate depending on market conditions.
Subscriptions And Real-Time Data Streams
Tick subscriptions are where most bots spend the bulk of their API calls. The payload is straightforward: ticks
req_id: 3
ticks: "R_10" But there's a catch. The tick stream for synthetic indices isn't truly real-time in the sense of showing every individual price movement. It's a smoothed aggregate that updates at a fixed interval based on the index type. R_10 updates roughly every 10 seconds. R_100 updates less frequently. If your strategy depends on sub-second precision, this API won't give it to you. There's no way to increase the tick frequency. The documentation states the update intervals clearly, but it's easy to miss if you're skimming.
For actual forex or cryptocurrency symbols, the tick data is sourced from real market providers and is closer to real-time, but latency still varies. I've measured 150 to 400 milliseconds round-trip from tick receipt to local processing on a decent connection. If you're doing high-frequency strategies, plan for that lag and size your stop losses accordingly. Another subscription type worth knowing about is the balance stream. Instead of polling for your account balance, subscribe to balance updates and receive them automatically when they change. This eliminates redundant API calls and ensures you never act on stale balance data. A common mistake is checking balance before placing an order and then finding out it changed in the 300 milliseconds between the check and the trade execution. Subscribe to balance events and let the API push updates to you.
Practical Implementation Notes
Writing the bot itself requires handling async responses properly. The API is asynchronous, meaning your buy request and its confirmation arrive at different times. You can't write linear code that sends a request and immediately checks the result. Use callback functions, promises, or async/await patterns depending on your language. Python users should look into asyncio. Node.js developers will find the eventEmitter pattern fits naturally. Rate limiting is another practical concern. The API enforces a maximum of 100 requests per second per connection. If your bot sends more than that, you'll get error responses and temporary throttling. Monitor your request rate and implement a simple queue with a timing check before each send. A circular buffer with timestamp tracking works fine. Most strategies don't need anywhere near 100 requests per second, but if you're watching multiple symbols and placing orders frequently, you can hit the limit without noticing until your trades start failing. Error handling deserves its own section. The API returns specific error codes for different failure scenarios. A malformed request gives a validation error. An expired token gives an authentication error. Insufficient funds gives an account error. Logging these with enough context to reproduce the issue is essential. I keep a structured log file with timestamp, request payload, error code, and symbol. When something goes wrong at 2 AM, that log tells me exactly what happened without me having to reconstruct the scenario from memory.
Known Limitations And When To Look Elsewhere
The Deriv API has clear limitations that matter for serious automated trading. First, it only supports Deriv's own markets. You can't connect your own exchange account or use external liquidity providers through this API. If you need multi-exchange routing, this isn't the tool. Second, there's no native support for complex order types like stop-loss orders attached to existing positions. You manage risk entirely through your own logic by placing closing trades manually. Third, the API doesn't provide historical tick data for backtesting. You can request historical OHLC data in candle form, but if your strategy needs tick-level backtesting, you'll need to collect and store your own data first. For strategies that need deeper market analysis or execution across multiple venues, consider combining the Deriv API with a data aggregation service or moving to a platform that offers more comprehensive execution APIs. Deriv's API is solid for its intended use case: automated trading within the Deriv ecosystem. It's not a general-purpose trading infrastructure solution. Knowing the boundary prevents wasted time and frustration. The community around Deriv API usage is small but active. The official documentation covers the fundamentals, and the playground tool makes experimentation fast. The gap is in advanced strategy implementation, which isn't documented because it varies too much between traders. You'll figure most of it out through trial, logging, and reading other people's open-source implementations. The API itself is stable, well-structured, and reasonably fast. It does what it says it does without unnecessary complexity.
