You reduce slippage in a trading bot by attacking its three causes: the order type you send, the delay between signal and fill, and the liquidity you trade into. No single fix wins. Limit orders protect price but can miss fills. Faster execution shrinks the gap between signal and fill. Slicing and timing cut market impact. Measuring your real fills tells you which lever is worth pulling.
Below we compare six methods on what they fix, what they cost you, and when they fit. Tickerly is one entrant, covering the execution-speed lever for TradingView strategies.
TL;DR
- Slippage is the gap between the price your bot expected and the price it got. Volatility, thin liquidity, order size and latency drive it.
- Limit and stop-limit orders control price but may not fill. Market orders fill but do not guarantee price.
- Faster alert-to-order execution helps most on fast-moving, signal-driven strategies. Slicing and timing help most on large orders.
- On DEXs, slippage tolerance is a trade-off between failed transactions and overpaying.
- Measure first: log timestamps and fill prices, then compare them with an arrival-price benchmark.
Table of Contents
- What slippage is and why bots hit it
- The six methods at a glance
- Method 1: Use limit and stop-limit orders where price matters
- Method 2: Cut latency between signal and fill
- Method 3: Slice large orders
- Method 4: Trade when liquidity is there
- Method 5: Set tolerance and estimators on DEXs
- Method 6: Measure, then backtest honestly
- Perspective: what we see in execution
- Choosing the right mix for your bot
- Try Tickerly on your own strategy
- FAQ
- Sources
What slippage is and why bots hit it
Slippage is the difference between the price at which your strategy decided to trade and the price at which the order actually filled. It can be positive or negative, but over many trades the negative side usually wins, because bots tend to trade exactly when markets move.
Three mechanics explain most of it:
- Order type. The SEC’s investor bulletin explains that a market order buys or sells at the best available price, but the execution price is not guaranteed. In fast markets, parts of a large order may fill at different prices.
- Volatility and liquidity gaps. OANDA’s guide names volatility around major economic releases, liquidity gaps and signal-to-server latency as primary causes.
- Size relative to depth. The bigger your order compared with what the book or pool can absorb, the more you move the price yourself. Jupiter’s developer documentation says slippage depends on token-pair volatility, trade size relative to pool liquidity and the time between quote and execution.
For a TradingView-driven bot, add one more step: the alert has to fire, travel to your automation service, be translated into an order and reach the exchange. Each hop adds milliseconds, and in a fast candle milliseconds are price.
The six methods at a glance
| Method | What it reduces | Main cost or risk | Best for |
|---|---|---|---|
| Limit and stop-limit orders | Price uncertainty | Missed or partial fills | Mean-reversion, patient entries |
| Faster alert-to-order execution | Latency slippage | Does not fix thin books | Breakout, momentum, scalping |
| Order slicing (TWAP, VWAP) | Market impact | Slower entry, alpha decay | Larger positions |
| Liquidity and timing rules | Spread and gap slippage | Fewer trades | Any bot on volatile or thin markets |
| DEX tolerance and estimators | Overpay and failed swaps | Failed transactions if too tight | On-chain bots |
| Measurement and realistic backtests | Hidden, unexplained cost | Needs logging discipline | Every bot |
Method 1: Use limit and stop-limit orders where price matters
The most direct fix is to stop accepting any price. The SEC bulletin notes that a limit order sets the worst price you will accept, but it may never execute if the market moves away. A stop order becomes a market order once triggered, so it can still slip. A stop-limit controls price but may remain unfilled.
The trade-off is real for bots. A limit order on a breakout entry may leave you flat while the move runs without you. A market order on a mean-reversion entry might overpay for no reason.
A practical rule:
- Urgency high, edge large (momentum entries, protective stops): accept a market order and manage slippage through speed and size.
- Urgency low, edge small (range entries, scaling in, take profits): use limit orders and accept some missed fills.
- Exits that protect capital: do not make them depend on a fill that may never come. A missed stop costs more than slippage on it.
On Tickerly, the alert has no order-type or limit-price field, so you can’t switch a leg to a limit order from the alert. Patience belongs in the strategy’s entry rules, and Tickerly executes the orders the strategy sends. For protective exits, a full trade alert attaches the take profit and stop loss to the entry as absolute prices on Bybit, Binance, Oanda and Capital.com, so they rest on the exchange instead of waiting for a later alert.
We cover the decision in more depth in our market vs. limit orders checklist, and the exit side in our guide to trailing stop automation.
Method 2: Cut latency between signal and fill
If your strategy trades on a fast candle close, the price at the moment of the signal and the price when your order lands can differ materially. OANDA lists signal-to-server latency as a cause and recommends lower-latency VPS infrastructure as one remedy.
For TradingView users, the delay chain usually runs like this:
- The Pine Script strategy or indicator condition triggers an alert.
- TradingView sends the alert webhook.
- The automation platform parses it and builds the order.
- The platform calls the exchange or broker API.
- The exchange acknowledges and fills.
You control steps 3 and 4 by choosing your tooling, and partly step 5 by choosing your venue. Step 1 and 2 you mostly inherit. The honest way to compare tools is to measure round trip from alert to acknowledged order yourself, which we walk through in measuring round trip latency before you buy and in how to reduce trading latency for TradingView bots.
Faster execution is not a cure-all. It shrinks the time component of slippage. It does nothing for a market order that sweeps a thin order book.
Where Tickerly fits
Tickerly converts TradingView strategy alerts into live orders on connected exchanges and platforms, including MetaTrader 4 and 5, across crypto, forex, stocks, futures and prop firm accounts. Our positioning is speed: each order is placed within a fraction of a second of the alert, from dedicated servers near major exchanges, with no code to write and, for direct exchange connections, no VPS to rent (MetaTrader runs through the Tickerly TV Connector inside your own terminal, which has to stay running). Our own page on a low latency TradingView bot for retail traders covers the topic in more depth. You should still measure the round trip with your own exchange and symbol, as we recommend for any tool.
Method 3: Slice large orders
If your order is large relative to the market, the cleanest fix is to stop sending it all at once. The BIS notes that algorithms commonly split block orders into smaller child orders to avoid the price changes block execution causes, reducing market impact and transaction costs.
The CFA Institute adds that order size, percentage of average daily volume, volatility, spreads and liquidity should shape the strategy, and that large trades are generally spread over longer horizons. It describes scheduled algorithms such as VWAP and TWAP for participating in volume over an execution window.
For a retail bot, you can approximate this without a full execution algorithm:
- Split an entry into two to five smaller alerts spaced by seconds or minutes.
- Cap the size per alert as a percentage of typical volume on that symbol.
- Use smaller clips on thin pairs and larger ones on majors.
The cost is alpha decay: while you slice, the move you wanted may leave. The CFA Institute frames optimal execution as a balance among expected cost, execution risk, alpha decay, urgency and constraints, not a universal preference for speed or price. If your accounts are small, slicing may be unnecessary. If you run many strategies on one symbol, it matters, because your own orders stack.
Method 4: Trade when liquidity is there
Timing is the cheapest slippage control, since it costs nothing but discipline. Two situations deserve rules:
- Scheduled news. OANDA flags volatility around major economic releases as a main source of slippage and liquidity gaps. A bot that pauses a few minutes around releases, or uses limit orders only in that window, avoids the worst fills.
- Thin hours. The SEC’s after-hours bulletin says reduced trading interest can widen spreads and make execution more difficult, and that many brokers accept only limit orders then. Crypto trades around the clock, but liquidity still varies by hour and venue.
On the strategy side, build in filters: a maximum spread, a minimum volume, a session window. How a bot behaves in fast markets is worth designing deliberately, and we go through it in how trading bots respond to market volatility and bot trading liquidity factors.
Method 5: Set tolerance and estimators on DEXs
On decentralized exchanges, slippage is an explicit parameter: the maximum price movement you accept between quote and execution. Too tight and the transaction fails. Too loose and you invite overpaying.
Jupiter’s documentation shows both approaches. Its Router path defaults to 50 basis points (0.5%) and can opt into its Real-Time Slippage Estimator, which uses token categories, historical and live data, and failure-rate monitoring to set tolerance at order time. On its Meta-Aggregator path the estimator is automatic. Jupiter’s view is that a fixed tolerance suits cases that need deterministic behavior or a deliberately higher chance of execution, while adaptive tolerance balances failures against overpaying.
If you route through infrastructure providers, check what the API returns. bloXroute’s route-swap documentation, for example, exposes slippage as a maximum percentage and returns expected output, minimum output after slippage, price impact and fees, which lets a bot reject a swap whose price impact is too high before sending it.
A workable approach for volatile tokens: use a wider tolerance on exits than on entries, because failing to exit is costlier than overpaying slightly.

Method 6: Measure, then backtest honestly
You cannot reduce what you do not measure. Most bots look fine in backtests and bleed in live trading because the backtest assumed fills at the signal price.
The BIS Markets Committee describes transaction-cost analysis in three stages: pre-trade analytics, real-time fill statistics and post-trade comparison of average execution cost against a benchmark. It also says market participants should assess execution strength in each stage, with embedded controls and consistent monitoring.
You can run a simple version:
- Log timestamps for the signal, order submission, acknowledgement and fill.
- Record each fill: price, quantity, venue and order type.
- Choose a benchmark, such as the price at signal time (arrival price), the midpoint, or VWAP, and state it.
- Compute volume-weighted average fill minus benchmark, in basis points.
- Segment results by symbol, order type, time of day and size, over a meaningful sample of trades.
For backtests, model friction. PyBroker’s documentation says realistic backtests should include spreads, latency and market impact, and its volume model caps fills at a percentage of bar volume and applies price impact based on filled size relative to volume. If your strategy only works at zero slippage, it does not work.
Perspective: what we see in execution
We build for traders who turn TradingView alerts into live orders, so we see where fills go wrong. Our view is that most retail slippage is a design problem before it is a speed problem. A strategy that fires market orders into thin books on news candles will slip on any platform. Speed matters, and we have built Tickerly around it, but speed pays off most when the order type, size and timing are already sensible.
Our advice is a sequence. First, measure your real alert-to-fill gap on a small size. Second, decide how each strategy leg should behave: protective exits that never wait on a fill that may not come, and patient entry rules where a missed trade is cheap. On Tickerly that logic lives in the strategy, and where the exchange supports it, a full trade alert rests the stop loss and take profit on the exchange with the entry. Third, remove avoidable delay in the chain you control. Fourth, scale up and keep measuring. Treat any latency number, ours included, as a claim to test on your own symbol and venue.
There is also an advantage in running many strategies at once: diversification means no single fill defines your results. That only holds if each strategy’s execution cost is known.
— Jay
Choosing the right mix for your bot
Match the method to the strategy rather than applying everything:
- Scalping and breakouts on liquid pairs: latency first, market orders for entries, tight monitoring of fills.
- Swing strategies: latency matters less. Use limit orders for entries and accept missed trades.
- Larger accounts or many strategies on one symbol: slice orders and cap size relative to volume.
- On-chain bots: set tolerance by token liquidity, check price impact before sending, and wider tolerance on exits.
- Prop firm accounts: slippage can breach a daily drawdown limit, so map stops and take profits carefully. Our guide to take profit automation for prop firms covers it.
For how brokers and venues differ in fill quality, see how brokers power efficient automated trading, and for the case for removing manual steps, why automate order execution.
Try Tickerly on your own strategy
If your slippage comes from the alert-to-order delay, the quickest test is your own strategy on your own exchange. Tickerly turns TradingView alerts into live orders with no code, and no VPS for direct exchange connections, runs unlimited strategies from Level 3 with 100 to 2,500 alerts a day depending on plan, and starts with a 30-day free trial.
Paid plans published on our site are Level 2 at $19 per month, Level 3 at $29 per month, Level 4 at $39 per month (which adds MetaTrader 4 and 5) and Level 4 Ultra for traders who need 2,500 alerts a day, differing by supported asset classes, strategies and alert limits. Compare them on the Tickerly plans page.
Run the trial with the measurement routine above: log signal time and fill time for a week, and compare it with your current setup.
FAQ
Can a trading bot eliminate slippage?
No. Slippage comes from market conditions as well as your tools. You can reduce it with order types, speed, sizing and timing, but a market order always carries price uncertainty, and a limit order trades that uncertainty for the risk of no fill.
Are limit orders always better than market orders for bots?
No. Limit orders cap your price but may not fill, so you can miss the very trades your strategy depends on. Many traders use limit orders for patient entries and market orders for urgent or protective exits.
How much slippage is acceptable?
It depends on your edge per trade. If average slippage consumes a large share of your expected profit per trade, the strategy is fragile. Measure slippage in basis points against a stated benchmark and compare it with your backtested edge.
Does a VPS reduce slippage?
It can, by shortening the path between your software and the exchange, and OANDA recommends it for latency-sensitive setups. It does not help with thin liquidity or large orders. Hosted automation services remove the need to run a VPS yourself for direct exchange connections. MetaTrader setups are the exception: the connector runs inside your own terminal, which has to stay running, so a VPS is still the usual answer there.
Sources
- SEC Investor Bulletin: Trading Basics
- SEC Investor Bulletin: After-Hours Trading
- OANDA: Minimize slippage and execution risk
- CFA Institute: Trade Strategy and Execution
- BIS: Electronic trading and financial markets
- BIS Markets Committee: FX execution algorithms and market functioning
- Jupiter Developers: Slippage Estimation
- bloXroute: Jupiter route-swap endpoint
- PyBroker: Modeling Slippage
Recommended
- How to Manage Risk in Trading Bots Effectively
- Bot Trading Liquidity Factors: Design Bots That Survive
- Trading Bot Position Sizing Methods: A Practical Guide
- How Trading Bots Respond to Market Volatility
This article was produced with Al assistance and reviewed for accuracy. It is provided for general information only and is not professional or financial advice.

