Frequently asked Questions

FuturesBot is a automated crypto futures trading bot, which trades on Kraken, Bybit and Bitget . The software evaluates the market around the clock with 14 strategies and places orders automatically according to your settings – with multi-level risk management that does not reliably limit losses.

The bot runs locally on your PC, your money stays on your own exchange account at all times. Nobody except you has access. Paper trading is also without exchange registration possible.

FuturesBot trades 17 perpetual futures on Kraken, Bybit and Bitget: BTC/USD, ETH/USD, SOL/USD, XRP/USD, DOGE/USD, ADA/USD, LINK/USD, BNB/USD, AVAX/USD, SUI/USD, TAO/USD, XAUT/USD, ZEC/USD, WIF/USD, XMR/USD, HYPE/USD and XLM/USD.

Currently, 3 exchanges supported: Kraken Futures, Bybit and Bitget. FuturesBot is an independent product and is not offered by Kraken, Bybit or Bitget. You choose your exchange via EXCHANGE= in the .env. Further exchanges are planned, without commitment.

After Kraken, Bybit and Bitget, further exchanges are planned, including OKX, Binance, dYdX and Hyperliquid – with no commitment as to scope and timing. Currently you switch between Kraken, Bybit and Bitget via configuration.

Leveraged futures trading requires basic knowledge. FuturesBot carries out analysis and execution automatically according to your settings – you set strategies, leverage and stake yourself, and you should understand which risks are associated with futures trading. The Paper trading mode allows you to get to know it without real money (simulated); check every setting thoroughly in paper mode first.

Yes. No trading system can guarantee profits. Trading crypto futures involves considerable risks and can lead to the complete loss of the capital used. The multi-stage risk management is intended to limit losses according to your settings but cannot prevent them – stop-loss and protection functions do not take effect reliably (price gaps, slippage, liquidation). Only trade with money whose loss you can bear.

Your money stays always in your own exchange account (Kraken, Bybit or Bitget). The bot runs locally on your PC and connects to your exchange only via API. The API key requires trading permission only – no withdrawal permission. No one but you has access to your money. This does not protect against trading losses: leveraged futures trading can lead to total loss.

Your stop-loss is on the Exchange servers (Kraken, Bybit or Bitget) and remains active even if your PC fails. In the case of price gaps or slippage, execution can turn out worse than the stop price. After a restart, the bot automatically detects open positions and takes over control again.

The Full version (€1.996) includes all 14 bot-native strategies plus the complete TradingView integration, Claude AI, Telegram control and all features.

The TradingView Edition (€599) is a leaner version without the bot's own strategies – it works purely as a TradingView execution engine for your own Pine Scripts. All protection systems, Telegram control and risk management are identical in both versions. Windows or Linux selectable at purchase.

For traders who your own Pine Scripts and want to execute them automatically on their own account at Kraken, Bybit or Bitget – with risk management and protection features. Trading on behalf of third parties or passing on signals may require authorization.

Yes. An upgrade from the TradingView Edition to the full version is possible at any time. Contact us at support@futuresbot.de for the upgrade terms.

Download the free 14-day trial down. To simulate the TradingView Edition:

1) In config/strategies.py set all strategies to False set (disables the bot's own strategies).

2) In config/.env: TRADINGVIEW_ENABLED=true and EXTERNAL_STRATEGIES_ENABLED=0 set; in config/flipper.py: ENABLE_POSITION_FLIPPING = False.

3) Restart the bot.

Now the bot executes only TradingView signals — similar to the TradingView Edition (TV_RAW_EXECUTION stays at false as there). All protection systems (trailing stop, Smart Profit) remain active.

You need:

1. A PC with Windows or Linux
2. A Exchange account (Kraken, Bybit or Bitget) with API key – or paper trading without registration
3. The FuturesBot Download and your license key

Optional: TradingView account for the TV integration, Telegram for remote control, Claude AI API key for AI validation.

FuturesBot is available as Windows version and as a Linux version (selectable at purchase). Mac is currently not supported. For Linux servers (e.g. VPS) there are installation instructions in the documentation – ideal for 24/7 operation. Both platforms? That goes through support.

Step by step:

1. Create an account at your exchange (Kraken, Bybit or Bitget). Kraken: Referral link* (* Advertising/affiliate link — if you sign up through it, we receive a commission at no extra cost to you; the commission may depend on the trading volume of the registered accounts)
2. Go to the API settings of your exchange (e.g. for Kraken: futures.kraken.com/trade/settings/api)
3. Create a new API key with trading permission only
4. Important: Do NOT enable the withdrawal permission — the bot does not need it
5. Copy API key and API-Secret
6. Enter both in the config/.env file (API_KEY=... and API_SECRET=...)
7. Restart the bot — first check your settings thoroughly in paper mode before trading with real money.

Your money always stays in your exchange account. The bot can only trade, never pay out money.

A detailed step-by-step guide is included with the bot (docs/README_LINUX.txt). Brief overview:

1. Copy ZIP to server — via scp (command line) or FileZilla (graphical)
2. Connect via SSH e.g. ssh benutzer@server-ip (PowerShell/Terminal) or PuTTY
3. Unzip — unzip FuturesBot_*.zip (if not installed: sudo apt install unzip -y)
4. Make executable — chmod +x bin/start
5. Adjust configuration — nano config/.env (API key, secret, Telegram etc.)
6. Start — ./bin/start (or via the bundled desktop frontend "FuturesBot starten" (Start FuturesBot))

Important for 24/7 operation: Use screen or tmux, so that the bot keeps running in the background even if you disconnect the SSH connection:

• screen: screen -S futuresbot → Start the bot → Ctrl+A, D to detach → screen -r futuresbot for reconnecting
• tmux: tmux new -s futuresbot → Start the bot → Ctrl+B, D to detach → tmux attach -t futuresbot

The bot can also be run on a VPS — for many uses an inexpensive Linux server is enough (from about 5 €/month, depending on the provider).

Yes. After every change to the configuration files the bot must be restarted so that the new settings are applied. In the user interface you stop and start the bot via the buttons; in the terminal (e.g. a Linux server) you end it with Ctrl+C and start it again.

If the bot is running, the user interface asks when you close via the window X: “Close window, keep bot running”, “Stop bot and close” or Cancel – with a warning if positions are open. The button “Close – bot keeps running” only closes the window; the bot keeps trading in the background. Configuration changes that have not been applied are asked about beforehand. The stop-loss of open positions sits at the exchange and remains in place even without a running bot; however, trailing and the time limit only work while the bot is running.

We recommend Visual Studio Code (VS Code) – free, with syntax highlighting for Python files and easy to use. Any text editor works, but VS Code offers the best convenience.

FuturesBot uses several configuration files in the config/ Folder:

• .env – API keys, Telegram, basic settings, leverage, position size, position limits, protection mode (PROTECTION_MODE), license key
• strategies.py – Switch strategies on/off
• risk.py – fine risk settings (the leverage values themselves are in the .env)
• protection.py – protection settings (trailing stop, Smart Profit Protection)
• flipper.py, paper_trading.py, claude_config.py – position switching, paper mode, Claude (optional)
• external_strategies.py – additional strategies (full version only)
• tradingview_config.py – TradingView signal check and fine settings (on/off, port and raw mode are in the .env)

All files include comments and can be edited with any text editor.

Leverage is fully configurable via the .envfile: MIN_LEVERAGE, MAX_LEVERAGE and DEFAULT_LEVERAGE. The starting value is DEFAULT_LEVERAGE (by default MIN 1 / MAX 5 / DEFAULT 5); caps by market phase and strategy type can lower it within your limits, an automatic adjustment by volatility is off by default. You also set the position size in the .env enter (BASE_POSITION_SIZE_PERCENT). After the change, the bot must be restarted.

In the strategies.py each of the 14 strategies can be activated or deactivated individually – separately for LONG and SHORT: Set enabled_long or enabled_short on True (active) or False (inactive). Restart required. Alternatively via Telegram (/strat schalten) – this takes effect immediately, but only until the next restart.

In the .env you choose via PROTECTION_MODE (default: SMART) between two protection modes: Smart Profit Protection (4-zone system with wick protection) or the 23-level trailing stop (purely price-based). Both modes are fully configurable. Only one mode can be active at a time.

Strategy presets are preconfigured variants of individual strategies with adjusted parameters. Example: for Trend Following there is a conservative preset (stricter filters, higher trend strength and score requirements) and a aggressive preset (looser thresholds, more signals). For Breakout there is a confirmed Preset with squeeze and volume confirmation before entry.

Currently there are 4 predefined presets for 3 strategies, all switched off by default. Presets are enabled in strategies.py (activation:enabled: True). Several presets of the same strategy can be active at the same time — each as an independent signal. You can also create your own presets by adding new entries with your own overrides add.

All configuration files are delivered with default settings as a starting point (not a recommendation). If you want to undo changes, you can restore the original files from the download archive. Tip: Before making changes, always create a backup of your config/ folder.

FuturesBot can receive signals from TradingView Pine Scripts receive and execute automatically on Kraken, Bybit or Bitget. For this, a webhook server (configurable port, default: 5000) runs on your PC and receives TradingView alerts. TradingView reaches it only via port 80/443 – through a reverse proxy, tunnel or port forwarding.

You can use the TradingView integration in addition to the bot's own strategies (full version) or as the sole signal source (TradingView Edition) – including all protection systems, Telegram control and risk management.

→ Complete TradingView guide with configuration

There is 3 modes, which determine how TradingView signals are processed:

• Raw Execution – direct execution without the bot's signal checks
• Confluence – TradingView confirms bot signals (full version only)
• Filters – TradingView blocks conflicting bot trades (full version only)

Each mode has its own use case – from direct execution to additional checking.

In Raw Execution mode, TradingView signals are directly and without the bot's signal checks executed (the price deviation check and paper mode remain active according to the configuration). Every incoming entry signal is converted into a trade immediately – higher risk of loss. Intended for traders who fully trust their Pine Scripts. All protection systems (Trailing, Smart Profit) nevertheless remain active.

In Confluence mode, it is required that TradingView and bot strategies match, before a trade is executed. TradingView confirms the bot's signals (or vice versa). A trade is only made when TradingView and the bot strategy agree – fewer signals are executed. Whether this improves the result is not proven; first test thoroughly in paper mode.

In Filter mode TradingView blocks contradictory signals. If your Pine Script is bearish, for example, the bot's long signals are suppressed. TradingView acts as an additional filter – not a signal generator of its own, but a checking layer that blocks bot signals against the TradingView direction.

Step-by-step guide:

1. Make sure the webhook server is running in the bot (port configurable in the .env over TRADINGVIEW_WEBHOOK_PORT, default: 5000)
2. Set up port forwarding or a reverse proxy so that TradingView can reach your server over the internet
3. In TradingView, open the desired chart and add your Pine Script indicator
4. Create a new alert – select "Webhook URL" and enter your server URL (e.g.  https://deine-domain/webhook – TradingView only sends to port 80/443; reverse proxy, tunnel or port forwarding forward to the local port 5000. Token protection is currently not usable; protect the endpoint via reverse proxy or firewall)
5. Set the alert format to JSON (see the next question for the exact format)
6. Choose the appropriate TradingView mode in the .env (Raw: TV_RAW_EXECUTION, Confluence/filters, full version only: TRADINGVIEW_USE_AS_CONFLUENCE / TRADINGVIEW_USE_AS_FILTER – environment variables, true by default, not contained in the delivered .env included)
7. Restart the bot – done! The alerts appear in the log. Test the chain thoroughly in paper mode first.

TradingView alerts must be formatted as JSON and contain at least the fields signal (long/short), symbol (e.g. ETH, SOL, XRP, DOGE — 17 symbols in total) and price included. Close signals are accepted but do not close a position – the bot controls exits; stop-loss/take-profit in the alert serve for information only. The exact format with all optional fields is in the tradingview_config.py documented, and examples are included in the documentation. The bot automatically validates incoming alerts and discards invalid formats.

The bot processes the signal types: Long (buy/open a long position), Short (sell/open a short position) and Close (is accepted but does not close any position – exits are controlled by the bot). In the Full version are additionally Flip signals supported, which automatically reverse an existing position (long to short or vice versa; on by default – first closing via reduce-only, then reopening).

Note on the TradingView Edition: In the pure TradingView Edition, automatic reversal is deactivated — your Pine Script supplies the entries, and the position is managed by the bot's protection systems (stop-loss, stop trailing, time limit). An opposing signal opens a new position there only once the old one has previously been closed in the regular way (e.g. by stop, stop trailing or time limit).

The bot can trade multiple symbols in parallel — both with the bot's own strategies and via TradingView alerts. In the delivered .env there are three ready-made Trading profiles to choose from (activate exactly one):

• Profile A — single symbol (classic): Bot scans and trades only ACTIVE_SYMBOL. MULTI_SYMBOL_ENABLED=false, MAX_CONCURRENT_POSITIONS=2.
• Profile B — Multi-Symbol (as-delivered state for all exchanges; technical starting value, not a recommendation): The bot scans the symbols in the scan list in turn (round robin, at most 6). MULTI_SYMBOL_ENABLED=true; default scan list ETH/BTC/SOL/ADA, MAX_CONCURRENT_SYMBOLS=3, MAX_CONCURRENT_POSITIONS=4, smaller position size per trade.
• Profile C — Multi-Symbol 3 (intended for exchanges with tighter API limits; not a recommendation): 3 symbols in the scan list, separate position limits.

In addition, the bot accepts, with TV_MULTI_SYMBOL=true TradingView webhooks for all symbols — the trade opens on the symbol reported by the Pine Script, regardless of the profile. 17 markets, one bot, one shared position budget.

The software processes a maximum of about 30 alerts per analysis cycle; alerts beyond that are ignored. How many positions may be open at the same time is limited by MAX_CONCURRENT_SYMBOLS and MAX_CONCURRENT_POSITIONS in the .env; how many alerts you can create depends on your TradingView plan.

Whether webhook alerts are possible and how many alerts you can create depends on your TradingView plan – check this with TradingView before setting up.

Two current scripts (Master and Precision) are included with the bot download. On TradingView you will also find example scripts provided by the provider (older versions) by the author "jura1986" – not a recommendation. They use the matching JSON alert format for FuturesBot; like any signal source, check them first in paper mode. Here you will find the scripts: jura1986 Pine Scripts on TradingView →

Yes, absolutely! You can use any Pine Scripts of your own – they only have to output the correct JSON format for the alerts. The format is described in the documentation. This is the main purpose of the TradingView Edition: running your own strategies automated on your own account.

The trial version includes the features of the full version with deviations: one bot instance, diagnostic report by email only and a smaller daily quota of the AI help. It runs in paper mode by default, live trading is possible. If the software is still running shortly before the trial expires, it closes open positions with a market order.

The trial runs 14 calendar days from activation. The days run continuously – even when the bot is switched off. It is best to start right after activation.

The Full version: €1.996 one-time. The TradingView Edition: €599 one-time. No monthly license costs, no subscription; you bear third-party costs (e.g. exchange fees, TradingView subscription, server) yourself.

No. FuturesBot is a one-time payment. No subscription, no monthly fees, no profit sharing. You pay once: perpetual license without a subscription; operation requires a regular online license check via our server (Terms and Conditions § 9). Updates for at least 24 months from purchase (details under „Are updates free?“).

The license is hardware-bound (one PC). In case of a hardware defect, or if you additionally want to use the second platform version (Windows→Linux or Linux→Windows), contact support at support@futuresbot.de with your proof of purchase – changing computers and the second platform version are handled via support.

The license is bound to one computer. Changing computers (e.g. in case of a defect) is handled via support: Write to support@futuresbot.de with your proof of purchase.

After the trial ends, you buy the full version and receive your license key. Tip: Copy your config/ folder – this way all your settings, strategy configurations and adjustments are preserved. You don't have to reconfigure anything.

How the update works:

1. Stop the bot, download the new version (ZIP) and unzip — this creates a new folder next to the old one
2. Copy from the old folder into the new one: config/, logs/ as well as license.key, activation.lock and trial_lock.dat (if present, in the root of the folder)
3. Start the program in the new folder — the desktop front end shows a dialog with the changed default values
4. Decide per parameter: keep your own value or adopt the new default; once everything is running, the old folder can be deleted

Good to know: Your config/ comes unchanged from the old folder; the new default templates are located separately under bin/config_template/. The dialog compares your own values against new defaults and shows only real conflicts.

API keys and secrets are NEVER shown as a conflict — they always stay at your value.

Note: With the carried-over logs/-folder, the account balance with statistics and the “Last trades” list are also kept. Without the desktop frontend the update works the same way, only without a dialog (details: docs/README_CONFIG.txt).

You receive security and functionality-preserving updates for at least 24 months from purchase at no additional cost; we have so far provided further updates free of charge, but there is no entitlement to new features.

Update notifications arrive by email, you download new versions in the customer area.

Paper trading is the Simulation mode of FuturesBot. The bot analyzes the real market and simulates trades – without real money. You see how the bot would trade according to your settings – with simulated profits and losses. Suitable for testing new strategies or configurations. New: Paper trading also works without exchange login – simply set EXCHANGE=bybit, leave the API keys empty and PAPER_TRADING=true. The bot uses real market data but trades only in simulation.

Paper mode models flat-rate fees (Taker 0,05 %, Maker 0,02 %) and slippage (0,01–0,03 %) approximately; Funding payments are not recorded in paper mode. Starting capital 10.000 by default (in paper_trading.py). Live results can differ significantly, especially with low liquidity; paper results are not a forecast.

The bot runs in one mode – either paper or live. However, you can switch between the modes at any time by changing the setting in the configuration and restarting the bot – or via Telegram with /paper_on or /paper_off (restarts, only without open positions) or in the user interface.

3 simple steps:

1. Create a Telegram bot: Open Telegram, search for @BotFather, send /newbot, choose a name and a username (must end in "bot"). You will receive a Bot token — copy it!
2. Find out the chat ID: Search @userinfobot in Telegram, send /start — your Chat ID is displayed.
3. Enter in config/.env:
   TELEGRAM_TOKEN=dein-bot-token
TELEGRAM_CHAT_ID=deine-chat-id
TELEGRAM_ENABLED=true

Restart the bot — afterwards you query status, positions and results by command (e.g. /status, /pos). Automatic push notifications are switched off in the current version.

The most important commands:

• /pos – Show current positions
• /balance – query account balance
• /pnl – Profit/loss overview
• /long – open a long position (with confirmation prompt)
• /short – open a short position (with confirmation prompt)
• /closeall – close all positions
• /leverage – show or change leverage
• /pause, /resume – pause or resume trading

And many more commands for statistics, configuration and bot control.

Yes! You can execute trades directly via Telegram – opening long and short (/long, /short) and closing all positions (/closeall) is possible by command. Full remote control from your phone, wherever you are.

FuturesBot can optionally Anthropic Claude AI use to support trading decisions. The AI analyzes market data, news and technical indicators and gives an additional automated assessment of each trade – according to your rules, not an investment recommendation. The integration is completely optional and can be enabled or disabled at any time.

→ Complete Claude AI guide with configuration

Claude AI is billed by usage – via your own Anthropic API key. The costs depend on the intensity of use (which components are active and how often they are called). FuturesBot itself charges no additional costs for the AI integration.

No. Claude AI is fully optional. FuturesBot works on its own with its 14 strategies and the scoring system. The AI is an additional filter for traders who want a further automated check of their trades.

Each component can be switched on or off individually:

• Trade validation – As the last check before the order, Claude assesses the signal using the bot's market data, optionally with a web search for acute extreme events; result FREIGABE (approval) or SPERRE (block); in case of timeout or error the signal is skipped. Not an investment recommendation.
• Exit check on time exit (optional) – When a position reaches its maximum holding time without any appreciable profit, the bot asks Claude about the short-term market direction; with sufficient confidence in the position's direction, the time exit is postponed by a few minutes (at most 3×). Postponing can increase the loss. Not an investment recommendation.

FuturesBot offers 2 selectable protection modes plus a server-side stop-loss on your exchange (Kraken, Bybit or Bitget). In addition there are liquidation distance monitoring, dynamic position sizes and an automatic emergency brake. The stop-loss always sits on the exchange server – it remains in place even if the PC goes down. There is no reliable protection against losses (price gaps, slippage, liquidation).

Smart Profit Protection is a 4-zone system, which moves the stop up in steps depending on the profit reached. Each zone has its own rules for the stop adjustment; partial sales exist by default only in the PROFIT and RUNNER zones (25–30 % depending on the profile). In addition there is Wick Protection: With the software-side stop, a brief price spike (wick) alone does not trigger an exit; the stop-loss on the exchange takes effect independently of that.

A purely price-based system with 23 automatic profit levels. The further your trade is in profit, the larger the share of the profit that the stop secures (the absolute distance to the price grows with it). The 23 levels apply to the standard tables; 15-minute strategies use 12, additional strategies 11 levels. Completely automatic – you do not have to adjust anything manually. Ideal for traders who prefer a simple, transparent protection system.

The server-side stop-loss on the exchange remains in place even during extreme market movements. In addition, the liquidation distance monitoring watches the approach to the liquidation price and can reduce positions automatically. Note: during extreme volatility, slippage can occur – the actual execution price may deviate from the stop price, and a liquidation can still occur.

All data is locally on your PC stored. Configuration files in the config/ folder, logs in the logs/ folder. Data goes to external servers only for: trading commands and account queries to your exchange, market data requests (exchanges, e.g. Binance), the license check (futuresbot.de), trial registration and time services, the version query (update notice), a diagnostic upload triggered by you, the AI chat, and optional services such as Telegram, Claude AI or TradingView.

FuturesBot writes in the logs/ Folder one file per topic (e.g. trading, TradingView, errors) and creates weekly archives (details: docs/README_LOGS.txt). The logs cover trading activity, errors, performance data and system status. This helps with traceability and error analysis.

With the follower function you can automatically mirror trades to a second exchange account mirror (Kraken, Bybit or Bitget). New: cross-exchange mirroring – the follower account can be on a another exchange than the main bot (e.g. bot on Kraken, follower on Bybit). One bot, two accounts: off by default (FOLLOWER_ENABLED=false), live mode only; the second account uses the same leverage as the main account and its own position size based on its balance. For your own accounts only. Trading for third parties or passing on signals may require a permit.

By email to support@futuresbot.de. We usually reply within 24 hours. For technical questions, please attach relevant log files – this speeds up troubleshooting.