How to test and debug your Autoview setup

Autoview

By the end of this guide you'll be able to fire a command at Autoview, watch exactly what it would have done, and fix it, all without putting a single dollar of real capital at risk. That's the whole game before you go live. Autoview isn't a finished bot you flip on. You're building your own automation, and any new build has bugs.

So you test. Every trader who has been burned learned the same lesson the expensive way: a comma in the wrong place, a quantity read as 100 instead of 1, an API key missing trade permission. Catch that on a dry-run, not on a live fill.

What you'll need first

Three things should already be in place before you test:

  • An exchange or broker account connected to Autoview. Test on the exact venue you'll trade on, because each one behaves a little differently.
  • At least one Autoview command you want to validate.
  • A way to send an alert to Autoview. Most people fire from TradingView, but the webhook platform accepts a POST from anything that can hit a URL, so a script or another service works too.

A tip worth its own line: when you can, run your tests against a demo, sandbox, or testnet connection. Several of those are free, so you can rehearse the full flow before any real exchange is involved.

Step 1: Add d=1 to every command

The dry-run parameter is the single most useful tool here. Put d=1 in a command and Autoview parses it, decides exactly what it would do, and writes that to the log. But it sends no order to the exchange. Nothing executes. You just see the intent.

Take a couple of commands you want to check and tack d=1 onto the end of each:

e=Binance s=XRPBTC b=buy q=25% d=1
e=Binance s=XRPBTC b=sell q=1% d=1

Make d=1 a habit. Any time you write a new command or change an old one, dry-run it before you trust it with money.

Step 2: Create a test alert you can fire on demand

You don't want to sit around waiting for a real market condition to trigger. Build an alert you control.

The simplest version: pick an active market, set a condition that's basically always true (price greater than 1, for instance) and set it to fire only once. Drop your d=1 commands into the alert message. Now you can fire on command instead of waiting on the chart.

If your command sets a price from the chart, it might look like this:

e=Binance s=XRPBTC b=buy q=25% t=limit p={{close}} d=1

One thing trips people up here. {{close}} is a TradingView placeholder, not Autoview syntax. TradingView swaps in the live close price when the alert fires, then sends the finished text to the webhook. The alert sender supplies the value. If you fire from a script or another platform instead of TradingView, that source has to fill the price its own way before it hits the webhook.

If you're testing a Pine strategy in TradingView, force the entry condition to true so it fires on the next candle:

longCondition = true
if longCondition
    strategy.entry("long", strategy.long, alert_message="your Autoview command here")

Need a single trigger at a precise moment instead? Gate it on an epoch timestamp:

epoch = input.int(1738789050, "EpochTime") * 1000
if time == epoch
    strategy.entry("long", strategy.long, alert_message="your Autoview command here")

Grab the epoch value from a converter like epochconverter.com.

Step 3: Open the log and read it

Keep your log open while you fire. It's where everything shows up: what Autoview parsed, what it would have done, and any errors or warnings along the way.

On a dry-run, the log spells out the trade it would have placed: the side of the book, order type, price, and quantity. Read it line by line against what you meant. If the side is wrong or the quantity looks off by a decimal, you found your bug, and it cost you nothing.

Step 4: Go live, small, watching both screens

Once the dry-run says what you want, remove d=1 from each command. That's the only change. The command that ran clean on a dry-run is the command that goes live.

Look up the exchange's minimum order size and trade at exactly that size first. Watch your log and the exchange side by side until you're sure the live behavior matches the dry-run. Then scale up. There's no rush. Fire as many tests as it takes to get this boringly predictable.

Troubleshooting the usual suspects

When something fails, it's almost always one of these:

  • Bad API credentials. Your key must have trade permission. Withdrawals should stay disabled, since Autoview never needs them. A key that's read-only or unrecognized can't place orders.
  • A disconnected account. If the connection dropped, nothing executes. Reconnect before you debug anything else.
  • Syntax errors. A malformed command fails. This is exactly what d=1 is for: catch it on the dry-run.
  • Venue-specific rules. Every exchange has its own quirks. Symbol formats differ: OANDA wants the underscore form like EUR_USD, not EURUSD. Check the per-exchange setup notes for the syntax that venue expects.

For credential and permission setup, your exchange's own API documentation is the authority. It's the most current source for what each key scope actually does and how to whitelist an IP. When in doubt about whether the platform itself is healthy, the Autoview status page is the place to check.

Test until it's dull. A boring, predictable dry-run is the best signal you'll get that your live trading is ready.

See the supported platforms