Bybit ranks as the third-largest crypto derivatives exchange by open interest (CoinGecko, accessed July 2026), so it's a common target for automated TradingView strategies. Here's how the connection actually works, and how to wire it up without the usual mistakes.

How does connecting Bybit to TradingView actually work?​

Bybit and TradingView have no native integration. You bridge them with a webhook: TradingView posts a JSON alert to TradingView Hub, which holds your Bybit API key and places the order. The webhook path delivers in seconds, against the roughly 60-second email fallback (TradingView Hub docs, 2026).

So there are always three parts in the chain, and it helps to picture them before you start.

TradingView never touches your funds; it only sends a message. Sizing, leverage, and order type all live in that JSON, and TradingView Hub turns it into a real Bybit order. The webhook anatomy post breaks down what each value means.

What do you need before you connect?​

Three things: a Unified Trading Account on Bybit, a paid TradingView plan, and a TradingView Hub account. TradingView's free plan doesn't include webhook notifications, so it can't send orders to Bybit; webhook delivery starts on the Essential tier (TradingView pricing, accessed July 2026).

The TradingView Hub account is the one you can get for free. If you don't have a Bybit account yet, create it through our referral link and the bot stays free for as long as you use it. Bybit pays us a commission on that signup, and that commission is what funds the free access. Already trading on Bybit? Paid subscriptions start at $23/month, with discounts on longer terms.

New Bybit accounts default to "Classic" mode. TradingView Hub expects the Unified Trading Account (UTA), which keeps Spot, Futures, and Options under one balance. Activate UTA from your Bybit account settings before you create the API key, or the key won't have the right trading scope.

Which TradingView plan do you need for webhooks?​

TradingView's free plan doesn't include webhook notifications, which is the mechanism this whole setup relies on. As of July 2026, the free plan includes 3 active price alerts, so you can watch a strategy by hand, but you can't fire an automated order from it. Webhook delivery starts on the Essential tier. There's no way around it: no webhook, no automated Bybit order.

How to create a Bybit API key for TradingView​

Creating the key takes about two minutes. Log in to Bybit, open API, create a system-generated key, and bind it to tv-hub.org as a third-party app with Read-Write permission. Because it's third-party bound, no IP whitelist is needed, and Bybit expires the key after 90 days (Bybit API docs, accessed July 2026).

Most competitor how-tos still show the old IP-whitelist flow. Bybit's third-party binding replaced that for supported apps, so the current steps look like this.

1. Log in at bybit.com, click your account icon in the top right, and open API.

2. Click Create New Key, then choose System-generated API Keys.

3. On the key form, select Connect to Third-Party Applications, type tv-hub.org in the application name field and pick it from the list, set permissions to Read-Write (Unified Trading, Contract and Spot trade), leave withdrawals off, then submit.

Bybit's own note on that page confirms the timing: keys not bound to an IP address stay valid for three months. That 90-day TTL matters later, because TradingView Hub doesn't auto-rotate the key and your alerts start failing the day it lapses (the rejections show up in the Activity Log). Copy the key and secret (Bybit shows the secret once) for the next step.

How do you send your first Bybit webhook from TradingView?​

A working Bybit webhook needs only two TradingView fields: the Webhook URL (https://alerts.tv-hub.org) and a one-line JSON Message carrying your token, exchange, pair, and the order. In our own testing, the alert reaches TradingView Hub within seconds of the trigger. First, hand the key to TradingView Hub.

Open Account, Settings, API Keys in TradingView Hub, pick Bybit, and paste the key and secret you just copied.

Now build the alert. In TradingView, create an alert, paste https://alerts.tv-hub.org into the Webhook URL box (need the exact endpoint? see which webhook URL to use), and drop the JSON into the Message box.

The minimal Bybit webhook payload (annotated)​

This is the smallest market-order payload that does something real on Bybit. It's the exact schema from our Bybit API key setup and payload reference, not a legacy example.

{
  "token": "your-tvh-token",
  "exchange": "bybit",
  "pair": "BTCUSDT",
  "isMarket": true,
  "isBuy": true,
  "units": 50,
  "unitsType": "percentBalance",
  "leverage": 5,
  "marginType": "cross"
}

One field isn't in the payload above: apiKey. If you've stored a single Bybit key in TradingView Hub, it's selected automatically. Once you keep more than one Bybit key, add apiKey with the name you gave the key in the dashboard so the order routes to the account you mean.

TradingView strips newlines from the Message field, so compact JSON on one line is fine. For how the JSON message field works, the alert message format docs go deeper. Bybit has a few quirks of its own too, like the separate take-profit-attach flags for market versus limit entries and UTA-wide sizing, all covered in the Bybit exchange reference.

How do you test safely on Bybit Demo first?​

Test on Bybit's Demo Account before you risk real money. It mirrors live prices behind a single checkbox, with no separate site or login, so you can validate the full alert-to-order path on paper. TradingView Hub demo trading is always free, including the prop-firm demo, with no referral required (TradingView Hub docs, 2026).

On bybit.com, open the Tools menu and switch on Demo Trading. Generate a demo API key the same way you made the live one, add it to TradingView Hub, and fire the same alert. The round trip is identical, just on paper.

Run your alert on demo and watch the orders land. Only swap in the live key once you've seen the full path work. If you want the difference between demo and the separate testnet spelled out, that's covered in a companion post on Bybit testnet vs demo.

How do you run a free Bybit trading bot?​

You run a free Bybit trading bot by opening your Bybit account through TradingView Hub's referral link. Do that, and the full bot stays free for as long as you keep trading, with no separate subscription needed for the live connection.

Free here means the complete product: live webhook trading on Bybit, every exchange feature, and no time limit or trial clock. Bybit pays TradingView Hub a commission on that referred signup, and that commission is what covers your access, so the cost lands on the exchange, not on you. Already have a Bybit account you don't want to replace? You can run the same bot on a paid plan instead, starting at $23/month with discounts on longer terms. And demo trading stays free for everyone regardless, referral or not, so you can validate a strategy on paper before any of this matters.

Why isn't my Bybit webhook firing?​

The most common Bybit webhook failure is an expired or wrong-permission API key that Bybit rejects. Bybit keys lapse after 90 days and TradingView Hub doesn't auto-rotate them (Bybit API docs, accessed July 2026). Check the Activity Log first: it records every inbound alert and the exchange's response, so it usually tells you exactly what broke. The Debug a Failed Trade Alert guide maps the common log entries to their fixes.

When we tested this on Bybit Demo, the first order that failed was almost always a Read-only key or an un-activated UTA. The table below is ordered by how often each one actually bit us, not alphabetically.

Work top to bottom. Nine times out of ten it's the key.

From a first trade to a full strategy​

Once your first Bybit order lands from a TradingView alert, the hard part is done. From here you can layer on stops, take-profits, and multiple alerts, all through the same webhook. When you're ready to move past a single manual setup, the landing page on how to automate Bybit trades with TradingView covers the strategy side and the trade-command builder.

Keep testing on demo whenever you change the payload. The full referral walkthrough, with the fee schedule and signup screenshots, lives in a dedicated post.

That's the full path: a webhook, a read-write key bound to tv-hub.org, one JSON message, and a demo run first. Get it working once, and every future Bybit strategy is just a change to the payload.

If you're building your first auto-trading setup from scratch, start with the TradingView automation guide, which covers the whole flow including a video tutorial. This post is the payload reference behind that setup.

What does a TradingView Hub webhook payload look like?​

A valid payload is a flat JSON object with four required fields plus one direction flag. TradingView posts the contents of an alert's Message field to your webhook URL, as described in TradingView's webhook docs (accessed July 2026). The full TradeCommand exposes 84 properties, but a working order needs only a handful.

Here's the smallest payload that actually fills on an exchange:

{
  "exchange": "bybit",
  "pair": "BTCUSDT",
  "isBuy": true,
  "isMarket": true,
  "unitsType": "percent",
  "unitsPercent": 1,
  "apiKey": "bybit-demo",
  "token": "YOUR_TOKEN"
}

Paste that into your alert's Message field, drop your webhook URL into the Webhook URL box, and the alert is wired. When the condition fires, a 1% market buy hits Bybit. Two endpoints exist: Binance markets (binance, binance-futures, binance-futures-coin) post to https://binance.tv-hub.org, and every other exchange posts to https://alerts.tv-hub.org. The quickstart runs this same flow against a demo account so you can test with zero risk, and the full field list lives in the canonical schema built for pasting into an LLM.

One caveat before you build this. Webhooks are a paid TradingView feature. The free plan doesn't include webhook delivery, so it can't fire automated webhook orders; that starts with the Essential tier. As of July 2026, the free plan includes 3 active price alerts, which is enough to test a single strategy by hand. TradingView's alert docs (accessed July 2026) cover how to attach the Message and the URL. If you're wiring Bybit specifically, the TradingView to Bybit guide covers the account side, and there's a step-by-step walkthrough to connect Bybit to TradingView with screenshots and troubleshooting.

The four fields every payload requires​

Four fields carry a required flag in the schema: exchange, pair, token, and apiKey. The core parameters reference marks all four as mandatory. Miss token and TVH rejects the request before it even looks at the order. Miss apiKey and TVH can't tell which exchange account to route to. Both failures show up as error entries in the Activity Log, and the Debug a Failed Trade Alert guide maps each entry to its fix.

The last two are the ones people confuse. token authenticates the caller: it's a GUID from your account settings that answers who you are. apiKey is the name you gave an exchange key in the dashboard, and it answers which account the order runs on. Every payload needs both, and they're never interchangeable.

How do you set direction, order type, and price?​

Direction and order type are booleans, not string enums. Set isBuy: true or isSell: true for entries, isClose: true to flatten. Pair that with isMarket: true for a market order, or isLimit: true plus a price for a limit. The trade command anatomy explains how the receiver maps these flags.

This is where most hand-written payloads go wrong, so it's worth stressing. There is no side: "buy" and no type: "market" in the schema. Direction is three mutually exclusive booleans, isBuy, isSell, and isClose. Order type is two more, isMarket and isLimit. Send isLimit: true and TVH reads the price field as your limit price. Send isMarket: true and price is ignored.

There's one string field that looks like direction but isn't. orderType exists only to map TradingView's {{strategy.order.action}} placeholder inside strategy alerts. For a normal hand-built webhook, stick with the booleans and leave orderType out.

How do you size a position?​

Sizing runs through units plus unitsType, which accepts six values: absolute, percent, percentBalance, percentWallet, percentPosition, and risk. The parameter reference lists each. Note that units is never a quote-currency amount, so a fixed dollar size uses a separate mechanism.

For most alerts you'll send unitsType: "percent" with unitsPercent set to the share of balance you want to commit, exactly like the minimal example above. absolute means a raw base-asset quantity, so units: 0.5 on BTCUSDT is half a Bitcoin. risk derives the size from your stop distance instead.

Here's the precedence rule that trips people up. If you want to spend a fixed quote amount, say exactly 250 USDT, do not put 250 in units. There is no unitsType: "quote". Instead, set useFixedSize: true and fixedQuoteSize: 250, which overrides units and unitsType entirely. Getting this wrong is the difference between a $250 order and a 250-coin order the exchange rejects.

How do you attach a stop-loss and take-profit?​

Stop-loss is a top-level field: stopLossPercent with stopLossType: "percent", or stopLoss for an absolute price. Take-profit is not a single field. It lives in a targets array, where each entry carries a takeProfitPercent and an amount. The parameter reference documents both, along with the targetType switch.

Send the stop and targets in the same payload as the entry. TVH places them as native exchange orders where the exchange supports it, so they keep working even if your dashboard or connection drops. A 5% entry with a 2% stop and a 4% target looks like this:

{
  "exchange": "bybit",
  "pair": "BTCUSDT",
  "isBuy": true,
  "isMarket": true,
  "unitsType": "percent",
  "unitsPercent": 5,
  "stopLossType": "percent",
  "stopLossPercent": 2,
  "targetType": "percent",
  "targets": [
    { "takeProfitPercent": 4, "amount": 100 }
  ],
  "apiKey": "bybit-demo",
  "token": "YOUR_TOKEN"
}

The targets array is what lets you build a laddered exit. Add more entries, each with its own takeProfitPercent and its share of the position in amount. Set targetAmountInPercent: true when those amounts are percentages of the position rather than base-asset quantities.

For futures, leverage is a separate field, and its ceiling isn't a fixed number. TVH sets the exchange-side leverage only when your requested value differs from the current setting, and the maximum is derived per exchange and per symbol. Both Bybit and Binance cap leverage by symbol tier, documented in Bybit's leverage endpoint and Binance's change-leverage docs (both accessed July 2026). Sending leverage: 0 tells TVH to use the symbol's maximum.

Common webhook mistakes to avoid​

The mistakes that generate the most support tickets are predictable: a chart-formatted pair, a missing token, and a close alert without reduceOnly. The 15 common mistakes doc catalogs the full list. Most are a one-character fix once you know the exact field the receiver expects.

Using BTC/USDT instead of the exchange-native pair​

TradingView chart tickers use a slash. Most exchange APIs don't. Bybit wants BTCUSDT, OKX wants BTC-USDT-SWAP, BitMEX wants XBTUSD. TVH doesn't normalize pair names across exchanges, so copy the format from the exchange, not from your chart. In our experience this is the single most common cause of a rejected order.

Forgetting token or apiKey​

No token and the request is rejected before the order is even considered. A wrong apiKey name, even a stray capital letter, means TVH can't find the credentials and the order never reaches the exchange. Both are case-sensitive, so copy them exactly as they appear in your dashboard.

Closing a position without reduceOnly​

If a reversal signal fires a close or opposite-direction alert on a flat book, and you haven't marked it reduceOnly: true, you can accidentally open a fresh position in the opposite direction instead of just closing. On futures, set reduceOnly: true on any exit-only alert so it can only shrink a position, never grow one.

FAQ​

Get the four required fields right, use booleans instead of string enums, and the rest of the schema is just optional fields you add as your strategy grows. When a payload bounces back, the gotchas page is the fastest way to find the field you missed.