Pine Script® Strategies are specialized scripts that simulate trades across historical and realtime bars, allowing traders to backtest and forward test their trading systems. These scripts provide the ability to place, modify, and cancel hypothetical orders while analyzing performance results through TradingView's dedicated Strategy Tester.
What Are Pine Script Strategies?
When a script uses the strategy() function as its declaration statement, it gains access to the strategy.* namespace, which features numerous functions and variables for simulating orders and retrieving essential strategy information. Strategy scripts have many of the same capabilities as indicator scripts but are specifically designed for trade simulation and performance analysis.
The primary purpose of these strategies is to help traders validate their trading ideas before risking real capital. By testing concepts against historical data, traders can identify potential strengths and weaknesses in their approaches.
Creating Your First Strategy
Let's examine a simple moving average crossover strategy that simulates entering long or short positions when two moving averages cross:
//@version=6
strategy("Simple strategy demo", overlay = true, margin_long = 100, margin_short = 100)
int lengthInput = input.int(14, "Base length", 2)
float fastMA = ta.sma(close, lengthInput)
float slowMA = ta.sma(close, lengthInput * 2)
if ta.crossover(fastMA, slowMA)
strategy.entry("buy", strategy.long)
if ta.crossunder(fastMA, slowMA)
strategy.entry("sell", strategy.short)
plot(fastMA, "Fast MA", color.aqua)
plot(slowMA, "Slow MA", color.orange)This basic example demonstrates several key concepts:
- The
strategy()function declares the script as a strategy - Moving averages are calculated using different periods
- Entry orders are placed when the fast MA crosses above or below the slow MA
- The strategy plots both moving averages on the chart for visual reference
Applying Strategies to Charts
To test a strategy, simply add it to your TradingView chart. You can select from built-in or published strategies from the "Indicators, Metrics & Strategies" menu, or write a custom strategy in the Pine Editor and click the "Add to chart" option.
Once applied, the script plots trade markers on the main chart pane and displays simulated performance results in the Strategy Tester tab. This visual feedback helps traders quickly assess how their strategy would have performed under historical market conditions.
👉 Explore advanced strategy testing tools
Understanding the Strategy Tester
The Strategy Tester visualizes hypothetical performance and displays strategy properties. When you add a strategy script to your chart, this tool populates four essential tabs with relevant information:
Overview Tab
The Overview tab provides a quick look into a strategy's performance across simulated trades. It displays essential performance metrics and includes three helpful visualizations:
- Equity baseline plot showing simulated equity across closed trades
- Drawdown column plot indicating how far equity fell below its peak
- Buy & hold equity plot comparing strategy performance to a simple buy-and-hold approach
Performance Summary Tab
This tab presents an in-depth summary of key performance metrics organized into separate columns. The "All" column shows performance for all simulated trades, while "Long" and "Short" columns show metrics separately for each direction. This detailed view helps traders understand how their strategy performs in different market conditions.
List of Trades Tab
Here you'll find a chronological listing of all simulated trades. Each item displays vital information including entry and exit times, order names, prices, quantities, profit/loss figures, and cumulative performance metrics. This detailed breakdown helps identify patterns in winning and losing trades.
Properties Tab
The Properties tab provides comprehensive information about strategy configuration and the dataset used for testing. It includes sections for date range, symbol information, strategy inputs, and strategy properties such as initial capital, currency, order size, margin requirements, and commission settings.
Broker Emulator and Execution Model
TradingView uses a broker emulator to simulate trades when running strategy scripts. Unlike real-world trading, the emulator fills orders exclusively using available chart data by default, executing orders on historical bars after they close.
The emulator makes assumptions about intrabar price movement based on opening, high, low, and closing prices:
- If open is closer to high than low, it assumes price moved: open → high → low → close
- If open is closer to low than high, it assumes: open → low → high → close
- It assumes no gaps exist between intrabars within each chart bar
- For price-based orders, it assumes no intrabars exist between the previous close and current open
Bar Magnifier Feature
Premium users can access the Bar Magnifier feature, which overrides the emulator's default assumptions by using data from lower timeframes for more granular price information. This results in more precise order fills in strategy simulations.
To enable Bar Magnifier, include use_bar_magnifier = true in your strategy declaration or select the option in the strategy's settings. This feature significantly improves backtesting accuracy, especially for strategies that rely on precise entry and exit timing.
Order Types and Their Applications
Pine Script strategies support multiple order types to accommodate different trading approaches:
Market Orders
Market orders are the simplest type, executed as soon as possible regardless of price. Most order placement commands generate market orders by default, and the broker emulator always executes them on the next available tick.
Limit Orders
Limit orders are instructions to buy or sell at a specific price or better. The broker emulator fills these orders when the market price reaches the specified value or crosses it in the favorable direction. Limit orders are essential for strategies that require precise entry and exit prices.
Stop and Stop-Limit Orders
Stop orders activate market or limit orders when the price reaches a specific level. Stop-limit orders combine both features, creating a subsequent limit order when the stop price is triggered. These order types are crucial for risk management and automated trade execution.
Order Placement and Management
The strategy.* namespace provides several functions for order management:
strategy.entry()
This command generates entry orders with unique features for position management. It can automatically reverse open positions and respects the strategy's pyramiding settings. The command creates market orders by default but can also generate limit, stop, and stop-limit orders.
strategy.order()
Unlike other commands, strategy.order() ignores most strategy properties and simply creates orders with specified parameters. It's useful for precise control over order execution without being affected by pyramiding or other strategy settings.
strategy.exit()
This powerful command generates exit orders with support for take-profit, stop-loss, and trailing stop functionality. It can create multiple order types per call and handle partial exits and multi-level exit strategies.
strategy.close() and strategy.close_all()
These commands generate market orders to exit positions. strategy.close() targets specific entry IDs, while strategy.close_all() exits the entire position regardless of entry IDs.
strategy.cancel() and strategy.cancel_all()
Order cancellation commands allow strategies to cancel unfilled orders before the broker emulator processes them. These are particularly useful for price-based orders that may no longer be relevant due to changing market conditions.
Position Sizing and Management
Pine Script offers two primary methods for controlling position sizes:
- Setting default fixed quantity types and values in the strategy declaration
- Specifying quantity arguments directly in order placement commands
Traders can implement various position sizing techniques, from fixed contract amounts to percentage-based risk management systems. Proper position sizing is crucial for risk management and consistent strategy performance.
Frequently Asked Questions
What's the difference between strategies and indicators in Pine Script?
Strategies are designed specifically for trade simulation and backtesting, with access to order placement functions and performance tracking. Indicators are primarily for visual analysis and don't simulate trades or track performance metrics.
How accurate are Pine Script backtests?
Backtest accuracy depends on several factors including data quality, broker emulator assumptions, and strategy design. While historical tests provide valuable insights, they cannot guarantee future performance. The Bar Magnifier feature improves accuracy for premium users.
Can I automate trading with Pine Script strategies?
While Pine Script excels at backtesting and strategy development, it doesn't support automated live trading directly through TradingView. Traders typically use the platform for testing and validation before implementing strategies through supported brokerage connections.
How do I handle commissions and slippage in my strategies?
You can configure commission structures and slippage assumptions in your strategy settings. These factors significantly impact performance results, so it's important to use realistic values that match your actual trading conditions.
What is pyramiding in strategy settings?
Pyramiding controls how many successive entries a strategy allows in the same direction. A value of 1 means the strategy can open new positions but cannot add to them. Higher values allow adding to positions, which can increase potential returns but also amplifies risk.
How does the FIFO closing method work?
By default, strategies use First In, First Out (FIFO) method for closing positions, meaning exit orders close the earliest open trade first. You can change this behavior by setting close_entries_rule = "ANY" in your strategy declaration.
Can I test multiple timeframes with one strategy?
While strategies run on a single chart timeframe, you can access higher and lower timeframe data using the request.security() function. This allows for sophisticated multi-timeframe analysis within a single strategy.
👉 Discover more strategy optimization techniques
Conclusion
Pine Script Strategies provide a powerful framework for developing, testing, and refining algorithmic trading approaches. By understanding order types, execution models, and position management techniques, traders can create robust systems for simulating market behavior.
The Strategy Tester offers comprehensive analytics to evaluate performance, while features like the Bar Magnifier enhance backtesting accuracy. Whether you're testing simple moving average crossovers or complex multi-timeframe systems, Pine Script provides the tools necessary for thorough strategy validation.
Remember that while historical testing provides valuable insights, past performance doesn't guarantee future results. Always use proper risk management and consider multiple market environments when evaluating any trading strategy.