Manual to Automated Trading: A Transition Guide

Manual trading breaks down when volatility demands faster decisions than your process can consistently deliver. The move from manual to automated trading is not about handing control to a black box, it is about turning proven trade ideas into clear, repeatable rules that execute without hesitation, missed entries, or emotional overrides.

This guide shows you how to make that transition without rushing into live automation. You will learn how to identify strategies that are structured enough to automate, define objective entry, exit, sizing, and risk rules, and pressure-test those rules through paper trading. We will also cover a phased deployment approach, so you can begin with limited capital, monitor real-world execution, and refine the system before scaling.

Using TradersPost as the automation layer, you can connect alerts and rule-based signals to brokerage execution while retaining oversight of your strategy. The goal is not more trades. It is a more disciplined process that can respond consistently when volatile markets move quickly.

Why Manual Trading Breaks Down in Volatile Markets

The Hidden Costs of Discretionary Execution

A trading idea can be structurally sound and still produce poor results when execution is discretionary under pressure. In volatile markets, the cost is rarely a single dramatic mistake. It is usually a sequence of small deviations from the intended plan: entering late, reducing size after a loss, increasing size to recover, moving a stop, or taking profits before the original target.

Consider a momentum setup triggered by an earnings surprise. A trader plans to buy a breakout above $102 with a stop at $99 and a first target at $108. If the stock gaps through the level, trades rapidly between $102 and $104, and social-media commentary accelerates the move, manual execution can deteriorate quickly. Hesitation may turn a $102 entry into a $104.20 entry. Fear of missing out may lead to buying after an extended candle. A stop may then be widened because the original risk no longer feels acceptable relative to the late entry.

• Hesitation creates delayed entries and missed exits when confirmation is interpreted differently from one trade to the next.
• Fear of missing out encourages traders to chase price after the planned entry has passed.
• Revenge trading converts a valid loss into an unplanned second or third attempt with weaker criteria.
• Inconsistent position sizing makes performance difficult to evaluate because each outcome carries a different amount of risk.

These problems become more acute after scheduled news, central-bank decisions, economic releases, earnings reports, analyst upgrades, and viral social catalysts. A liquid option contract can change materially in seconds as the underlying moves, implied volatility reprices, and bid-ask spreads widen. Manual order entry may require selecting the contract, checking liquidity, calculating size, entering a limit price, and monitoring the underlying simultaneously. By the time the order is submitted, the conditions that justified the trade may no longer exist.

Automation does not guarantee profitability. It does not make a weak signal profitable or protect a trader from adverse market conditions. Its principal benefit is enforcement: predefined rules are applied without hesitation, impulse, or selective interpretation.

What Automation Can and Cannot Solve

A well-designed automated workflow can standardize the mechanical components of a strategy. It can submit an order when objective conditions are met, calculate size from a fixed dollar or percentage risk limit, attach stop-loss and profit-target orders, and prevent trading outside approved hours. For example, a system might allow one long trade only when price closes above the opening range high, volume exceeds a defined threshold, the spread is below a maximum, and no position is already open.

• Define entries using measurable conditions rather than subjective chart interpretation.
• Set maximum loss per trade, maximum daily loss, and maximum concurrent exposure before deployment.
• Use fixed or volatility-adjusted position sizing based on account equity and stop distance.
• Enforce time restrictions, such as avoiding the first two minutes after the open or closing positions before liquidity deteriorates.
• Log every signal, order, fill, cancellation, and rule rejection for later review.

Automation cannot repair an unprofitable strategy, invalid market assumptions, excessive leverage, poor options liquidity, or unreliable alert logic. If a breakout alert fires after the move is already extended, automating that alert simply produces faster late entries. The transition from manual to automated trading is therefore not a transfer of responsibility to software. It is a move from emotional execution toward tested, repeatable decision-making, with risk controls that operate consistently when market conditions are least forgiving.

Start by Turning Your Manual Strategy Into Rules

Document the Exact Conditions Behind Every Trade

Before automating anything, convert each discretionary decision into a repeatable checklist. Every trade should specify the market, symbol, timeframe, setup, entry trigger, invalidation level, stop loss, profit target, and maximum holding time. If a condition cannot be stated clearly enough for a script or alert engine to evaluate it, it is not yet an automation-ready rule.

Replace subjective descriptions with observable conditions. “Buy when momentum looks strong” is not a rule. “Enter long when the 20-period EMA is above the 50-period EMA, price closes above the prior day’s high, and volume exceeds the 20-bar average volume” is testable, programmable, and reviewable.

• Market: US equities, index futures, major FX pairs, or another defined universe.
• Symbol filter: Minimum average daily volume, price range, spread, and market capitalization.
• Setup: Trend continuation, opening-range breakout, mean reversion, or volatility contraction.
• Risk definition: The price level proving the trade thesis wrong.

Review a representative sample of prior manual trades, including winners, losers, and trades you skipped. Identify the conditions you applied consciously and the filters you applied instinctively. This process often reveals that a supposedly discretionary strategy already relies on recurring price, trend, volume, and timing rules.

Define Objective Entry Rules

Entry conditions should use values that can be calculated by an alerting platform or execution system. Suitable inputs include moving-average alignment or crossovers, RSI thresholds, VWAP reclaim levels, opening-range breaks, prior-session highs and lows, trend filters, and price-channel breakouts.

For example, an intraday ETF strategy could state: buy a liquid ETF only when a 15-minute candle closes above the opening-range high, the 20 EMA is above the 50 EMA, and the protective stop is placed below the opening-range midpoint. Add operational constraints where needed, such as no entries after 2:00 p.m. ET, minimum 30-day average volume of 5 million shares, and no trade if the opening range exceeds 1.5% of price.

Specify alert timing precisely. A bar-close trigger waits for the 15-minute candle to complete, reducing false breakouts but entering later. An intrabar trigger acts as soon as price trades through the level, improving speed but increasing exposure to temporary breaches. Your backtest, alerts, and live execution must use the same trigger convention.

Define Exits Before the Position Is Opened

Automation is most reliable when exits are predetermined. Define whether the system uses a fixed-dollar stop, percentage stop, ATR-based stop, trailing stop, profit target, partial exits, indicator-based exit, or time-based exit. Each exit should be tied to evidence from the strategy’s historical behavior, not an arbitrary reward-to-risk ratio.

A complete rule might be: exit the remaining position if price reaches 2R, if a daily close falls below the 10 EMA, or if the trade remains open for more than five trading days. The system must also define precedence. For example, if a stop and target are both touched within one bar, the backtest needs a documented assumption about fill order.

• Use ATR-based stops when volatility changes materially across trades.
• Use partial exits only if historical results show they improve expectancy or reduce unacceptable drawdowns.
• Use time exits when the setup has a limited expected payoff window.

Build a Risk Framework Before You Automate

Use Position Sizing Rules Instead of Intuition

Automation should calculate position size from a predefined risk budget, not from confidence in a signal. A practical starting method is fixed-dollar risk sizing. First, define the maximum amount you are willing to lose if the stop is reached. Second, calculate the distance between the intended entry price and stop price. Third, divide the dollar risk by that stop distance.¹

Position quantity = maximum dollar risk ÷ (entry price - stop price)

For example, if the strategy permits a maximum loss of $100 per trade and the stop is $2 below entry, the maximum size is 50 shares:

• Maximum risk: $100
• Entry-to-stop distance: $2 per share
• Maximum quantity: $100 ÷ $2 = 50 shares

This is the theoretical maximum before considering buying power, margin requirements, minimum contract sizes, commissions, and broker quantity constraints. For options, use the contract multiplier. A $1.00 stop distance on a standard option contract represents approximately $100 of risk per contract before slippage.

Other valid sizing models include fixed quantity, fixed dollar allocation per position, percentage-of-equity risk sizing, and capped notional exposure. Percentage-of-equity sizing can reduce risk automatically after drawdowns, while capped exposure prevents a high-priced instrument from consuming an excessive share of capital. Select one method, encode it explicitly, and log the inputs used for every order.

Set Guardrails for Daily and Portfolio-Level Risk

A strategy-level stop is not enough. The automation also needs account-level controls that can override otherwise valid entry signals. Define limits that the system must enforce before order submission:

• Maximum realized and unrealized daily loss
• Maximum trades or order attempts per day
• Maximum concurrent positions
• Maximum capital allocation per symbol and sector
• Maximum overnight exposure and maximum leveraged exposure

Correlated positions can create hidden concentration risk. Owning several large technology stocks, a semiconductor ETF, and a leveraged Nasdaq ETF may look diversified by ticker count, but the portfolio can still be dominated by one market factor. Model exposure by sector, underlying index, and correlation group, not only by individual symbol.

Define the response to a loss streak before it occurs. For example, after three consecutive stopped trades or a 2% daily equity decline, disable new entries, cancel working entry orders, and require review. Other appropriate responses include reducing size by 50%, pausing the strategy for the session, or moving the strategy back to paper trading while investigating signal quality, data integrity, and execution logs.

Plan for Real-World Execution Risks

Live execution differs from a backtest. A historical test may assume fills at the close, midpoint, or stop price, but that price may not be available when an order reaches the market. Account for slippage, bid-ask spread widening, opening gaps, partial fills, rejected orders, market halts, insufficient buying power, and delayed alerts or API responses.

A stop order does not guarantee an exact exit price. If a stock closes at $50 and opens at $46 after earnings, a $48 stop may fill near $46 rather than $48. Similarly, a limit order can remain unfilled during a rapid move, while a market order can execute materially worse than the last quoted price.

Early automation should focus on liquid instruments with narrow spreads, reliable quote data, and sufficient average daily volume. Use conservative fill assumptions in testing, including spread costs and adverse slippage. Avoid strategies whose profitability disappears when fills are modeled one or two ticks worse than the backtest assumption. Your order logic should also handle partial fills explicitly: decide whether to cancel the remainder, adjust the protective stop to the filled quantity, or continue working the order within a defined time limit.

Test the Strategy Before Sending Live Orders

Backtest Rules, but Do Not Overtrust the Results

Backtesting answers an important but limited question: how would a precisely defined set of rules have performed on historical data? Use it to measure win rate, maximum drawdown, average trade, expectancy, trade frequency, profit factor, and exposure by market regime. For an options strategy, also evaluate results after realistic bid-ask spreads, commissions, slippage, contract liquidity constraints, and assignment or expiration handling where applicable.

A backtest is not proof that a strategy will perform live. Historical results are especially vulnerable to curve fitting when you repeatedly adjust indicator lengths, stop distances, profit targets, or entry filters until one parameter set produces the best equity curve.² A 14-period RSI threshold of 31.5 may look superior to 30 in a specific sample, but that does not make it structurally meaningful.

• Test parameter ranges, not only the single best-performing setting.
• Use out-of-sample data that was not used to design the rules.
• Evaluate separate periods of sustained trends, range-bound trading, high implied volatility, and low-volatility conditions.
• Review whether performance depends on a small number of unusually large winners or a narrow market period.

For example, a short-premium strategy may show strong historical expectancy during quiet, mean-reverting markets but fail during volatility expansions. A trend-following equity strategy may perform well in directional periods while generating repeated small losses during choppy index conditions. The goal is to understand those dependencies before capital is exposed.

Paper Trade the Full Alert-to-Order Workflow

Strategy backtesting validates historical logic. Paper trading validates whether the automation works correctly in current market conditions.³ Treat these as separate tests. A backtest can show that an entry rule had positive expectancy, but it cannot confirm that your alert payload reaches the broker, maps the correct symbol, submits the intended order type, and places protective exits without delay or duplication.

For every simulated trade, verify that the alert includes the intended ticker, side, order type, quantity or sizing instruction, time-in-force, stop behavior, target behavior, and position-closing logic. If the strategy trades options, confirm the correct expiration, strike, call or put designation, and contract multiplier.

• Record the alert timestamp and the expected entry price.
• Record the simulated fill price, broker or execution-engine response, and any latency.
• Confirm stop-loss and profit-target placement immediately after entry.
• Record amendments, partial fills, exit alerts, and final realized paper outcome.

If a buy alert for 100 shares of SPY becomes a market order for 1 share, or a stop order is rejected because of an invalid price relationship, the strategy is not ready for live deployment regardless of its backtest statistics.

Use a Minimum Validation Checklist

Do not approve a strategy after five favorable paper trades. Require a meaningful sample size relative to its frequency and holding period. A high-frequency intraday system may generate enough observations in several weeks, while a weekly swing strategy may require months of paper data. The objective is to observe repeated executions across varied conditions, not to reach an arbitrary trade count.

• Confirm behavior during the opening auction and first 30 minutes, when spreads and volatility are often elevated.
• Test lunch-hour conditions, when liquidity may decline and signals can become noisier.
• Test closing-session moves, including end-of-day exits and orders near session cutoffs.
• Review every failed alert, duplicate signal, missed trade, stale price, order rejection, and unexpected position state.

Enable live capital only after the strategy’s trading logic, alert formatting, execution handling, and risk controls have all behaved consistently in paper trading. Start live with reduced size, then compare live fills and operational results against the paper-trading record before scaling.

Move From Manual to Automated Trading in Phases

Phase 1: Use Alerts as a Decision-Support System

Begin by converting discretionary observations into alertable conditions without allowing the platform to place orders. TradingView and TrendSpider are useful at this stage because they can monitor price, volume, indicator, and multi-timeframe conditions continuously.

For example, a trader who manually buys pullbacks in an uptrend might create an alert requiring: price above the 20-period and 50-period moving averages, a pullback to the 20-period average, relative volume above 1.5, and a five-minute candle closing back above its prior high. The alert should identify a defined event, not a vague instruction such as “strong momentum.”

• Keep order entry manual and record every alert in a journal or spreadsheet.
• Compare alerts with the trades you would have taken manually: Did the alert trigger on time? Did it miss valid setups? Did it generate conditions you would reject?
• Refine ambiguous rules. Replace terms such as “near support” with measurable criteria, such as price within 0.25% of VWAP or within one ATR of a prior breakout level.
• Measure alert latency, especially for short-duration setups. An accurate alert that arrives after the favorable entry has passed is not operationally useful.

Phase 2: Automate Entries While Supervising Exits

Once alerts consistently identify valid setups, automate a narrow entry workflow. Limit the system to one strategy, a small watchlist, and one market session. For instance, automate opening-range breakout entries only in highly liquid index ETFs between 9:35 a.m. and 10:30 a.m. Eastern Time, rather than attempting to automate every intraday pattern.

Use paper trading first, then introduce small live size only after the order-routing workflow has been verified. The entry logic should include explicit controls: maximum position size, permitted symbols, order type, maximum spread, time window, and a daily trade limit.

• Attach a predefined protective stop and profit target immediately with the entry order, preferably as a bracket or OCO order where supported.⁴
• Continue managing exits manually during this phase, but document every override of the planned stop or target.
• Review whether manual interventions improve results or merely reflect hesitation, fear, or profit-taking bias.
• Test edge cases, including partial fills, rejected orders, gap-through stops, duplicate webhooks, and connectivity interruptions.

Phase 3: Automate the Complete Trade Lifecycle

Automate exits only after the strategy has passed paper testing and phased live validation. The complete workflow may include entries, stop-loss orders, profit targets, break-even rules, trailing stops, time exits, and strategy-specific exits. Each exit must be objectively defined. For example, a trend-following system may trail a stop at 2 ATR below the highest close since entry, while a mean-reversion system may exit at VWAP or after 45 minutes if the target has not been reached.

Deploy at reduced size and scale only from actual execution data. Compare expected fills from backtests or paper results with live fills, slippage, commissions, rejected orders, and stop execution quality. Confidence in the logic is not a substitute for verified operational performance.

• Maintain a documented manual kill-switch procedure.
• Know how to pause alerts, disable webhooks or broker automations, cancel open orders, and flatten positions immediately.
• Define conditions requiring intervention, such as abnormal spreads, data-feed failures, duplicate orders, broker outages, or market halts.
• Review automated trades weekly for rule compliance, execution quality, and changes in market behavior.

Set Up TradingView or TrendSpider Alerts for Automation

Choose Signals That Are Simple Enough to Automate Reliably

Begin with one setup that has explicit entry, exit, and risk rules. Automation executes stated conditions exactly, so the first strategy should not depend on discretionary interpretation such as “this breakout looks strong” or “the trend appears exhausted.” If two traders could apply the rule differently from the same chart, it is not yet ready for automation.

Suitable initial candidates include:

• Breakout entries: Buy when price closes above the highest high of the prior 20 bars, with a protective stop below the breakout bar low.
• Moving-average systems: Enter long when a 20-period moving average crosses above a 50-period moving average, then exit when the relationship reverses.
• RSI mean reversion: Buy when RSI(2) closes below 10 while price remains above a 200-period moving average, then exit at a defined profit target or RSI threshold.
• Price-level breaks: Enter when a defined support, resistance, opening-range, or prior-day high/low level is crossed.
• Rule-based exits: Submit an exit alert when price reaches a fixed stop-loss, profit target, trailing stop, or time-based liquidation condition.

Avoid trying to encode headline interpretation, real-time social-media sentiment, subjective chart-pattern quality, or manually assessed liquidity conditions in the first version. Those inputs may eventually be modeled, but they introduce data, latency, and classification risks that are unnecessary for an initial automated workflow.

Create Webhook Alerts With Complete Trade Instructions

A webhook alert should contain enough information for the receiving automation platform, bot, or execution service to identify the intended action without guessing. At minimum, include the symbol, direction, order behavior, quantity or sizing rule, and strategy destination. A structured payload is preferable to a free-text message.

For example, an entry alert might send:

{"strategy":"ORB_15M","action":"BUY","symbol":"NASDAQ:AAPL","order_type":"MARKET","quantity":100,"destination":"equities_bot_1"}

Use a consistent symbol convention across TradingView or TrendSpider, the webhook receiver, and the broker or execution platform. “AAPL” may be sufficient for a US equity broker, while a charting platform may use “NASDAQ:AAPL.” Futures, forex, and crypto require even more care because contract codes, continuous futures symbols, exchange suffixes, and spot versus perpetual products can differ. If your strategy trades options-related underlyings, ensure the automation knows whether it should trade the underlying, select an option contract, or route a signal to a separate options execution engine.

Create distinct alerts for entry, exit, reversal, and stop events when those actions require different handling. A reversal should not be treated as another entry if the system must first close an existing position.

Avoid Common Alert and Webhook Mistakes

Confirm how each alert evaluates conditions: once per bar, once per bar close, or on every price movement. A breakout strategy intended to act immediately may require intrabar triggering, while a moving-average crossover based on confirmed closes should generally use bar-close alerts. Mixing these settings can materially change live behavior relative to backtests.

• Define position-state rules, such as “enter long only when flat” and “ignore additional long signals while already long.” This prevents repeated alerts from pyramiding exposure unintentionally.
• Specify whether a sell alert means close a long position, open a short position, or both. These are operationally different instructions.
• Test webhook authentication, JSON formatting, symbol mapping, order quantities, and error responses in paper trading before sending live orders.
• Test market-hours behavior, including premarket, postmarket, session opens, futures roll periods, and crypto’s continuous trading schedule.

Review alert logs against broker fills during testing. An alert that fires correctly but maps to the wrong symbol, submits the wrong quantity, or repeats after a partial fill is not operationally ready for capital deployment.

Measure Results and Improve Without Reintroducing Emotion

Track Strategy Metrics Separately From Execution Metrics

Evaluate the trading model and the automation layer as two distinct systems. A strategy can have positive expectancy while the automated implementation loses money because of delayed orders, rejected submissions, poor fills, or missed signals. Conversely, flawless execution cannot rescue a trading rule set with negative expectancy.

Maintain a strategy-performance report based on completed trades and normalized risk. At minimum, track:

• Expectancy: average amount gained or lost per trade, preferably expressed in R multiples as well as currency.
• Win rate, average win, and average loss: analyze whether performance changes come from hit rate, payoff ratio, or both.
• Profit factor: gross profit divided by gross loss.
• Maximum drawdown: compare live drawdown with the historical and out-of-sample drawdown distribution.
• Exposure time and trade frequency: identify whether the system is taking materially more or fewer trades than testing predicted.

Run a separate operational dashboard for alerts received, orders submitted, broker acknowledgements, fills received, partial fills, order rejections, slippage, cancelled orders, and missed signals. For example, if a breakout strategy generated 24 valid signals but only submitted 21 orders because a webhook timed out, that is an execution failure, not evidence that the breakout logic stopped working. For options strategies, also compare actual fills against the modeled mid-price or conservative bid-ask assumptions used in testing.

Create a Scheduled Review Process

Do not modify rules after every losing trade or short losing streak. Define a weekly operational review and a monthly strategy review. Weekly reviews should focus on data integrity, broker connectivity, order-routing exceptions, and whether the automation followed its written rules. Monthly reviews should assess performance against the tested sample and current market regime.

Use a fixed checklist for every review:

• Did market conditions change materially, such as volatility regime, trend persistence, liquidity, or correlation structure?
• Did every entry, exit, position-size adjustment, and risk limit follow the documented rules?
• Did actual execution differ from testing assumptions for spreads, slippage, fill probability, or latency?
• Is there enough new data to support a statistically meaningful modification?

Document each proposed change with its rationale, date, affected rules, test period, and expected impact. Retest the revised version on historical data and, where possible, forward-test it in paper trading before deploying it. Treat version control as mandatory. A live result should always be traceable to a specific strategy version and automation configuration.

Know When to Pause an Automated Strategy

A pause is a risk-management action, not a failure of automation. Establish pause criteria before deployment. Examples include actual drawdown exceeding the tested range, a material change in market structure, abnormal volatility or liquidity conditions, data-feed failures, broker outages, repeated order rejections, or evidence that alerts and executed orders no longer match.

For example, if testing showed a 12% maximum drawdown and the live strategy reaches 15% despite normal position sizing, stop new entries and investigate. If an options system was designed around liquid weekly contracts but bid-ask spreads widen substantially during a volatility event, modeled returns may no longer be achievable. Pause rather than allowing execution assumptions to drift unchecked.

After a major rule change, infrastructure incident, or extended period away from the strategy, return to paper testing before resuming live trading. Confirm signal generation, order construction, risk controls, and reconciliation reports under current market conditions. Resume only when the strategy and its automation layer have both passed their defined checks.

Frequently Asked Questions

How do I transition from manual to automated trading?

Start with one repeatable strategy and document its exact entry, exit, position-sizing, and risk-management rules. Backtest those rules using historical data, then paper trade the complete workflow from alert generation to order placement. Move gradually: begin with alerts only, progress to supervised automation where you confirm orders, and then consider fully automated execution at a reduced position size. Review results regularly before increasing capital or complexity.

Can I automate a discretionary trading strategy?

You can reliably automate only the parts of a discretionary strategy that can be expressed as objective, measurable rules. Turn visual or intuitive decisions into conditions involving price, volume, indicators, time of day, market structure, and predefined risk limits. If a decision depends on context that cannot be clearly defined, keep it manual. In many cases, alerts and decision-support tools are a better fit than full automation.

Should I paper trade before using automated trading live?

Yes. Paper trading helps validate both your strategy logic and the operational workflow between alerts, automation settings, and broker orders. Test for duplicate alerts, incorrect symbols, sizing mistakes, rejected orders, and how the system behaves during active market conditions. However, paper trading does not guarantee live performance. Slippage, spreads, fills, liquidity, and the emotional pressure of using real capital can produce different results.

Can TradersPost automate TradingView alerts?

TradersPost can receive compatible webhook alerts from TradingView and translate configured signals into broker-directed orders through connected integrations.⁵ Traders can set rule-based execution, position sizing, and paper-testing workflows before enabling live trading. However, the trader remains responsible for the strategy design, TradingView alert logic, broker selection, and risk management. Always test alert formatting and order behavior carefully before using live capital.

What is the biggest risk of fully automated trading?

The biggest risk is automating untested rules or deploying too much capital before validating real-world execution. Even a sound strategy can be affected by slippage, market gaps, duplicate signals, connectivity failures, platform issues, broker interruptions, and over-optimization. Reduce operational risk by starting with small position sizes, setting clear loss limits, paper testing thoroughly, monitoring live performance, and reviewing automation settings whenever your strategy or market conditions change.

Conclusion

Moving from manual to automated trading is not about handing control to a black box. It is about converting a repeatable process into clear, testable rules, then validating each part before capital is at risk. Start with a strategy you already understand, define entries, exits, position sizing, and risk limits precisely, and use phased automation to identify operational gaps before they become costly.

Automation can improve consistency and execution discipline, but the underlying edge still matters. Monitor performance, review exceptions, and refine your rules as market conditions change. Ready to take the next step? Create a TradersPost paper trading bot for your first rule-based strategy, connect your TradingView or TrendSpider alerts, and see how your workflow performs in real time before going live. Build confidence through evidence, then automate with purpose.

References

¹ TradersPost Docs, Position Sizing
² TradingView Pine Script Docs, Repainting
³ TradersPost Docs, Paper Trading
⁴ TradersPost Docs, Order Classes
⁵ TradersPost Docs, Webhooks