Why Automate Bitunix with TradingView
Bitunix has rapidly emerged as one of the most exciting crypto derivatives exchanges. With competitive fees, a clean trading interface, and deep liquidity on popular perpetual pairs, it has attracted a fast-growing community of derivatives traders looking for a reliable alternative to the established incumbents.
But even on a fast exchange like Bitunix, manual trading has inherent limitations. You cannot monitor charts around the clock. Breakouts happen at inconvenient hours. Emotions cloud judgment during volatile moves. And by the time you manually open your app, log in, and place the order, the optimal entry is often gone.
TradingView solves the strategy side of this equation. Millions of traders use Pine Script indicators and alerts to identify trading opportunities. The missing link has always been reliable execution: turning a TradingView alert into an actual order on the exchange, instantly and without manual intervention.
Flipr.Cloud bridges that gap. When your TradingView indicator triggers, the alert fires a webhook to Flipr.Cloud, which parses your command and places the order on Bitunix within 50 to 250 milliseconds. No manual intervention. No missed entries. No complicated JSON formatting.
What makes the Bitunix integration special is that Flipr.Cloud uses a native API integration rather than a generic CCXT wrapper. This custom-built connection communicates directly with Bitunix servers, eliminating the overhead of translation layers. Combined with routing through the Flipr Singapore server for minimal network latency, the result is some of the fastest webhook-to-execution times available.
Prerequisites
Before you begin, make sure you have the following accounts and tools ready. The entire setup takes about 5 to 10 minutes once you have these in place.
- Bitunix Account (verified) — Sign up at bitunix.com and complete identity verification. You need a verified account to create API keys and trade futures.
- TradingView Account (Essential plan or higher) — Webhooks are a paid feature on TradingView. The Essential plan (or higher) is required to send webhook notifications from your alerts. The free plan does not support webhooks.
- Flipr.Cloud Account — Create a free account at flipr.cloud. The free trial gives you full access to all Pro features with no time limit and no credit card required, so you can test everything before committing.
Testnet Available
If you want to test without risking real funds, Bitunix offers a testnet environment for simulated trading. You can create a testnet API key and toggle the Testnet option in Flipr.Cloud to connect to it. This is the recommended approach for your first setup.
Step 1: Create a Bitunix API Key
The API key is how Flipr.Cloud authenticates with Bitunix to place orders on your behalf. You will create a restricted key that can only trade, never withdraw, ensuring your funds stay safe even if the key is ever compromised.
- Log in to your Bitunix account and navigate to Account > API Management.
- Click "Create API" to generate a new API key.
- Give the key a descriptive label, such as
Flipr-TradingVieworTV-Automation. - Set Permissions: Enable "Trade" only. Do not enable "Withdraw" or "Transfer" permissions. Trading permission is all Flipr.Cloud needs.
- IP Whitelisting (recommended): For extra security, add the Flipr.Cloud Singapore server IP to the allowed list. You can find the current server IP in your Flipr.Cloud dashboard under API Keys settings.
- Click "Confirm" and complete any verification Bitunix requires.
- Save your API Key and Secret Key immediately. Bitunix only shows the Secret Key once. Store both values in a secure password manager.
Security Warning
Never share your API key or secret with anyone. Never enable withdrawal permissions for a trading bot key. If you suspect your key has been compromised, delete it immediately from Bitunix and create a new one. Flipr.Cloud encrypts all API keys at rest using industry-standard Fernet encryption.
Step 2: Add the API Key to Flipr.Cloud
Now that you have your Bitunix API key and secret, you need to register them with Flipr.Cloud so it can execute trades on your behalf.
- Log in to Flipr.Cloud and navigate to the API Keys page from the sidebar.
- Click the "Add API Key" button.
- Select Bitunix as the exchange.
- Select Futures as the market type.
- Paste your API Key and Secret Key into the corresponding fields.
- Give the key a recognizable label (e.g.,
Bitunix-Main). - If using testnet, toggle the "Testnet" option before testing.
- Click "Test Connection" to verify that Flipr.Cloud can reach Bitunix with your credentials.
Connection Verified
If the test shows your account balance, the connection is working correctly. Flipr.Cloud is now authorized to place trades on your Bitunix account. If the test fails, double-check that your API key has Trade permission enabled and that you copied the key and secret without extra spaces.
After adding the key, you will see your personal webhook URL on the dashboard. It looks like:
Your Webhook URL
Copy this URL. You will need it in the next step when configuring your TradingView alert.
Step 3: Create a TradingView Alert with Webhook
This is where the automation happens. You will configure a TradingView alert that sends a webhook request to Flipr.Cloud every time your indicator or strategy triggers. Flipr.Cloud will parse the message and execute the trade on Bitunix instantly.
- Open your chart on TradingView with the indicator or strategy you want to automate.
- Click the "Alert" button (clock icon) or press
Alt + A. - Set your alert condition (e.g., indicator crossing a threshold, strategy entry signal, price level).
- In the "Notifications" tab, check "Webhook URL" and paste your Flipr.Cloud webhook URL.
- In the "Message" field, enter your trading command using Smart Syntax. This is plain text, not JSON:
Alert Message (Market Entry with SL/TP)
That is it. Two lines. The first line specifies the symbol and exchange. The second line is the trading command with an inline stop loss and take profit. When the alert fires, Flipr.Cloud will:
Open a long position of 0.01 BTC on Bitunix Futures
Set a stop loss 2% below the entry price
Set a take profit 5% above the entry price
Click "Create" to save the alert. TradingView will now send a webhook to Flipr.Cloud every time this alert triggers.
About Bitunix_F
The _F suffix tells Flipr.Cloud to route the order to Bitunix Futures (perpetual contracts). Always include this suffix when targeting Bitunix. If you have multiple Bitunix API keys, you can target a specific one by using the key label instead, e.g., BTCUSDT on Bitunix-Main.
Step 4: Test with a Small Order
Before deploying your full strategy, always test with the smallest possible position size. This confirms that the entire pipeline works: TradingView fires the alert, Flipr.Cloud receives it, parses the command, and executes the trade on Bitunix.
- Create a test alert with a condition that will trigger soon (e.g., price crossing a level that is close to the current price).
- Use the minimum position size for the pair. For BTCUSDT on Bitunix, this is typically 0.001 BTC.
- Open the Real-Time Log on your Flipr.Cloud dashboard. This shows every incoming webhook and the resulting trade execution in real time via Server-Sent Events.
- Wait for (or manually trigger) the alert. Watch the Real-Time Log for the execution confirmation.
- Verify the order on Bitunix by checking your Positions and Order History.
Pay attention to the execution speed shown in the Real-Time Log. For Bitunix, you should see execution times under 250ms thanks to the native API integration. This is the time from when Flipr.Cloud received the webhook to when the order was confirmed by Bitunix.
Quick Test Without Waiting
You can also test your webhook directly using the "Test Webhook" feature on the Flipr.Cloud dashboard, or by sending a manual HTTP POST request to your webhook URL. This lets you verify the connection without waiting for a TradingView alert to trigger.
Useful Smart Syntax Commands for Bitunix
Flipr.Cloud uses Smart Syntax, a plain-text command format designed for TradingView webhooks. Here are the most common commands you will use with Bitunix Futures. Every example assumes the first line is your symbol header (e.g., BTCUSDT on Bitunix_F).
Market Entry with Stop Loss and Take Profit
The most common command. Opens a position at market price with protective stop loss and take profit orders placed automatically.
Market Long with SL/TP
The off prefix means "offset from current price." So sl off 2% places the stop loss 2% below your entry, and tp off 5% places the take profit 5% above.
Limit Entry
Place a limit order at a specific offset from the current price, with stop loss and take profit.
Limit Order
This places a limit buy order 1% below the current price. The SL and TP will be placed after the limit order fills.
Close a Position
Close part or all of an open position. Use percentage of position size for flexible exits.
Close Entire Position
Close Half Position
Entry-Relative Stop Loss and Take Profit
Use the e prefix to set SL/TP relative to your entry price instead of the current price. This is useful when the market price may have moved by the time the order executes.
Entry-Relative SL/TP
For a short position, sl e+1.5% places the stop loss 1.5% above entry, and tp e-4% places take profit 4% below entry.
Multiple Take Profits
You can send multiple commands in a single webhook message using a block format. This is useful for scaling out of a position at different price levels.
Entry with Multiple Take Profits
This opens a 0.03 BTC long, then sets three take profit levels: 33% of the position at 3% profit, another 33% at 5%, and the remaining position at 8%.
Check Balance
You can check your Bitunix account balance at any time by sending a simple balance command.
Balance Check
Bitunix-Specific Tips
Bitunix has some exchange-specific characteristics that are worth understanding when setting up your automation. Here are the key points to keep in mind.
Native API Integration
Unlike most exchanges on Flipr.Cloud which use the CCXT library, Bitunix is integrated via a custom-built native REST API client. This means Flipr communicates directly with Bitunix servers without any translation layer. The result is faster order placement, more accurate error messages, and better handling of Bitunix-specific features. You do not need to do anything different; the native integration is used automatically when you target Bitunix_F.
USDT-Margined Perpetual Futures
Bitunix futures are USDT-margined perpetual contracts. Your margin and PnL are both denominated in USDT. Make sure you have USDT in your futures wallet before opening positions. All symbols follow the format SYMBOLUSDT (e.g., BTCUSDT, ETHUSDT, SOLUSDT).
Leverage Settings
Bitunix allows you to set leverage per trading pair on the exchange interface. Flipr.Cloud respects whatever leverage you have configured on Bitunix. Set your desired leverage directly on Bitunix before running automated trades. This gives you full control over your risk exposure without needing to specify leverage in your webhook commands.
Singapore Server Routing
Flipr.Cloud routes all Bitunix orders through its Singapore server, which provides the lowest network latency to Bitunix infrastructure. This is handled automatically. When you send a webhook to Flipr.Cloud, the system detects the target exchange and routes the request to the optimal regional server before executing the trade. Combined with the native API, this delivers execution speeds of 50 to 250ms.
Growing Pair Selection
Bitunix has been rapidly expanding its list of supported perpetual futures pairs. BTC, ETH, SOL, XRP, DOGE, ADA, AVAX, LINK, and many more altcoins are available. New pairs are added regularly. Check the Bitunix exchange for the most up-to-date list of supported symbols.
Troubleshooting
If your webhook automation is not working as expected, here are the most common issues and their solutions. Most problems are related to API key configuration or symbol formatting.
"Invalid API Key" Error
- Verify you copied the API key and secret correctly, with no extra spaces or characters.
- Confirm the key has Trade permission enabled on Bitunix.
- Make sure the key is for the correct environment (live vs. testnet).
- Use the "Test Connection" button in Flipr.Cloud to re-verify.
"IP Not Whitelisted" Error
- If you enabled IP whitelisting on Bitunix, add the Flipr.Cloud Singapore server IP to the allowed list.
- The server IP is displayed on the Flipr.Cloud API Keys page when you select Bitunix.
- Alternatively, disable IP restrictions on the Bitunix API key if you prefer simplicity (slightly less secure).
"Insufficient Balance" Error
- Ensure you have sufficient USDT in your Bitunix Futures wallet (not Spot wallet).
- Transfer USDT from your Spot wallet to Futures wallet on Bitunix if needed.
- Check that your position size multiplied by current price divided by leverage does not exceed your available margin.
"Symbol Not Found" Error
- Use the format
BTCUSDTwithout slashes or colons. - Do not use
BTC/USDTorBTC/USDT:USDT. Bitunix uses the concatenated symbol format. - Make sure the pair is listed on Bitunix Futures. Not all crypto assets have a corresponding futures contract.
Webhook Not Received
- Confirm the webhook URL is correctly pasted in TradingView. It should start with
https://flipr.cloud/webhook/. - Check that your TradingView plan supports webhooks (Essential or higher).
- Look at the Real-Time Log on Flipr.Cloud to see if the webhook arrived but failed to execute.
- Make sure the alert is active and has not expired.