1 of 100

FTO Indicators Docs

Overview

Welcome to the documentation for creating custom indicators in Forex Tester Online (FTO).

This guide is designed to help developers and strategy testers understand the structure, lifecycle, and capabilities of custom scripts written for FTO. You’ll learn how to set up your environment, build your own indicators, and access key platform features via the available API.

📌 What You’ll Find Here

👨‍💻 Who is This For?

This documentation is for:

Developers building and debugging trading indicators
Algorithmic traders backtesting and optimizing their strategies
Power users looking to customize and extend FTO’s capabilities

🚀 Ready to Begin?

Set up indicator

This is a separate guide on how to set up the environment to write your custom indicator for FTO.

Open it with Cursor or any IDE of your choice — we suggest Cursor. Then, by clicking the icon shown in Picture #1, open the terminal and install the dependencies using the command npm install.

After installing the dependencies, build the project using the command npm run build.

If you get an error that goes like this:

cannot be loaded because running scripts is disabled on this system.
For more information, see about_Execution_Policies at
https:/go.microsoft.com/fwlink/?LinkID=135170. At line:1 char:1

Then you need to enter command Set-ExecutionPolicy RemoteSigned -Scope CurrentUser and then trynpm install and then npm run build command again.

After building the project, a file my-indicator-project.js (Indicator file name) will appear in the dist folder.

Upload indicator to FTO

This is a separate guide on how to upload your indicator to FTO.

If you have created an indicator that you want to upload and have run the npm build command in the terminal, a file named my-indicator-project.js (indicator's file name) will appear in the dist folder. Upload this file to FTO (see Picture #1 and #2).

From there, your indicator should appear in "My Indicators" dropdown menu (Picture #3).

Tutorial: Create indicator with Cursor IDE

This tutorial will guide you through the process of creating a new indicator using Cursor IDE.

Introduction

Cursor IDE is a fork of VS Code that has powerful AI capabilities, allowing it to access your code directly and have information about your project.

Cursor can also be provided with FTO custom indicator documentation to assist in creating new indicators.

Please note that Cursor is a paid IDE, but it has a free version, the free version is limited to 50 requests and 2000 completions total.

Step 1: Install Cursor and set up the project

Step 2: Apply Cursor Rules

To set up global rules for Cursor, click the setting icon (Picture #1)

From here, click the Rules setting (Picture #2)

In the User Rules field (Picture #3), download and paste contents of the file below called Rules.txt

Step 3: Upload FTO indicator documentation to Cursor

You can upload the FTO indicator documentation to Cursor, and Cursor will be able to use it to help you create new indicators.

To upload the FTO indicator documentation to Cursor, you need to follow these steps:

1. Click the setting icon in the top right corner of the Cursor IDE. (Picture #4)

2. Select "Features" on the left sidebar (Picture #5).

Scroll down until you see Docs (Picture #6)

Click on the "Add new doc" button and insert link https://fto-2.gitbook.io/fto-indicators-docs to the FTO indicator documentation (Picture #7).

After some indexing, Cursor will be able to refer to the documentation to help you create new indicators.

Step 4: Getting familiar with Cursor

To open Cursors AI window, you can press Ctrl+L or click on the icon in the top right corner of the Cursor IDE (Picture #8)

This panel has a chat interface and in Cursor version 0.47.8 it has 3 modes, Agent, Ask and Edit,

each catering to different needs during development (Picture #9).

Agent Mode: This mode allows for automated code generation and completion by interacting with the AI. It helps streamline the coding process by providing intelligent suggestions and solutions. I access your project files directly and suggests code which you can accept or reject
Ask Mode: In this mode, developers can ask questions about their codebase, programming concepts, or any development-related topics. The AI will respond with helpful guidance and explanations.
Edit Mode: Edit Mode assists in making modifications to the existing code. It aids in refactoring, simplifying, or improving code sections as needed.

What makes these modes powerful is the ability to add context directly from your project or documentation

For now, select the Ask mode

Next to the "select mode menu" there is also an option to select a model of AI that we want to use, for now we should choose Auto-select (Picture#10).

Step 5: Start building

In the result, we got code below

import { IndicatorImplementation, TDrawStyle, TPenStyle, TOutputWindow, TIndexBuffer } from "forex-tester-custom-indicator-api";

export default class OBVIndicator extends IndicatorImplementation {
    // Declare the buffer as a class property
    public obvBuffer!: TIndexBuffer;

    Init(): void {
        this.api.RecalculateMeAlways();
        
        // Set indicator name
        this.api.IndicatorShortName("On Balance Volume (OBV)");
        
        // Configure to display in separate window since OBV is an oscillator
        this.api.SetOutputWindow(TOutputWindow.SEPARATE_WINDOW);
        
        // Register the number of buffers we'll use
        this.api.IndicatorBuffers(1);
        
        // Create and initialize the OBV buffer
        this.obvBuffer = this.api.CreateIndexBuffer();
        
        // Bind buffer to index 0
        this.api.SetIndexBuffer(0, this.obvBuffer);
        
        // Configure buffer appearance
        this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#0000FF"); // Blue line
        this.api.SetIndexLabel(0, "OBV");
    }

    Calculate(index: number): void {
        // If this is the first bar (rightmost/newest), initialize OBV
        if (index === this.api.Bars() - 1) {
            this.obvBuffer.setValue(index, this.api.Volume(index));
            return;
        }

        // Get current and previous close prices
        const currentClose = this.api.Close(index);
        const previousClose = this.api.Close(index + 1);
        
        // Get current volume
        const volume = this.api.Volume(index);
        
        // Get previous OBV value
        const previousOBV = this.obvBuffer.getValue(index + 1);
        
        let currentOBV;
        
        // Calculate OBV based on price movement
        if (currentClose > previousClose) {
            // If price increased, add volume
            currentOBV = previousOBV + volume;
        } else if (currentClose < previousClose) {
            // If price decreased, subtract volume
            currentOBV = previousOBV - volume;
        } else {
            // If price unchanged, OBV remains the same
            currentOBV = previousOBV;
        }
        
        // Set the calculated OBV value
        this.obvBuffer.setValue(index, currentOBV);
    }
}

The current logic seems correct, but it's using only the Close price, and there is currently no way for the user to specify their own price type. Let's ask it to fix that (Picture #12).

The code that Cursor wrote in his second response is below

import { 
    IndicatorImplementation, 
    TDrawStyle, 
    TPenStyle, 
    TOutputWindow, 
    TIndexBuffer,
    TOptionType,
    TOptValue_number
} from "forex-tester-custom-indicator-api";

export default class OBVIndicator extends IndicatorImplementation {
    // Declare the buffer as a class property
    public obvBuffer!: TIndexBuffer;
    
    // Declare price type parameter
    public priceType!: TOptValue_number;

    Init(): void {
        this.api.RecalculateMeAlways();
        
        // Set indicator name
        this.api.IndicatorShortName("On Balance Volume (OBV)");
        
        // Configure to display in separate window since OBV is an oscillator
        this.api.SetOutputWindow(TOutputWindow.SEPARATE_WINDOW);
        
        // Initialize price type parameter
        this.priceType = this.api.createTOptValue_number(0); // Default to Close price
        
        // Register price type parameter as an enum
        this.api.RegOption(
            "Price Type",
            TOptionType.ENUM_TYPE,
            this.priceType
        );
        
        // Add price type options
        this.api.AddOptionValue("Price Type", "Close");
        this.api.AddOptionValue("Price Type", "Open");
        this.api.AddOptionValue("Price Type", "High");
        this.api.AddOptionValue("Price Type", "Low");
        this.api.AddOptionValue("Price Type", "Median ((H+L)/2)");
        this.api.AddOptionValue("Price Type", "Typical ((H+L+C)/3)");
        
        // Register the number of buffers we'll use
        this.api.IndicatorBuffers(1);
        
        // Create and initialize the OBV buffer
        this.obvBuffer = this.api.CreateIndexBuffer();
        
        // Bind buffer to index 0
        this.api.SetIndexBuffer(0, this.obvBuffer);
        
        // Configure buffer appearance
        this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#0000FF"); // Blue line
        this.api.SetIndexLabel(0, "OBV");
    }

    private getPrice(index: number): number {
        switch (this.priceType.value) {
            case 0: // Close
                return this.api.Close(index);
            case 1: // Open
                return this.api.Open(index);
            case 2: // High
                return this.api.High(index);
            case 3: // Low
                return this.api.Low(index);
            case 4: // Median
                return (this.api.High(index) + this.api.Low(index)) / 2;
            case 5: // Typical
                return (this.api.High(index) + this.api.Low(index) + this.api.Close(index)) / 3;
            default:
                return this.api.Close(index); // Fallback to Close
        }
    }

    Calculate(index: number): void {
        // If this is the first bar (rightmost/newest), initialize OBV
        if (index === this.api.Bars() - 1) {
            this.obvBuffer.setValue(index, this.api.Volume(index));
            return;
        }

        // Get current and previous prices using selected price type
        const currentPrice = this.getPrice(index);
        const previousPrice = this.getPrice(index + 1);
        
        // Get current volume
        const volume = this.api.Volume(index);
        
        // Get previous OBV value
        const previousOBV = this.obvBuffer.getValue(index + 1);
        
        let currentOBV;
        
        // Calculate OBV based on price movement
        if (currentPrice > previousPrice) {
            // If price increased, add volume
            currentOBV = previousOBV + volume;
        } else if (currentPrice < previousPrice) {
            // If price decreased, subtract volume
            currentOBV = previousOBV - volume;
        } else {
            // If price unchanged, OBV remains the same
            currentOBV = previousOBV;
        }
        
        // Set the calculated OBV value
        this.obvBuffer.setValue(index, currentOBV);
    }
}

And with the addition of this new parameter and internal method, we get a nice dropdown with price types (Picture #13).

Recommendations

Start by selecting the Ask mode and add context to your query by typing @ and selecting Docs from the drop-down menu (Picture #14).

And provide add a file in which you want to create the indicator, you can do it by drag and dropping it from explorer window on the left onto the chat window or finding it in the @ drop-down menu under Files & folders (Picture #16)

Set up Cursor Rules

To set up global rules for Cursor, click the setting icon (Picture #1)

From here, click the Rules setting (Picture #2)

In the User Rules field (Picture #3), download and paste contents of the file below called Rules.txt

Tutorial: Open and upload indicator

This page will guide you how to install Cursor IDE and how to upload your custom indicator to FTO.

After installing node.js, download the archive with the indicator example below and extract it to a convenient location.

Open the extracted folder "Moving Average" and inside of it you should find another folder "custom_indicator", open it with Cursor (Picture #2 and #3).

If you get a pop-up like this, click "Yes, I trust the authors"

Then, by clicking the icon shown on Picture #5 you should open the terminal and install the dependencies using the command npm install.

After installing the dependencies, you can start writing your indicator in the index.ts file.

Once the implementation is complete, you can build the project using the command npm run build.

If you get an error that goes like this:

Then you need to enter command Set-ExecutionPolicy RemoteSigned -Scope CurrentUser and then trynpm install and then npm run build command again.

After building the project, a file my-indicator-project.js (Indicator file name) will appear in the dist folder.

Upload this file to the FTO (Picture #6 and #7).

From there, your indicator should appear in "My Indicators" dropdown menu (Picture #8).

Tutorial: Moving Average

In this tutorial, we will look at an example implementation of the MovingAverage indicator.

To get acquainted with the implementation example, download the archive with the indicator example and open it in IDE of your choice, we suggest you use Cursor IDE.

You can download the archive of Moving Average from here

Indicator structure

import { IndicatorImplementation } from "forex-tester-custom-indicator-api";

export default class MovingAverage extends IndicatorImplementation {
  // indicator logic
}

Indicator parameters

export default class MovingAverage extends IndicatorImplementation {
    // Declaring class-level fields
    public Period!: TOptValue_number;
    public Shift!: TOptValue_number;
    public MAtype!: TOptValue_number;
    public ApplyToPrice!: TOptValue_number;
    public VShift!: TOptValue_number;

    Init(): void {
        // Create parameters using factory method
        this.Period = this.api.createTOptValue_number(8);
        this.Shift = this.api.createTOptValue_number(0);
        this.MAtype = this.api.createTOptValue_number(E_MAType.SMA);
        this.ApplyToPrice = this.api.createTOptValue_number(TPriceType.CLOSE);
        this.VShift = this.api.createTOptValue_number(0);
    ...existing code...
    }


public Init(): void {
  ...existing code...
  // Register parameter this.Period so it's shown in the indicator settings
  this.api.RegOption(
    'Period',
    TOptionType.INTEGER,
    this.Period
  );
  // Setting the maximum avalable range that can be used for Period value
  this.api.SetOptionRange(
    'Period',
    1,
    Number.MAX_SAFE_INTEGER
  );
  // Register parameter this.Shift so it's shown in the indicator settings
  this.api.RegOption(
    'Shift',
    TOptionType.INTEGER,
    this.Shift
  );
  // Register parameter this.VShift so it's its shown in the indicator settings
  this.api.RegOption(
    'VShift',
    TOptionType.INTEGER,
    this.VShift
  );
  // Register the MA type so it has a drowdown in the indicator settings
  this.api.RegMATypeOption(
    this.MAtype,
    'MAtype'
  );
  // Register the price type so it has a dropdown in the indicator settings.
  this.api.RegApplyToPriceOption(
    this.ApplyToPrice,
    'ApplyToPrice'
  );
...existing code...
}

Buffers setup

public SSMA!: TIndexBuffer
private SMA!: TIndexBuffer

this.SMA = this.api.CreateIndexBuffer();
this.SSMA = this.api.CreateIndexBuffer();

After their creation, you need to tell how many buffers will be displayed on the chart and bind them by index, starting from 0 (the indices must be unique) In this case, there is one buffer

this.api.IndicatorBuffers(1);
this.api.SetIndexBuffer(0, this.SSMA);

this.api.SetIndexLabel(0, "MA");
this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
this.api.SetIndexDrawBegin(0, this.Period.value - 1 + this.Shift.value);

Other settings

Indicator's main function

public Calculate(index: number): void {
    // check if the index is in the valid range
    if (index + this.Period.value >= this.api.Bars()) {
        return
    }

    // calculate the SMA value
    const calculatedSMA = this.api.GetMA(
        index,
        0,
        this.Period.value,
        this.MAtype.value,
        this.ApplyToPrice.value,
        // here we get the value of the previous bar
        this.SMA.getValue(index + 1)
    )

    this.SMA.setValue(index, calculatedSMA)
    // set the value which is going to be displayed on the chart
    this.SSMA.setValue(index, calculatedSMA + this.VShift.value * this.api.Point())
}

Changing parameters

public OnParamsChange(): void {
    this.api.SetBufferShift(0, this.Shift.value)
}

Download indicator examples

These are indicator examples you can download

Indicators

Indicator structure

import { IndicatorImplementation } from "forex-tester-custom-indicator-api";

export default class IndicatorName extends IndicatorImplementation {
  // parameters

  public Init(): void {
    // initialization logic
  }

  public Calculate(index: number): void {
    // calculation logic
  }

  public OnParamsChange(): void {
    // logic after parameters change
  }

  public Done(): void {
    // logic after finishing the calculation
  }

  public OnHide(): void {
    // logic after hiding the indicator
  }

  public OnShow(): void {
    // logic after showing the indicator
  }
}

Description of the structure

To get familiar with other methods, you can read the documentation for each method.

Init

What is it?

The Init method is called once, right when your custom indicator is created or loaded onto the chart. This is where you set everything up — like naming your indicator, creating buffers, creating parameters and registering them, and more.

Syntax

public Init(): void {
    // initialization logic here
}

What Happens in `Init`

This method is like a constructor for your indicator. Here’s what usually happens inside:

Set the name and description of the indicator
Create buffers that store the calculated values
Create and register input parameters like period, color, or line style
Set the number of plots, line types, and other configurations

Example

export default class MovingAverage extends IndicatorImplementation {
  // parameters
  public Period!: TOptValue_number;
  public MA!: TIndexBuffer;

  public Init(): void {
    // Create parameters
    this.Period = this.api.createTOptValue_number(8);
    // Setting visible name for an indicator
    this.api.IndicatorShortName("Moving Average");
    // Setting output window to chart, not oscillator  window
    this.api.SetOutputWindow(TOutputWindow.CHART_WINDOW);
    // Registerring parameter Period
    this.api.RegOption("Period", TOptionType.INTEGER, this.Period);
    // Setting available range for it in the menu
    this.api.SetOptionRange("Period", 1, 9999);
    // Creating and tuning the buffer
    this.MA = this.api.CreateIndexBuffer();
    this.api.IndicatorBuffers(1);
    this.api.SetIndexBuffer(0, this.MA);
    this.api.SetIndexLabel(0, "Moving Average");
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
  }
}

Why It Matters

Without Init, your indicator won't show anything.
It's required to tell the system how many lines you draw and what inputs you need.
Think of it as your setup stage — it only runs once when the indicator is loaded.

Pro Tip

Avoid heavy calculations or per-bar logic here. Use Calculate() for that. Init is only for defining the structure and settings of the indicator.

Calculate

What is it?

The Calculate method is one of the core functions used in a custom indicator. It’s responsible for calculating the logic of your indicator for each bar (candle) on the chart.

This function runs automatically on each price update (tick) and recalculates values for the given bar.

How It Works

index — This parameter tells you which bar you’re working with.
- index = 0 → the latest bar (rightmost on the chart).
- index = 1 → the previous bar, and so on.
The method runs once per tick (price change) and calculates the indicator value only for the specified bar.

Example Explained

public Calculate(index: number): void {
    // Skip if not enough bars to calculate moving average
    if (index + this.Period.value >= this.api.Bars()) {
        return
    }

    // Get the calculated value of the Moving Average
    const calculatedSMA = this.api.GetMA(
        index,
        0,                              // Shift (usually 0)
        this.Period.value,              // Period for MA
        this.MAtype.value,              // Type of MA (SMA, EMA, etc.)
        this.ApplyToPrice.value,        // Price type (Close, Open, etc.)
        this.SMA.getValue(index + 1)    // Previous value for smoothing (optional)
    )

    // Save the value to the SMA buffer
    this.SMA.setValue(index, calculatedSMA)

    // Save a shifted version to another buffer
    this.SSMA.setValue(index, calculatedSMA + this.VShift.value * this.api.Point())
}

What This Code Does

Checks if there are enough bars to calculate the moving average. (We need Period number of candles; otherwise, we skip.)
Calculates a Moving Average value using GetMA().
Stores the result in the SMA buffer, which is used for drawing on the chart.
Applies a vertical shift (VShift) and stores the result in a second buffer (SSMA).

In Short

This method is where you put your main logic.
It runs automatically for each bar.
You should use it to calculate and store indicator values.
Buffers like SMA and SSMA are how your indicator shows up visually on the chart.

this.SSMA.setValue(index, calculatedSMA + this.VShift.value * this.api.Point())

OnParamsChange

What is it?

The OnParamsChange method is called automatically when the user changes any parameter of your indicator — for example, the period, color, MA type, etc.

It allows you to respond to these changes and adjust your indicator's behavior or visuals accordingly.

Syntax

When and Why to Use It

This method is called after the user updates the settings in the indicator panel.
Use it to:
- Recalculate internal values
- Adjust or re-create custom chart objects
- Apply shifts, styling, or any other dynamic behavior
- Update dependencies between parameters

Example Use Case

Let’s say your indicator displays a shifted line or a custom label. When the user updates the "Shift" parameter, you want the line or label to move accordingly — that logic would go inside OnParamsChange.

Important Notes

It only runs when the user changes something manually in the settings window.
If you don’t need any custom logic after parameter changes — you can leave it empty.

In Simple Terms

Think of OnParamsChange as the method that reacts to user edits in the settings panel. It gives you a place to respond to those changes and adjust the indicator’s behavior.

Done

What is it?

The Done method is called once, after the indicator has finished calculating all bars. It marks the end of the calculation cycle and is typically used for final steps or cleanup.

Syntax

When and Why to Use It

Use Done when you need to:

Perform post-processing after all Calculate() calls are complete
Draw or update custom chart objects that rely on full data
Clean up temporary data or buffers
Log or store final values

This method is especially useful if your indicator logic depends on seeing the entire dataset.

Example

Important Notes

Done is called after all bars have been processed in Calculate().
It runs once per full calculation cycle — not on every tick.
It’s safe to use this method to add chart decorations, logs, or summary calculations.

OnShow

What is it?

The OnShow method is called when the indicator is made visible on the chart. This includes the moment it’s re-enabled after being hidden.

Syntax

When and Why to Use It

Use OnShow when you need to:

Re-create or re-draw custom chart objects
Restore visual elements that were removed or hidden earlier
Trigger any logic that should happen only when the indicator is visible

This method is helpful when your indicator includes dynamic elements (like shapes, labels, or highlights) that should appear only when the indicator is active.

Example

Important Notes

This method is not called during every tick or calculation — only when visibility changes.
If your indicator does not rely on custom objects or UI elements, you may not need to implement OnShow.

OnHide

What is it?

The OnHide method is called automatically when the indicator is hidden from the chart — for example, when the user disables its visibility.

This gives you a place to clean up any visual elements or perform other logic when the indicator is no longer visible.

Syntax

public OnHide(): void {
    // logic after hiding the indicator
}

When and Why to Use It

Use OnHide when you want to:

Remove custom chart objects (labels, lines, shapes) added by the indicator
Free resources or stop background logic tied to visualization
Prepare for a clean re-render when the indicator is shown again

Example

public OnHide(): void {
    // Custom method to remove a label created when the indicator was shown
    this.DeleteObject("InfoLabel")
}

Important Notes

OnHide only runs when the indicator becomes hidden — not when it is removed completely.
It pairs naturally with OnShow, helping you manage custom visual elements.

Parameters

What Are Parameters?

Indicator parameters are configurable settings that allow users to customize how an indicator behaves and looks. They appear in the indicator’s settings panel and can be modified without changing the code.

How It Works

To make a parameter configurable, it must be created using one of the TOptValue types , created and registered inside the Init() method.

Any variable that does not extend TOptValue is considered internal and will not be visible or editable in the user interface.

Common Parameter Types

Here are some of the commonly used TOptValue types:

TOptValue_number — numeric values (e.g., period, shift)
TOptValue_bool — true/false switches
TOptValue_string — string input

Example

export default class CustomIndicator extends IndicatorImplementation {
  // Configurable parameters
  public Period!: TOptValue_number;
  public ShowLabels!: TOptValue_bool;
  public ApplyToPrice!: TOptValue_number;

  // Internal parameter (not configurable)
  public internalParameter: number = 0;

  public Init(): void {
    // Create parameters
    this.Period = this.api.createTOptValue_number(8);
    this.ShowLabels = this.api.createTOptValue_bool(true);
    this.ApplyToPrice = this.api.createTOptValue_number(TPriceType.CLOSE);
    // Register parameters so they show up in the UI
    this.api.RegOption("Period", TOptionType.INTEGER, this.Period);
    this.api.RegOption("ShowLabels", TOptionType.BOOLEAN, this.ShowLabels);
    this.api.RegOption("ApplyToPrice", TOptionType.INTEGER, this.ApplyToPrice);
  }
}

Key Rules

Parameters control how the indicator works and looks — use them for anything the user might want to tweak

TOptValue

This is documentation for different types of TOptValue classes which are used to create parameters for indicators.

TOptValue_number

What Is It?

TOptValue_number is a class used to define numeric parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust numbers such as periods, shifts, price types, and more.

You must use the createTOptValue_number() method of the api object inside Init() method to create an instance.

When to Use

Use TOptValue_number when you need a configurable parameter of type number, such as:

Period length for moving averages
Shift values
Enum values (e.g., MA type, price type)
Any numeric input from the user

Syntax

Example

In this example:

Period controls how many bars are used in the moving average calculation.
Shift can offset the indicator horizontally.
MAtype selects the type of moving average (e.g., SMA, EMA).
ApplyToPrice defines which price (close, open, high, low) the MA should use.
VShift applies a vertical offset to the line.

Notes

You can access the value using this.MyParameter.value.

TOptValue_str

What Is It?

TOptValue_str is a class used to define string parameters in custom indicators. It allows users to enter or modify text values in the indicator settings panel.

Use the createTOptValue_str() method from the api object inside Init() method to create an instance.

When to Use

Use TOptValue_str when you want to let the user:

Input custom labels or names
Define identifiers or tags
Set any free-form text value

Syntax

// Declare the parameter in the class fields
public MyText!: TOptValue_str;

public Init(): void {
    // Create the parameter
    this.MyText = this.api.createTOptValue_str("default text");

    // Register the parameter
    this.api.RegOption("MyText", TOptionType.STRING, this.MyText);
}

Example

export default class CustomIndicator extends IndicatorImplementation {
  public Name!: TOptValue_str;

  public Init(): void {
    this.Name = this.api.createTOptValue_str("Custom Indicator");

    this.api.RegOption("Name", TOptionType.STRING, this.Name);
  }
}

In this example:

Name is a string parameter that can be changed by the user.
The value can be accessed via this.Name.value.

Notes

You can use the value directly in Calculate, OnShow, or other methods as needed.

TOptValue_bool

What Is It?

TOptValue_bool is a class used to define boolean (true/false) parameters in custom indicators. It allows users to enable or disable certain features through the indicator settings panel.

Use the createTOptValue_bool() method from the api object inside Init() method to create an instance.

When to Use

Use TOptValue_bool when you want to let the user:

Toggle a feature on or off
Show or hide additional elements
Enable conditional behavior in your indicator

Syntax

public MyFlag!: TOptValue_bool;

public Init(): void {
    // Create the parameter
    this.MyFlag = this.api.createTOptValue_bool(defaultValue);

    // Register the parameter
    this.api.RegOption("MyFlag", TOptionType.BOOLEAN, this.MyFlag);
}

Example

export default class CustomIndicator extends IndicatorImplementation {
  public IsEnabled!: TOptValue_bool;

  public Init(): void {
    this.IsEnabled = this.api.createTOptValue_bool(true);

    this.api.RegOption("IsEnabled", TOptionType.BOOLEAN, this.IsEnabled);
  }

  public Calculate(index: number): void {
    if (!this.IsEnabled.value) {
      return;
    }

    // Perform calculations only if enabled
  }
}

In this example:

IsEnabled allows the user to toggle indicator logic on or off.
Inside Calculate(), the logic runs only if the toggle is true.

Notes

Access the value with this.MyFlag.value.

Visible buffers

Overview

To display indicator values on the chart in Forex Tester Online, you need to use buffers. Buffers store the calculated values and define how they should be visualized (e.g., lines, histograms, dots).

Each buffer is created as a TIndexBuffer and configured through API calls.

Step-by-Step Guide

1. Declare the Buffer

All buffers must be declared as class fields using the TIndexBuffer type.

2. Create the Buffer in `Init()`

Create the buffer instance using the CreateIndexBuffer() method.

3. Register the Number of Buffers

Tell the API how many buffers you plan to use. In this case — one:

This must be called before setting buffer styles or assignments.

4. Bind the Buffer to an Index

Each buffer must be assigned a unique index:

5. Configure the Buffer

You can now customize how the buffer will appear on the chart:

Full Example

Notes

Each buffer must be declared, created, and registered properly to be visible on the chart.
Indices must be unique and zero-based (0, 1, 2, etc.).
You can use multiple buffers to display several lines or visual elements.

Access to Bar Arrays

This section provides functions to access historical bar data such as open, high, low, close, volume, and time. These functions are essential for building logic in custom indicators.

Available Functions

Click on any function name to view its detailed documentation.

Volume

Returns the volume for a specific bar.

Syntax

Volume(shift: number): number

Parameters

shift: A number representing the shift from the current bar

Return Value

Returns a number representing the trading volume during the specified bar.

Description

The Volume method returns the trading volume for a bar at the specified shift from the current bar. Volume represents the total amount of trading activity during the bar's timeframe. The shift parameter determines which bar's volume to return:

0: Current bar
1: Previous bar
2: Two bars ago
And so on

Example

// Get current bar's volume
const currentVolume = this.api.Volume(0);

// Get previous bar's volume
const previousVolume = this.api.Volume(1);

// Calculate average volume over last 3 bars
let totalVolume = 0;
for (let i = 0; i < 3; i++) {
  totalVolume += this.api.Volume(i);
}
const averageVolume = totalVolume / 3;
console.log(`Average volume over last 3 bars: ${averageVolume}`);

// Check for volume spike
if (this.api.Volume(0) > this.api.Volume(1) * 2) {
  console.log("Volume spike detected on current bar");
}

iVolume

Returns the tick volume of a bar in the specified symbol's price history.

Syntax

iVolume(Symbol: string, TimeFrame: number, index: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the tick volume of the specified bar.

Description

The iVolume method retrieves the tick volume of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar. The volume represents the number of price changes (ticks) that occurred during the bar period.

Example

// Get the volume of the current bar for EURUSD on H1 timeframe
const currentVolume = this.api.iVolume("EURUSD", 60, 0);

// Get the volume from 5 bars ago
const pastVolume = this.api.iVolume("EURUSD", 60, 5);

// Calculate the total volume over the last 3 bars
const totalVolume =
  this.api.iVolume("EURUSD", 60, 0) +
  this.api.iVolume("EURUSD", 60, 1) +
  this.api.iVolume("EURUSD", 60, 2);

// Calculate average volume over last 3 bars
const avgVolume = totalVolume / 3;

// Check if current volume is higher than previous bar
if (this.api.iVolume("EURUSD", 60, 0) > this.api.iVolume("EURUSD", 60, 1)) {
  console.log("Volume is increasing");
}

// Check for volume spike (2x average)
const isVolumeSpiking = this.api.iVolume("EURUSD", 60, 0) > avgVolume * 2;

iTime

Returns the opening time of a bar in the specified symbol's price history.

Syntax

iTime(Symbol: string, TimeFrame: number, index: number): FTODate

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Description

The iTime method retrieves the opening time of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar. The returned time is in UTC timezone.

Example

// Get the time of the current bar for EURUSD on H1 timeframe
const currentTime = this.api.iTime("EURUSD", 60, 0);

// Get the time from 5 bars ago
const pastTime = this.api.iTime("EURUSD", 60, 5);

// Calculate time difference between bars
const timeDiff =
  this.api.iTime("EURUSD", 60, 0).toMilliseconds() -
  this.api.iTime("EURUSD", 60, 1).toMilliseconds();

// Check if bar is from today
const now = this.api.createFTODate(Date.now());
const barTime = this.api.iTime("EURUSD", 60, 0);
const isToday =
  barTime.getUTCDate() === now.getUTCDate() &&
  barTime.getUTCMonth() === now.getUTCMonth() &&
  barTime.getUTCFullYear() === now.getUTCFullYear();

// Get bar times for the last 3 bars
const barTimes = [];
for (let i = 0; i < 3; i++) {
  barTimes.push(this.api.iTime("EURUSD", 60, i));
}

iOpen

Returns the open price of a bar in the specified symbol's price history.

Syntax

iOpen(Symbol: string, TimeFrame: number, index: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the open price of the specified bar.

Description

The iOpen method retrieves the opening price of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

// Get the open price of the current bar for EURUSD on H1 timeframe
const currentOpen = this.api.iOpen("EURUSD", 60, 0);

// Get the open price from 5 bars ago
const pastOpen = this.api.iOpen("EURUSD", 60, 5);

// Calculate the difference between current and previous bar's open prices
const openDiff =
  this.api.iOpen("EURUSD", 60, 0) - this.api.iOpen("EURUSD", 60, 1);

// Check if current bar opened higher than previous bar
if (this.api.iOpen("EURUSD", 60, 0) > this.api.iOpen("EURUSD", 60, 1)) {
  console.log("Current bar opened higher");
}

iLowest

Returns the index of the bar with the lowest value over a specified range.

Syntax

iLowest(symbol: string, timeFrame: number, type: number, count: number, index: number): number

Parameters

symbol: The symbol to get data for
timeFrame: The timeframe of the data (in minutes)
type: The price type to compare (0=OPEN, 1=HIGH, 2=LOW, 3=CLOSE, 4=VOLUME)
count: Number of bars to search through
index: The starting bar index (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the index of the bar with the lowest value. Returns -1 if no valid bar is found.

Description

The iLowest method searches for the bar with the lowest value of the specified price type (open, high, low, close, or volume) within a range of bars. The search starts from the specified index and looks back for the specified number of bars. The method is useful for finding local minima and implementing various technical analysis strategies.

Example

// Find lowest low price in last 10 bars
const lowestIndex = this.api.iLowest("EURUSD", 60, 2, 10, 0);
if (lowestIndex !== -1) {
  const lowestPrice = this.api.iLow("EURUSD", 60, lowestIndex);
  console.log(`Lowest price: ${lowestPrice} at index ${lowestIndex}`);
}

// Find lowest close in last 20 bars
const lowestCloseIndex = this.api.iLowest("EURUSD", 60, 3, 20, 0);

// Find lowest volume in last 5 bars
const lowestVolumeIndex = this.api.iLowest("EURUSD", 60, 4, 5, 0);

// Check if current bar is lowest in last 50 bars
const isNewLow = this.api.iLowest("EURUSD", 60, 2, 50, 0) === 0;

// Find lowest low starting from a specific bar
const startIndex = 10;
const lookback = 5;
const lowIndex = this.api.iLowest("EURUSD", 60, 2, lookback, startIndex);

// Get lowest price values for different types
const types = [0, 1, 2, 3]; // OPEN, HIGH, LOW, CLOSE
const lowestValues = types.map((type) => {
  const idx = this.api.iLowest("EURUSD", 60, type, 10, 0);
  return idx !== -1 ? this.api.iLow("EURUSD", 60, idx) : null;
});

// Find price channel
const highestHigh = this.api.iHigh(
  "EURUSD",
  60,
  this.api.iHighest("EURUSD", 60, 1, 20, 0)
);
const lowestLow = this.api.iLow(
  "EURUSD",
  60,
  this.api.iLowest("EURUSD", 60, 2, 20, 0)
);
const channelHeight = highestHigh - lowestLow;

iLow

Returns the lowest price of a bar in the specified symbol's price history.

Syntax

iLow(Symbol: string, TimeFrame: number, index: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the lowest price of the specified bar.

Description

The iLow method retrieves the lowest price reached during a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

// Get the low price of the current bar for EURUSD on H1 timeframe
const currentLow = this.api.iLow("EURUSD", 60, 0);

// Get the low price from 5 bars ago
const pastLow = this.api.iLow("EURUSD", 60, 5);

// Calculate the lowest price over the last 3 bars
const lowest = Math.min(
  this.api.iLow("EURUSD", 60, 0),
  this.api.iLow("EURUSD", 60, 1),
  this.api.iLow("EURUSD", 60, 2)
);

// Check if current bar's low is a new local low
if (this.api.iLow("EURUSD", 60, 0) < this.api.iLow("EURUSD", 60, 1)) {
  console.log("New local low formed");
}

// Calculate the average low price of last 3 bars
const avgLow =
  (this.api.iLow("EURUSD", 60, 0) +
    this.api.iLow("EURUSD", 60, 1) +
    this.api.iLow("EURUSD", 60, 2)) /
  3;

// Calculate bar range
const barRange =
  this.api.iHigh("EURUSD", 60, 0) - this.api.iLow("EURUSD", 60, 0);

iHighest

Returns the index of the bar with the highest value over a specified range.

Syntax

iHighest(symbol: string, timeFrame: number, type: number, count: number, index: number): number

Parameters

symbol: The symbol to get data for
timeFrame: The timeframe of the data (in minutes)
type: The price type to compare (0=OPEN, 1=HIGH, 2=LOW, 3=CLOSE, 4=VOLUME)
count: Number of bars to search through
index: The starting bar index (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the index of the bar with the highest value. Returns -1 if no valid bar is found.

Description

The iHighest method searches for the bar with the highest value of the specified price type (open, high, low, close, or volume) within a range of bars. The search starts from the specified index and looks back for the specified number of bars. The method is useful for finding local maxima and implementing various technical analysis strategies.

Example

// Find highest high price in last 10 bars
const highestIndex = this.api.iHighest("EURUSD", 60, 1, 10, 0);
if (highestIndex !== -1) {
  const highestPrice = this.api.iHigh("EURUSD", 60, highestIndex);
  console.log(`Highest price: ${highestPrice} at index ${highestIndex}`);
}

// Find highest close in last 20 bars
const highestCloseIndex = this.api.iHighest("EURUSD", 60, 3, 20, 0);

// Find highest volume in last 5 bars
const highestVolumeIndex = this.api.iHighest("EURUSD", 60, 4, 5, 0);

// Check if current bar is highest in last 50 bars
const isNewHigh = this.api.iHighest("EURUSD", 60, 1, 50, 0) === 0;

// Find highest high starting from a specific bar
const startIndex = 10;
const lookback = 5;
const highIndex = this.api.iHighest("EURUSD", 60, 1, lookback, startIndex);

// Get highest price values for different types
const types = [0, 1, 2, 3]; // OPEN, HIGH, LOW, CLOSE
const highestValues = types.map((type) => {
  const idx = this.api.iHighest("EURUSD", 60, type, 10, 0);
  return idx !== -1 ? this.api.iHigh("EURUSD", 60, idx) : null;
});

iHigh

Returns the highest price of a bar in the specified symbol's price history.

Syntax

iHigh(Symbol: string, TimeFrame: number, index: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the highest price of the specified bar.

Description

The iHigh method retrieves the highest price reached during a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

// Get the high price of the current bar for EURUSD on H1 timeframe
const currentHigh = this.api.iHigh("EURUSD", 60, 0);

// Get the high price from 5 bars ago
const pastHigh = this.api.iHigh("EURUSD", 60, 5);

// Calculate the highest price over the last 3 bars
const highest = Math.max(
  this.api.iHigh("EURUSD", 60, 0),
  this.api.iHigh("EURUSD", 60, 1),
  this.api.iHigh("EURUSD", 60, 2)
);

// Check if current bar's high is a new local high
if (this.api.iHigh("EURUSD", 60, 0) > this.api.iHigh("EURUSD", 60, 1)) {
  console.log("New local high formed");
}

// Calculate the average high price of last 3 bars
const avgHigh =
  (this.api.iHigh("EURUSD", 60, 0) +
    this.api.iHigh("EURUSD", 60, 1) +
    this.api.iHigh("EURUSD", 60, 2)) /
  3;

iClose

Returns the close price of a bar in the specified symbol's price history.

Syntax

iClose(Symbol: string, TimeFrame: number, index: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)
index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the close price of the specified bar.

Description

The iClose method retrieves the closing price of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

// Get the close price of the current bar for EURUSD on H1 timeframe
const currentClose = this.api.iClose("EURUSD", 60, 0);

// Get the close price from 5 bars ago
const pastClose = this.api.iClose("EURUSD", 60, 5);

// Calculate the difference between current and previous bar's close prices
const closeDiff =
  this.api.iClose("EURUSD", 60, 0) - this.api.iClose("EURUSD", 60, 1);

// Check if current bar closed higher than previous bar
if (this.api.iClose("EURUSD", 60, 0) > this.api.iClose("EURUSD", 60, 1)) {
  console.log("Current bar closed higher");
}

// Calculate average closing price of last 3 bars
const avgClose =
  (this.api.iClose("EURUSD", 60, 0) +
    this.api.iClose("EURUSD", 60, 1) +
    this.api.iClose("EURUSD", 60, 2)) /
  3;

iBarShift

Returns the bar index for a specified time in the symbol's price history.

Syntax

iBarShift(symbol: string, timeframe: number, time: FTODate, exact: boolean): number

Parameters

symbol: The symbol to get data for
timeframe: The timeframe of the data (in minutes)
exact: Whether to require an exact match

Return Value

Returns a number representing the index of the bar corresponding to the specified time. Returns -1 if no matching bar is found.

Description

The iBarShift method searches for a bar with a specific opening time and returns its index. If exact is true, only bars with exactly matching times will be considered. If exact is false, the method will return the index of the nearest bar that opened before the specified time.

Example

// Find bar index for a specific time
const searchTime = this.api.createFTODate("2023-01-01T10:00:00Z");
const barIndex = this.api.iBarShift("EURUSD", 60, searchTime, true);

// Check if specific time exists in history
if (this.api.iBarShift("EURUSD", 60, searchTime, true) !== -1) {
  console.log("Bar found for the specified time");
}

// Find nearest bar before a time
const approxIndex = this.api.iBarShift("EURUSD", 60, searchTime, false);

// Get price at specific historical time
const historicalTime = this.api.createFTODate("2023-06-01T14:30:00Z");
const index = this.api.iBarShift("EURUSD", 60, historicalTime, false);
if (index !== -1) {
  const price = this.api.iClose("EURUSD", 60, index);
  console.log(`Price at ${historicalTime}: ${price}`);
}

// Find bar index for current time
const now = this.api.createFTODate(Date.now());
const currentIndex = this.api.iBarShift("EURUSD", 60, now, false);

iBars

Returns the total number of bars available in the specified symbol's price history.

Syntax

iBars(Symbol: string, TimeFrame: number): number

Parameters

Symbol: The symbol to get data for
TimeFrame: The timeframe of the data (in minutes)

Return Value

Returns a number representing the total count of available bars.

Description

The iBars method returns the total number of bars available in the price history for a given symbol and timeframe. This count includes all bars from the oldest available bar up to the current (most recent) bar. The method is useful for determining the size of the historical data and for implementing lookback periods in technical analysis.

Example

// Get total number of bars for EURUSD on H1 timeframe
const totalBars = this.api.iBars("EURUSD", 60);

// Check if enough historical data is available
const requiredBars = 100;
if (this.api.iBars("EURUSD", 60) >= requiredBars) {
  console.log("Sufficient historical data available");
}

// Calculate average over all available bars
let sum = 0;
const bars = this.api.iBars("EURUSD", 60);
for (let i = 0; i < bars; i++) {
  sum += this.api.iClose("EURUSD", 60, i);
}
const average = sum / bars;

// Find the oldest available bar's time
const oldestBarIndex = this.api.iBars("EURUSD", 60) - 1;
const oldestTime = this.api.iTime("EURUSD", 60, oldestBarIndex);

// Check data availability across timeframes
const m1Bars = this.api.iBars("EURUSD", 1);
const h1Bars = this.api.iBars("EURUSD", 60);
const d1Bars = this.api.iBars("EURUSD", 1440);

Close

Returns the closing price for a specific bar.

Syntax

Close(shift: number): number

Parameters

shift: A number representing the shift from the current bar

Return Value

Returns a number representing the closing price of the specified bar.

Description

The Close method returns the closing price of a bar at the specified shift from the current bar. The shift parameter determines which bar's closing price to return:

0: Current bar
1: Previous bar
2: Two bars ago
And so on

Example

// Get current bar's closing price
const currentClose = this.api.Close(0);

// Get previous bar's closing price
const previousClose = this.api.Close(1);

// Calculate price change
const priceChange = this.api.Close(0) - this.api.Close(1);
console.log(`Price changed by ${priceChange} points`);

// Get closing prices for last 3 bars
for (let i = 0; i < 3; i++) {
  const closePrice = this.api.Close(i);
  console.log(`Bar -${i} close price: ${closePrice}`);
}

High

Returns the highest price for a specific bar.

Syntax

High(shift: number): number

Parameters

shift: A number representing the shift from the current bar

Return Value

Returns a number representing the highest price reached during the specified bar.

Description

The High method returns the highest price reached during a bar at the specified shift from the current bar. The shift parameter determines which bar's high price to return:

0: Current bar
1: Previous bar
2: Two bars ago
And so on

Example

// Get current bar's high price
const currentHigh = this.api.High(0);

// Get previous bar's high price
const previousHigh = this.api.High(1);

// Find highest price over last 3 bars
let highestPrice = this.api.High(0);
for (let i = 1; i < 3; i++) {
  const high = this.api.High(i);
  if (high > highestPrice) {
    highestPrice = high;
  }
}
console.log(`Highest price in last 3 bars: ${highestPrice}`);

// Check if current bar made new high
if (this.api.High(0) > this.api.High(1)) {
  console.log("New high formed on current bar");
}

Low

Returns the lowest price for a specific bar.

Syntax

Low(shift: number): number

Parameters

shift: A number representing the shift from the current bar

Return Value

Returns a number representing the lowest price reached during the specified bar.

Description

The Low method returns the lowest price reached during a bar at the specified shift from the current bar. The shift parameter determines which bar's low price to return:

0: Current bar
1: Previous bar
2: Two bars ago
And so on

Example

// Get current bar's low price
const currentLow = this.api.Low(0);

// Get previous bar's low price
const previousLow = this.api.Low(1);

// Find lowest price over last 3 bars
let lowestPrice = this.api.Low(0);
for (let i = 1; i < 3; i++) {
  const low = this.api.Low(i);
  if (low < lowestPrice) {
    lowestPrice = low;
  }
}
console.log(`Lowest price in last 3 bars: ${lowestPrice}`);

// Check if current bar made new low
if (this.api.Low(0) < this.api.Low(1)) {
  console.log("New low formed on current bar");
}

Open

Returns the opening price for a specific bar.

Syntax

Open(shift: number): number

Parameters

shift: A number representing the shift from the current bar

Return Value

Returns a number representing the opening price of the specified bar.

Description

The Open method returns the opening price of a bar at the specified shift from the current bar. The shift parameter determines which bar's opening price to return:

0: Current bar
1: Previous bar
2: Two bars ago
And so on

Example

// Get current bar's opening price
const currentOpen = this.api.Open(0);

// Get previous bar's opening price
const previousOpen = this.api.Open(1);

// Compare current and previous opening prices
const openDiff = this.api.Open(0) - this.api.Open(1);
console.log(
  `Price opened ${openDiff > 0 ? "higher" : "lower"} than previous bar`
);

// Get opening prices for last 3 bars
for (let i = 0; i < 3; i++) {
  const openPrice = this.api.Open(i);
  console.log(`Bar -${i} open price: ${openPrice}`);
}

Bars

Returns the total number of bars.

Syntax

Bars(): number

Return Value

Returns a number representing the total count of available bars.

Description

The Bars method returns the total number of price bars available in the current symbol's history. This count includes all bars from the earliest available data point up to and including the current bar.

Example

// Get total number of bars
const totalBars = this.api.Bars();
console.log(`Total available bars: ${totalBars}`);

// Check if enough history for analysis
const requiredBars = 20;
if (this.api.Bars() >= requiredBars) {
  // Perform analysis requiring 20 bars of history
}

// Process last 10 bars (if available)
const barsToProcess = Math.min(10, this.api.Bars());
for (let i = 0; i < barsToProcess; i++) {
  const close = this.api.Close(i);
  console.log(`Bar -${i} close price: ${close}`);
}

// Calculate valid shift range
const maxShift = this.api.Bars() - 1;
console.log(`Valid shift range: 0 to ${maxShift}`);

Access to Objects

This section provides functions to manage and interact with chart objects. These functions allow you to create, remove, and modify objects on a chart.

Available Functions

Click on any function name to view its detailed documentation.

RemoveAllObjects

Removes all chart objects of a specified type.

Syntax

RemoveAllObjects(objType: TObjectType, isStatic: boolean = false): void

Parameters

Parameter

Type

Description

objType

The type of objects to remove

isStatic

boolean

Optional. Whether to remove static objects (default: false)

Description

The RemoveAllObjects method removes all chart objects of a specified type from the chart. This is useful for cleaning up multiple objects at once. The method can remove either regular objects or static objects, depending on the isStatic parameter.

Example

// Remove all trend lines
this.api.RemoveAllObjects(TObjectType.TREND_LINE);

// Remove all static text labels
this.api.RemoveAllObjects(TObjectType.TEXT, true);

// Clean up all drawing objects
const objectTypes = [
  TObjectType.TREND_LINE,
  TObjectType.RECTANGLE,
  TObjectType.TRIANGLE,
  TObjectType.TEXT,
];

for (const type of objectTypes) {
  this.api.RemoveAllObjects(type);
}

// Remove objects and log count
const beforeCount = this.api.GetObjectCount();
this.api.RemoveAllObjects(TObjectType.RECTANGLE);
const afterCount = this.api.GetObjectCount();
console.log(`Removed ${beforeCount - afterCount} rectangle objects`);

DoesChartObjectExist

Checks if a chart object with the specified name exists.

Syntax

DoesChartObjectExist(uniqueObjectName: string, isStatic: boolean = false): boolean

Parameters

Parameter

Type

Description

uniqueObjectName

string

The unique name of the object to check

isStatic

boolean

Optional. Whether to check static objects (default: false)

Return Value

Returns a boolean indicating whether the object exists (true) or not (false).

Description

The DoesChartObjectExist method checks for the existence of a chart object with the specified name. It can check for both regular and static objects, depending on the isStatic parameter.

Example

// Check if object exists before using it
if (this.api.DoesChartObjectExist("MyTrendLine")) {
  // Object exists, safe to use
  this.api.SetObjectProperty("MyTrendLine", ObjProp.OBJPROP_COLOR, 0xff0000);
} else {
  console.log("Object not found");
}

// Check static object
const staticExists = this.api.DoesChartObjectExist("MyStaticLabel", true);
console.log(`Static object exists: ${staticExists}`);

// Create object only if it doesn't exist
const objectName = "UniqueObject";
if (!this.api.DoesChartObjectExist(objectName)) {
  this.api.СreateChartObject(
    objectName,
    TObjectType.TEXT,
    0,
    this.api.createFTODate(Date.now()),
    1.2345
  );
}

// Remove object if it exists
if (this.api.DoesChartObjectExist("OldObject")) {
  this.api.RemoveChartObject("OldObject");
}

GetObjectText

Returns the text content of a chart object.

Syntax

GetObjectText(name: string, isStatic: boolean = false): string

Parameters

Parameter

Type

Description

name

string

The name of the object

isStatic

boolean

Optional. Whether to look in static objects (default: false)

Return Value

Returns a string containing the object's text content.

Description

The GetObjectText method retrieves the text content of a specified chart object. This is primarily used with text-based objects like labels, but can also be used with other objects that have text properties.

Example

// Get text from a text label
const labelText = this.api.GetObjectText('MyLabel')
console.log(`Label text: ${labelText}`)

// Get text from a static label
const staticText = this.api.GetObjectText('MyStaticLabel', true)
console.log(`Static label text: ${staticText}`)

// List all text objects with their content
const count = this.api.GetObjectCount()
for (let i = 0; i < count; i++) {
    const name = this.api.GetObjectName(i)
    if (this.api.GetObjectType(name) === TObjectType.TEXT) {
        const text = this.api.GetObjectText(name)
        console.log(`Text object ${name}: "${text}"`)
    }
}

// Error handling example
try {
    const text = this.api.GetObjectText('NonExistentObject')
} catch (error) {
    console.log('Error getting object text:', error.message)
}

FTO Indicators Docs

Overview

Overview

📌 What You’ll Find Here

👨‍💻 Who is This For?

🚀 Ready to Begin?

Set up indicator

Upload indicator to FTO

Tutorial: Create indicator with Cursor IDE

Introduction

Step 1: Install Cursor and set up the project

Step 2: Apply Cursor Rules

Step 3: Upload FTO indicator documentation to Cursor

Step 4: Getting familiar with Cursor

Step 5: Start building

Recommendations

Set up Cursor Rules

Tutorial: Open and upload indicator

Tutorial: Moving Average

Indicator structure

Indicator parameters

Buffers setup

Other settings

Indicator's main function

Changing parameters

Download indicator examples

Indicators

Indicator structure

Description of the structure

Init

What is it?

Syntax

What Happens in Init

Example

Why It Matters

Pro Tip

Calculate

What is it?

How It Works

Example Explained

What This Code Does

In Short

OnParamsChange

What is it?

Syntax

When and Why to Use It

Example Use Case

Important Notes

In Simple Terms

Done

What is it?

Syntax

When and Why to Use It

Example

Important Notes

OnShow

What is it?

Syntax

When and Why to Use It

Example

Important Notes

OnHide

What is it?

Syntax

When and Why to Use It

Example

Important Notes

Parameters

What Are Parameters?

How It Works

Common Parameter Types

Example

Key Rules

TOptValue

TOptValue_number

What Is It?

When to Use

Syntax

Example

Notes

What Happens in `Init`

2. Create the Buffer in `Init()`