How to connect TradingView strategies to Kraken Futures
Deterministic execution. Non-custodial. Fail-safe by default.
If you're running strategies in TradingView and want them to place real orders on Kraken Futures, you have two options:
- Build and maintain the execution layer yourself
- Use a purpose-built execution router
This page explains both — plainly — so you can choose what makes sense.
The basic idea
TradingView does not place trades.
What it does:
- Run indicators and strategies
- Fire alerts when conditions are met
To trade on Kraken Futures, those alerts must be:
- Received by a server
- Validated
- Translated into an exchange order
- Sent via the Kraken Futures API
That middle layer is where most failures happen.
Option 1: Build it yourself (DIY)
At minimum, you need:
- A server with a public webhook endpoint
- TradingView webhooks enabled
- Secure storage for API keys
- Kraken Futures API integration
- Logic for position sizing and risk limits
- Handling for partial fills, rejections, retries, and duplicate alerts
- Monitoring and logs when things break
This works — until it doesn't.
Common failure modes:
- Alerts firing twice
- Orders rejected due to margin or size constraints
- Missed exits if TradingView or your server goes down
- Silent failures you only notice after the fact
- No clear audit trail explaining why a trade didn't happen
If you're comfortable owning all of this long-term, DIY is a valid approach.
Option 2: Use an execution router (OrderRail)
OrderRail is a non-custodial execution layer that connects TradingView alerts to Kraken Futures.
It is a paid service priced at $30 per month, designed for users already operating TradingView strategies.
OrderRail does not:
- Generate signals
- Modify your strategy logic
- Optimise entries or exits
- Promise profitability
Its sole purpose is to make execution predictable, auditable, and safe.
How OrderRail connects TradingView to Kraken Futures
1. TradingView sends the alert
Your strategy fires an alert with a JSON payload to your unique OrderRail endpoint.
2. Payload is validated
- Payload structure
- Shared secret
- Configured instrument
Invalid requests are rejected and logged. No order is built.
3. Execution risk checks
Before any order is sent:
- Position size is validated
- Instrument and exchange permissions are verified
- Worst-case bounds are enforced
Your strategy-defined exits remain fully untouched.
A last-resort worst-case stop is attached only as a safety net if:
- Your strategy fails to exit
- Alerts stop arriving
- Infrastructure or execution breaks down
It is not part of the strategy.
4. Order is routed or skipped
If all checks pass, an order is sent to Kraken Futures. If any check fails, no order is sent, and the reason is logged.
What makes this safer than most setups
- •
Deterministic behaviour
Same alert and configuration produce the same outcome, every time.
- •
Fail-safe defaults
Missing credentials, invalid payloads, or sizing violations result in no order.
- •
Transparent failure modes
Every send or skip decision is logged with an explicit reason.
- •
Non-custodial by design
You retain full control of funds and strategy logic at all times.
Who this is for
- Users already running TradingView strategies
- Kraken Futures users
- People who prioritise risk control and execution integrity
- Anyone who prefers not to maintain custom webhook infrastructure
Who this is not for
- Signal seekers
- Beginners
- "Set and forget" bots
- Anyone expecting guaranteed returns
Execution visibility
OrderRail surfaces execution outcomes, order status, and fees so users can audit how alerts were handled over time.
Current exchange support
- ✅Kraken Futures
- ⏳Binance, Bybit (planned)
Pricing
$30 per month
Flat pricing. No per-trade fees. Cancel anytime.
After signing in, you'll connect your exchange and purchase execution access before going live.