Claude Code can now do more than draw on charts and backtest ideas — it can place real orders on your exchange. By sitting between TradingView’s signals and an exchange API, an AI agent can watch your strategy, block any trade that fails a condition, and run around the clock in the cloud. Here is how the setup works, and where the real risks are.

This guide walks through the architecture demonstrated by Lewis Jackson: connecting Claude Code to a BitGet account, adding a strict safety layer, deploying the bot so it trades 24/7, and logging every fill for tax season. No repositories to clone by hand — the whole thing installs from a single one-shot prompt.

Key takeaways

  • Claude Code becomes the “brain” between TradingView and your exchange — TradingView supplies price signals, Claude holds the strategy, and the exchange executes only when every filter passes.
  • A one-shot prompt handles the entire install. A built-in onboarding agent walks you through API keys, environment files, risk limits and deployment, pausing whenever it needs your input.
  • Risk guardrails are the point. Trades fire only when conditions like VWAP position, EMA trend and RSI thresholds all align; any failed filter blocks the order and logs the reason.
  • Cloud deployment (Railway) keeps it running without your laptop open, and every transaction is written to a tax-ready spreadsheet.
  • Start in paper trading mode. The demo strategy is explicitly not expected to be profitable — this is an automation tutorial, not a money-making system.

How Claude sits between TradingView and your exchange

The design places Claude Code as a central decision layer with two connections. On one side, TradingView provides the chart data and alert signals. On the other, an exchange (BitGet in the walkthrough) receives the actual buy and sell orders through its API.

Claude’s job is to hold the context of your strategy — the full set of rules that define a valid trade — and to act as a gatekeeper. When TradingView flags a potential entry, Claude checks it against every rule before anything reaches your exchange account. If the setup is clean, the order goes through. If not, nothing happens and the reason is recorded.

This is a meaningful shift from earlier “Claude + TradingView” setups that could only build strategies and annotate charts. The addition here is live execution, cloud hosting, condition-based risk filtering, and accounting logs — completing the loop from signal to filled order.

The three tools you connect

The system links three services, each with a distinct role:

  • TradingView — the signal source. Your indicators and alerts live here and tell the bot when something might be worth acting on.
  • Claude Code — the reasoning layer. It reads your rules.json, evaluates each condition, and decides whether to send an order.
  • An exchange (e.g. BitGet) — the execution venue. Connected by API key and secret, it places the trade when Claude approves it.

Because the strategy lives in a simple configuration file, you can edit your rules in plain terms rather than rewriting code.

Getting your exchange API keys

The first hands-on step is generating API credentials inside your exchange account. On BitGet this means creating an API key with trading permissions enabled, then copying the key, secret and passphrase into your bot’s environment file.

Two safety habits matter here. First, restrict the key’s permissions to only what the bot needs — trading, not withdrawals. Second, treat the secret like a password; it belongs in a local environment file, never pasted into a public repository or chat. If you follow official exchange guidance on API key security, you remove most of the avoidable risk. TradingView’s own alerts documentation covers how signals are pushed downstream.

The one-shot prompt and onboarding agent

Rather than a manual install, the entire build starts from a single prompt pasted into Claude Code. That prompt contains a built-in onboarding agent that runs the setup for you: it opens the files and websites you need, explains each step, and — crucially — stops and waits whenever it needs a decision or a credential from you.

In practice the agent walks through connecting your exchange API, creating the environment file, setting your trade limits and risk guardrails, wiring TradingView to the bot, loading your strategy, and finally deploying to the cloud. Tutorials are included for the top ten exchanges and for Windows, Mac and Linux, so the flow adapts to your setup. No prior coding experience is assumed.

Setting risk limits and safety filters

This is the part worth slowing down on. The bot is built so that a trade only executes when every condition in your strategy is true at the same time. The walkthrough uses a familiar stack of filters — price relative to VWAP, an EMA trend confirmation, and an RSI threshold — but the mechanism matters more than the specific indicators.

If price is on the wrong side of VWAP, or the EMA trend disagrees, or RSI is out of range, the order is blocked and the reason is logged. That “fail closed” behaviour is the difference between an automated tool and a reckless one: the default is no trade, and only a fully aligned setup gets through. You can also cap position sizes and trade frequency so a misfiring signal can’t drain an account.

The same discipline applies to the broader shift toward autonomous software. As we explored in the economic singularity thesis, agents that act on the world need hard limits far more than agents that only produce text — and a trading bot is about as consequential as an agent’s actions get.

Deploying to the cloud for 24/7 trading

Markets don’t wait for you to open your laptop, so the bot is deployed to a cloud host (Railway in the demo) where it runs continuously. Once deployed, it listens for TradingView signals, runs them through Claude’s filters, and executes around the clock without any machine of yours staying on.

Cloud deployment also removes a single point of failure: your home internet or a sleeping laptop won’t cause a missed exit. The trade-off is that a live, always-on bot with API access needs conservative limits and monitoring — an unattended system amplifies both good and bad rules.

Tax-ready trade logging

Every transaction the bot makes is written to a spreadsheet formatted for accounting. That means each fill, its size, price and timestamp lands in a log you can hand to an accountant at tax time rather than reconstructing trades from exchange exports months later.

For anyone trading with real size, this is a quietly valuable feature. Automated record-keeping turns a painful year-end chore into a byproduct of the bot simply doing its job.

Reverse-engineering strategies from YouTube

The walkthrough also includes a method for scraping YouTube transcripts with Apify to extract other creators’ trading strategies and feed them into your rules.json. Mechanically it’s clever — you turn a described strategy into structured rules the bot can enforce.

Treat it with caution, though. A strategy that sounds good on video is not a validated edge, and copying rules without understanding why each filter exists is how people automate losing systems at scale. Backtest and paper trade anything you import before it touches real money.

Why paper trading comes first

The single most important line in the source material is the disclaimer: the demonstrated strategy was built for tutorial purposes and is not expected to be profitable. The value of this project is the plumbing — the safe connection between signals, reasoning and execution — not the example rules.

Run everything in paper trading mode first. Simulated results have real limitations and won’t perfectly match live conditions, but paper trading lets you confirm the bot behaves as intended, respects its guardrails, and logs correctly before any capital is at risk. Crypto is volatile and largely unregulated; you should be prepared to lose everything you put in, and nothing here is financial advice.

This kind of tooling is part of a broader wave of AI moving from analysis into action across finance — a shift we track in our coverage of prediction markets becoming the new Wall Street, where machines increasingly price and act on markets in real time.

The bottom line

Connecting Claude Code to TradingView and a live exchange is now genuinely accessible: one prompt, a guided setup, and a cloud deployment that trades and books its own records 24/7. The engineering is impressive and the risk filtering is thoughtfully “fail closed.”

But the tool is only ever as good as the rules you give it, and an always-on bot with API keys deserves respect. Start in paper mode, keep position and frequency limits tight, and never automate a strategy you couldn’t defend on paper. The infrastructure is the innovation — the profitable strategy is still yours to find.

Frequently asked questions

Can Claude Code execute live trades?

Yes. As of 2026, Claude Code can be wired between TradingView (signals) and an exchange API such as BitGet (execution), evaluating every alert against a rules file and placing orders only when all conditions pass. Earlier setups could only build and backtest strategies; live execution, cloud hosting, and trade logging complete the loop.

Is an AI trading bot like this safe?

The architecture is “fail closed” — a trade is blocked by default and executes only when every filter (e.g. VWAP position, EMA trend, RSI range) agrees, with position-size and frequency caps on top. The residual risks are the ones automation can’t remove: a bad strategy executed perfectly, API keys with excessive permissions, and volatile markets. Restrict keys to trading only (never withdrawals) and paper trade first.

Do I need coding experience to set it up?

No. The build starts from a single one-shot prompt containing an onboarding agent that opens the right files and sites, explains each step, and pauses whenever it needs your input — covering the top ten exchanges across Windows, Mac and Linux.