Build your
trading bot

A starter file for XTester Studio. Add your entry and exit rules in the bar callback. Source

public class UserStrategy : IStrategy
{
    // Services available to the strategy: orders, indicators, parameters,
    // market data, and logging.
    private IApi _api = null!;
    private IIndicators _indicators = null!;
    private IStrategyParams _params = null!;
    private IMarketData _marketData = null!;
    private ILogger _logger = null!;

    public void OnInit(StrategyContext context)
    {
        _api = context.Api;
        _indicators = context.Indicators;
        _params = context.Parameters;
        _marketData = context.MarketData;
        _logger = context.Logger;

        _logger.Info("UserStrategy initialized.");
    }

    public void OnTick(decimal? price = null)
    {
    }

    // Called for every closed bar in every subscription.
    // symbolKey identifies the exchange, market, pair, and timeframe.
    public void OnBar(ISymbolKey symbolKey, IKline kline)
    {
    }

    // Called exactly once when a Tester, Paper, or Live run finishes.
    public void OnFinish(StrategyFinishContext context)
    {
    }
}

A starter file for XTester Studio. Add your entry and exit rules in the bar callback. Source

# Add your decisions in on_bar. self.context.api places orders (buy, sell, place_order,
# close_position); self.context.indicators reads the engine's indicators (rsi, sma, ema,
# macd, call("ADX", period=14)); self.context.logger writes to the strategy log.
from xtester import Strategy, OrderSide, OrderType


class UserStrategy(Strategy):
    # symbol_key: exchange, market, symbol, timeframe of the closed bar.
    # bar: open_time, close_time, open, high, low, close, volume as Decimal.
    def on_init(self, context):
        context.logger.info("UserStrategy initialized.")

    def on_tick(self, price):
        pass

    def on_bar(self, symbol_key, bar):
        pass

    def on_finish(self, context):
        pass


def create_strategy():
    return UserStrategy()

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

// EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
// First bullish candle: attempt a 0.01 market buy. First later bearish candle:
// attempt to close the whole position. At most one entry and one exit request.
// Acceptance is not a fill; errors stop the example. No retries, restart recovery,
// position reconciliation or risk controls. Choose valid size/funds in Studio.
// GETTING STARTED
// 1. Open Data and download candles for an exchange, market, and symbol.
// 2. Press F5: the XTester engine runs this strategy over the project's candles and
//    executes orders, fees and balances itself; this file only decides.
// 3. Add your decisions in onBar. this.context.api places orders (buy, sell, placeOrder,
//    closePosition); this.context.indicators reads the engine's indicators (rsi, sma, ema,
//    macd, call('ADX', { period: 14 })); this.context.logger writes to the strategy log.
// Ask the AI assistant to explain this file.
import { Strategy, OrderSide, OrderType } from 'xtester';

export class UserStrategy extends Strategy {
	phase = 0;
	// symbolKey: exchange, market, symbol, timeframe of the closed bar.
	// bar: openTime, closeTime, open, high, low, close, volume as numbers (bar.text.* keeps the exact decimals).
	onInit(context) {
		context.logger.info('UserStrategy initialized.');
	}

	onTick(price) {
	}

	onBar(symbolKey, bar) {
		if (this.phase === 0 && bar.close > bar.open) {
			const result = this.context.api.buy('0.01');
			this.phase = result.success ? 1 : 2;
			if (!result.success) this.context.logger.info(result.errorMessage);
		} else if (this.phase === 1 && bar.close < bar.open) {
			const result = this.context.api.closePosition();
			this.phase = 2;
			if (!result.success) this.context.logger.info(result.errorMessage);
		}
	}

	onFinish(context) {
	}
}

export function createStrategy() {
	return new UserStrategy();
}

A starter file for XTester Studio. Add your entry and exit rules in the bar callback. Source

// The XTester engine type-checks this strategy, runs it over the project's candles
// and executes orders, fees and balances itself; this file only decides.
import { Strategy, OrderSide, OrderType, type Bar, type Context, type SymbolKey } from 'xtester';

export class UserStrategy extends Strategy {
    // symbolKey: exchange, market, symbol, timeframe of the closed bar.
    // bar: openTime, closeTime, open, high, low, close, volume as numbers.
    onInit(context: Context): void {
        context.logger.info('UserStrategy initialized.');
    }

    onTick(price: number | undefined): void {
    }

    onBar(symbolKey: SymbolKey, bar: Bar): void {
    }

    onFinish(context: Context): void {
    }
}

export function createStrategy(): UserStrategy {
    return new UserStrategy();
}

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

// EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
// First bullish candle: attempt a 0.01 market buy. First later bearish candle:
// attempt to close the whole position. At most one entry and one exit request.
// Acceptance is not a fill; errors stop the example. No retries, restart recovery,
// position reconciliation or risk controls. Choose valid size/funds in Studio.
// GETTING STARTED
// 1. Open Data and download candles for an exchange, market, and symbol.
// 2. Press F5: the XTester engine runs this strategy over the project's candles and
//    executes orders, fees and balances itself; this file only decides. A JDK is needed:
//    Studio offers the Java language pack when none is installed.
// 3. Add your decisions in onBar. context.api() places orders (buy, sell, placeOrder,
//    closePosition); context.indicators() reads the engine's indicators (rsi, sma, ema,
//    macd, call("ADX", "period", 14)); context.logger() writes to the strategy log.
// Ask the AI assistant to explain this file.
import xtester.Bar;
import xtester.Context;
import xtester.Strategy;
import xtester.SymbolKey;
import java.math.BigDecimal;

class UserStrategy extends Strategy {
    private int phase = 0;
    @Override
    public void onInit(Context context) {
        context.logger().info("UserStrategy initialized: " + context.parameters().symbolKey());
    }

    @Override
    public void onTick(BigDecimal price) {
    }

    @Override
    public void onBar(SymbolKey symbolKey, Bar bar) {
        if (phase == 0 && bar.close().compareTo(bar.open()) > 0) {
            var result = context.api().buy("0.01");
            phase = result.success() ? 1 : 2;
            if (!result.success()) context.logger().info(result.errorMessage());
        } else if (phase == 1 && bar.close().compareTo(bar.open()) < 0) {
            var result = context.api().closePosition();
            phase = 2;
            if (!result.success()) context.logger().info(result.errorMessage());
        }
    }

    @Override
    public void onFinish(Context context) {
    }
}

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

// EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
// First bullish candle: attempt a 0.01 market buy. First later bearish candle:
// attempt to close the whole position. At most one entry and one exit request.
// Acceptance is not a fill; errors stop the example. No retries, restart recovery,
// position reconciliation or risk controls. Choose valid size/funds in Studio.
// GETTING STARTED
// 1. Open Data and download candles for an exchange, market, and symbol.
// 2. Press F5 inside a project: the XTester engine compiles every .cpp of this folder with the
//    header-only xtester.hpp and runs it over the project's candles, executing orders, fees and
//    balances itself; this file only decides. A C++ compiler is needed (Xcode CLT, clang/g++).
// 3. Add your decisions in onBar. ctx.api places orders (buy, sell, placeOrder, closePosition);
//    ctx.indicators reads the engine's indicators (rsi, sma, ema, call("ADX", ...)); ctx.logger
//    writes to the strategy log. XTESTER_STRATEGY defines main: never write main yourself.
// Ask the AI assistant to explain this file.
#include "xtester.hpp"

class UserStrategy : public xtester::Strategy {
	int phase = 0;
	void onInit(xtester::Context& ctx) override {
		ctx.logger.info("UserStrategy initialized: " + ctx.parameters.symbolKey.str());
	}

	void onTick(xtester::Context& ctx, std::optional<double> price) override {
	}

	void onBar(xtester::Context& ctx, const xtester::SymbolKey& symbolKey, const xtester::Bar& bar) override {
		if (phase == 0 && bar.close > bar.open) {
			auto result = ctx.api.buy("0.01");
			phase = result.success ? 1 : 2;
			if (!result.success) ctx.logger.info(result.errorMessage);
		} else if (phase == 1 && bar.close < bar.open) {
			auto result = ctx.api.closePosition();
			phase = 2;
			if (!result.success) ctx.logger.info(result.errorMessage);
		}
	}

	void onFinish(xtester::Context& ctx) override {
	}
};
XTESTER_STRATEGY(UserStrategy)

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

// EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
// First bullish candle: attempt a 0.01 market buy. First later bearish candle:
// attempt to close the whole position. At most one entry and one exit request.
// Acceptance is not a fill; errors stop the example. No retries, restart recovery,
// position reconciliation or risk controls. Choose valid size/funds in Studio.
// GETTING STARTED
// 1. Open Data and download candles for an exchange, market, and symbol.
// 2. Press F5 inside a project: the XTester engine builds this folder as a crate around the
//    xtester SDK and runs it over the project's candles, executing orders, fees and balances
//    itself; this file only decides. A Rust toolchain is needed: Studio offers the Rust language pack.
// 3. Add your decisions in on_bar. ctx.api places orders (buy, sell, place_order, close_position);
//    ctx.indicators reads the engine's indicators (rsi, sma, ema, call("ADX", ...)); ctx.logger
//    writes to the strategy log (println! breaks the protocol). The engine generates main.
// Ask the AI assistant to explain this file.
use xtester::*;

#[derive(Default)]
struct UserStrategy { phase: u8 }

impl Strategy for UserStrategy {
	fn on_init(&mut self, ctx: &Context) {
		ctx.logger.info(format!("UserStrategy initialized: {}", ctx.parameters.symbol_key));
	}

	fn on_tick(&mut self, ctx: &Context, price: Option<f64>) {
	}

	fn on_bar(&mut self, ctx: &Context, symbol_key: &SymbolKey, bar: &Bar) {
		if self.phase == 0 && bar.close > bar.open {
			let result = ctx.api.buy("0.01");
			self.phase = if result.success { 1 } else { 2 };
			if !result.success { ctx.logger.info(result.error_message); }
		} else if self.phase == 1 && bar.close < bar.open {
			let result = ctx.api.close_position(None, None);
			self.phase = 2;
			if !result.success { ctx.logger.info(result.error_message); }
		}
	}

	fn on_finish(&mut self, ctx: &Context) {
	}
}

pub fn create_strategy() -> Box<dyn Strategy> {
	Box::new(UserStrategy::default())
}

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

// EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
// First bullish candle: attempt a 0.01 market buy. First later bearish candle:
// attempt to close the whole position. At most one entry and one exit request.
// Acceptance is not a fill; errors stop the example. No retries, restart recovery,
// position reconciliation or risk controls. Choose valid size/funds in Studio.
// GETTING STARTED
// 1. Open Data and download candles for an exchange, market, and symbol.
// 2. Press F5 inside a project: the XTester engine builds this folder (package main) with the
//    xtester SDK and runs it over the project's candles, executing orders, fees and balances
//    itself; this file only decides. A Go toolchain is needed: Studio offers the Go language pack.
// 3. Add your decisions in OnBar. ctx.Api places orders (Buy, Sell, PlaceOrder, ClosePosition);
//    ctx.Indicators reads the engine's indicators (RSI, SMA, EMA, Call("ADX", ...)); ctx.Logger
//    writes to the strategy log. Do not write func main: the engine generates it.
// Ask the AI assistant to explain this file.
package main

import (
	"fmt"

	"xtester"
)

type UserStrategy struct {
	xtester.Base
	phase int
}

func init() { xtester.Register(func() xtester.Strategy { return &UserStrategy{} }) }

func (s *UserStrategy) OnInit(ctx *xtester.Context) {
	ctx.Logger.Info(fmt.Sprintf("UserStrategy initialized: %s", ctx.Parameters.SymbolKey))
}

func (s *UserStrategy) OnTick(ctx *xtester.Context, price *float64) {
}

func (s *UserStrategy) OnBar(ctx *xtester.Context, symbolKey xtester.SymbolKey, bar xtester.Bar) {
	if s.phase == 0 && bar.Close > bar.Open {
		result := ctx.Api.Buy("0.01")
		if result.Success { s.phase = 1 } else { s.phase = 2; ctx.Logger.Info(result.ErrorMessage) }
	} else if s.phase == 1 && bar.Close < bar.Open {
		result := ctx.Api.ClosePosition(nil, "")
		s.phase = 2
		if !result.Success { ctx.Logger.Info(result.ErrorMessage) }
	}
}

func (s *UserStrategy) OnFinish(ctx *xtester.Context) {
}

Educational Tester example: one market buy on a bullish candle, one close request on a later bearish candle. One symbol, initially flat; acceptance is not a fill. Not for live trading. Source

# EDUCATIONAL TESTER EXAMPLE — one symbol, initially flat; not for live trading.
# First bullish candle: attempt a 0.01 market buy. First later bearish candle:
# attempt to close the whole position. At most one entry and one exit request.
# Acceptance is not a fill; errors stop the example. No retries, restart recovery,
# position reconciliation or risk controls. Choose valid size/funds in Studio.
# GETTING STARTED
# 1. Open Data and download candles for an exchange, market, and symbol.
# 2. Press F5 inside a project: the XTester engine runs this file with Rscript over the
#    project's candles, executing orders, fees and balances itself; this file only decides.
#    R must be installed (https://cloud.r-project.org); the R pack adds jsonlite and the language server.
# 3. Add your decisions in on_bar. context$api places orders (buy, sell, place_order,
#    close_position); context$indicators reads the engine's indicators (rsi, sma, ema,
#    call("ADX", list(period = 14))); context$logger writes to the strategy log.
# Ask the AI assistant to explain this file.
create_strategy <- function() {
  state <- new.env()
  state$phase <- 0L
  list(
    on_init = function(context) {
      context$logger$info(paste("UserStrategy initialized:", xtester_symbol_text(context$parameters$symbol_key)))
    },
    on_tick = function(context, price) {
    },
    on_bar = function(context, symbol_key, bar) {
      if (state$phase == 0L && bar$close > bar$open) {
        result <- context$api$buy("0.01")
        state$phase <- if (result$success) 1L else 2L
        if (!result$success) context$logger$info(result$error_message)
      } else if (state$phase == 1L && bar$close < bar$open) {
        result <- context$api$close_position()
        state$phase <- 2L
        if (!result$success) context$logger$info(result$error_message)
      }
    },
    on_finish = function(context) {
    }
  )
}

Original EMA crossover strategy for the Pine subset interpreter. Source

//@version=6
// XTester's own Pine interpreter runs this script once per closed bar and
// the engine executes strategy.entry / strategy.exit / strategy.close orders,
// fees and balances. Plots and drawings are accepted and ignored.
strategy("UserStrategy", overlay = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 10)

fast = ta.ema(close, input.int(9, "Fast EMA"))
slow = ta.ema(close, input.int(21, "Slow EMA"))
if ta.crossover(fast, slow)
    strategy.entry("Long", strategy.long)
if ta.crossunder(fast, slow)
    strategy.close("Long")
plot(fast, "Fast", color.new(color.blue, 0))
plot(slow, "Slow", color.new(color.orange, 0))