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

To to use our custom indicator API, you need to first download indicator example. You can find some of the examples here or download the suggested example file below.

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.

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

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

If you want to know how to upload your indicator to FTO, you can go to upload guide.

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

• Get started with setting up your development environment and creating your first indicator using a simple Moving Average example.

• Understand the lifecycle of an indicator through core functions like Init, Calculate, Done, and more.

• Learn how to create and manage visible buffers to display your indicator’s values on the chart.

• Understand how to retrieve bar data, price arrays, and time series to power your custom logic.

• Customize the behavior and appearance of indicators through parameters and configuration blocks.

• Use external inputs to make your indicators dynamic and easily customizable by users.

• Retrieve metadata about the active instrument, such as symbol name, point size, and tick value.

• Use the FTODate structure to manage time-based logic and align calculations with bar timestamps.

• Explore helper functions and additional features available to streamline development.

👨‍💻 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?

Start with the guide and move on to the to see how it all works in action.

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.

Download and install the Cursor editor: https://www.cursor.com/downloads, while installing make sure to check all the checkmarks (Picture #1)

Then, you have to install Node.js if you don't already have it. Use the link below. https://nodejs.org/en

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.

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

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).

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 run 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).

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.

Step 1: Install Cursor and set up the project

How to install Cursor and set up the project is described in guide. If you don’t yet know how to set up your environment to work with the FTO API for indicators, that is also covered in the same guide.

Step 2: Apply Cursor Rules

The feature in Cursor IDE allows users to define custom guidelines or behaviors that the AI should follow when generating code. By setting up rules that describe how indicators work in FTO, you can effectively teach Cursor the context it needs to produce accurate and consistent indicators.

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).

1. Scroll down until you see Docs (Picture #6)

1. 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.

To become more familiar with how to use this added documentation in your requests to Cursor, go to the section below.

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

Before we begin writing the indicator, it is expected that you are familiar with how to set up the environment to access the FTO Indicator API. If not, please read guide first before continuing.

For this example, we will ask Cursor to implement the On Balance Volume (OBV) indicator for us. In this guide, we will start with an empty file, but for future indicator implementations, you can use some of our indicator foundations provided in .

In the request to create the OBV indicator for us, I included the FTO documentation for and added the discussed earlier. In the screenshot, you can see the sections of the documentation it decided to use (Picture #11).

In the result, we got code below

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

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

So in the end, we got a proper indicator with just two simple requests by setting up Cursor properly and providing it with and documentation for context.

Recommendations

For Cursor to use the documentation that we provided in we need to do the following:

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

In the drop-down menu, select FTO Indicator documentation, which we added earlier in (Picture#15)

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)

The feature in Cursor IDE allows users to define custom guidelines or behaviors that the AI should follow when generating code. By setting up rules that describe how indicators work in FTO, you can effectively teach Cursor the context it needs to produce accurate and consistent indicators.

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

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

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

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.

public OnParamsChange(): void {
    // Example: Reposition a line or label when "VShift" is changed
    
    this.UpdateShiftedLine(this.VShift.value) // custom method UpdateShiftedLine
}

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.

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

Main methods of each indicator are Init and Calculate, Init is called once when the indicator is created, and Calculate is called on each tick. Other methods are optional and can be used to add additional logic to the indicator.

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

• OnParamsChange

• Done

• OnHide

• OnShow

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

A custom indicator is built by extending the IndicatorImplementation class, provided by the forex-tester-custom-indicator-api library. You can find this implementation in the source code of the Moving Average example described in the Setup and Installation section.

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

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

Indicator parameters

These parameters can be of different types, they are determined by the TOptValue class, and they will be displayed in the indicator addition/editing window

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...
    }

For this, they need to be registered in the Init function.

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...
}

You can see the methods for registering parameters in the external parameters definition

Buffers setup

Buffers are used to store and display indicator values on the chart.

public SSMA!: TIndexBuffer
private SMA!: TIndexBuffer

They need to be declared with all class fields and initialized in the Init function

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);

Each registered buffer can be configured

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

Also, other methods for configuring the indicator are used in the Init function. To ensure the indicator recalculates on each tick, use the function RecalculateMeAlways. If this setting is not used, each buffer index will be calculated only once to save resources, but some indicators may be calculated inaccurately. If the calculations do not heavily load the processor, we recommend always using it.

Set the indicator name, which will be displayed in the indicator settings window and in the context menu: IndicatorShortName.

We want the Moving Average indicator to be displayed on the main chart, so we use SetOutputWindow.

Using this call, specify that values equal to 0 will not be drawn on the chart: SetEmptyValue.

Indicator's main function

The main function of the indicator is the Calculate function, where the indicator values are calculated on each tick.

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

To add custom logic after changing the indicator parameters, we use the OnParamsChange method. In Moving average, it is applied to the horizontal shift of the indicator. This method is often used to work with custom objects or to shift the indicator.

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

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

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

What This Code Does

1. Checks if there are enough bars to calculate the moving average. (We need Period number of candles; otherwise, we skip.)

2. Calculates a Moving Average value using GetMA().

3. Stores the result in the SMA buffer, which is used for drawing on the chart.

4. 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.

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

Key Rules

• Only -based parameters are configurable

• You must register each parameter inside the method using

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

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.

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.

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

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

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

public Done(): void {
    // Draw a horizontal line based on final SMA value
    const lastIndex = 0
    const finalValue = this.SMA.getValue(lastIndex)
    
    // custom method CreateHorizontalLine
    this.api.CreateHorizontalLine("FinalSMA", finalValue, "red") 
}

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.

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.

public SSMA!: TIndexBuffer;

2. Create the Buffer in Init()

Create the buffer instance using the CreateIndexBuffer() method.

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

3. Register the Number of Buffers

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

this.api.IndicatorBuffers(1);

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:

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

5. Configure the Buffer

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

this.api.SetIndexLabel(0, "SSMA"); // Label shown in the legend
this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000"); // Style
this.api.SetIndexDrawBegin(0, this.Period.value - 1 + this.Shift.value); // Starting bar

Full Example

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

export default class MovingAverage extends IndicatorImplementation {
  // Declare parameters as class fields
  public Period!: TOptValue_number;
  public Shift!: TOptValue_number;
  public SSMA!: TIndexBuffer;

  public Init(): void {
    // Create parameters
    this.Period = this.api.createTOptValue_number(8);
    this.Shift = this.api.createTOptValue_number(0);

    // Create and configure the buffer
    this.SSMA = this.api.CreateIndexBuffer();
    this.api.IndicatorBuffers(1);
    this.api.SetIndexBuffer(0, this.SSMA);
    this.api.SetIndexLabel(0, "SSMA");
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
    this.api.SetIndexDrawBegin(0, this.Period.value - 1 + this.Shift.value);
  }
}

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.

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

// Declare the parameter in the class fields
public MyParameter!: TOptValue_number;

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

    // Register the parameter
    this.api.RegOption("MyParameter", TOptionType.INTEGER, this.MyParameter);
}

Example

export default class MovingAverage extends IndicatorImplementation {
  public Period!: TOptValue_number;
  public Shift!: TOptValue_number;
  public MAtype!: TOptValue_number;
  public ApplyToPrice!: TOptValue_number;
  public VShift!: TOptValue_number;

  public Init(): void {
    // Create the parameter
    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);

    // Register the parameter
    this.api.RegOption("Period", TOptionType.INTEGER, this.Period);
    this.api.RegOption("Shift", TOptionType.INTEGER, this.Shift);
    this.api.RegOption("MAtype", TOptionType.INTEGER, this.MAtype);
    this.api.RegOption("ApplyToPrice", TOptionType.INTEGER, this.ApplyToPrice);
    this.api.RegOption("VShift", TOptionType.INTEGER, this.VShift);
  }
}

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

• After creating a parameter, don’t forget to register it using this.RegOption in the Init method.

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

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

Returns an FTODate object representing the opening time of the specified bar.

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));
}

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");
}

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;

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

• Don't forget to register string parameters using this.RegOption inside the Init method.

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

• Access the value with this.MyFlag.value.

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");
}

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

• Don't forget to register string parameters using this.RegOption inside the Init method.

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

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

Syntax

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

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

• : Gets the volume value of the current bar.

• : Retrieves volume value from a specific bar index.

• : Retrieves the timestamp of a specific bar.

• : Retrieves the open price of a specific bar.

• : Finds the lowest value over a range of bars.

• : Gets the low price of a specific bar.

• : Finds the highest value over a range of bars.

• : Gets the high price of a specific bar.

• : Retrieves the close price of a specific bar.

• : Finds the index of a bar by time.

• : Returns the number of bars between two dates.

• : Gets the close price of the current bar.

• : Gets the high price of the current bar.

• : Gets the low price of the current bar.

• : Gets the open price of the current bar.

• : Returns the total number of bars.

• : Gets the time of the current bar.

Click on any function name to view its detailed documentation.

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

Syntax

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

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

Syntax

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

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

Syntax

Parameters

• symbol: The symbol to get data for

• timeframe: The timeframe of the data (in minutes)

• time: The time to search for

• 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

Returns the closing price for a specific bar.

Syntax

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

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");
}

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}`);

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;
});

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);

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");
}

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;

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}`);
}

Returns the time for a specific bar.

Syntax

Time(shift: number, timeZoneMode?: TimeZoneMode): FTODate

Parameters

• shift: A number representing the shift from the current bar

• timeZoneMode: Optional. Default value is project timezone. A TimeZoneMode enum value representing the timezone mode to use for the returned date

Return Value

Returns an FTODate object representing the bar's opening time.

Description

The Time method returns the opening time of a bar at the specified shift from the current bar. The time is returned as an FTODate object, which provides various date/time manipulation capabilities. The shift parameter determines which bar's time to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

The timeZoneMode parameter allows you to specify how the time should be interpreted:

• TimeZoneMode.PROJECT: Returns time in the project's timezone (default)

• TimeZoneMode.UTC: Returns time in UTC

Example

// Get current bar's time in project timezone
const currentTime = this.api.Time(0);
console.log(`Current bar time: ${currentTime.toString()}`);

// Get current bar's time in UTC
const currentTimeUTC = this.api.Time(0, TimeZoneMode.UTC);
console.log(`Current bar UTC time: ${currentTimeUTC.toString()}`);

// Get previous bar's time
const previousTime = this.api.Time(1);

// Calculate time difference between bars
const timeDiff = currentTime.getTime() - previousTime.getTime();
console.log(`Time between bars: ${timeDiff} milliseconds`);

// Get opening times for last 3 bars
for (let i = 0; i < 3; i++) {
  const time = this.api.Time(i);
  console.log(`Bar -${i} opened at: ${time.toString()}`);
}

Returns the type of a chart object.

Syntax

GetObjectType(name: string, isStatic: boolean = false): TObjectType

Parameters

Return Value

Returns a TObjectType enum value representing the object's type.

Description

The GetObjectType method retrieves the type of a specified chart object. The type is returned as a TObjectType enumeration value.

Example

// Get type of a specific object
const type = this.api.GetObjectType("MyTrendLine");
console.log(`Object type: ${type}`);

// Check object type
if (this.api.GetObjectType("MyLine") === TObjectType.TREND_LINE) {
  console.log("Object is a trend line");
}

// List all objects with their types
const count = this.api.GetObjectCount();
for (let i = 0; i < count; i++) {
  const name = this.api.GetObjectName(i);
  const type = this.api.GetObjectType(name);
  console.log(`Object ${name} is of type ${type}`);
}

// Check static object type
const staticType = this.api.GetObjectType("MyStaticLine", true);
if (staticType === TObjectType.V_LINE) {
  console.log("Static object is a vertical line");
}

Returns the text content of a chart object.

Syntax

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

Parameters

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)
}

Creates a new chart object with specified parameters.

Syntax

СreateChartObject(
    name: string,
    objType: TObjectType,
    window: number,
    ftoDate1: FTODate,
    price1: number,
    ftoDate2?: FTODate,
    price2?: number,
    ftoDate3?: FTODate,
    price3?: number,
    isStatic?: boolean
): boolean

Parameters

Return Value

Returns boolean - true if the object was created successfully, false otherwise.

Description

The СreateChartObject method creates a new chart object with the specified parameters. Different object types require different sets of coordinates

Example

// Create a trend line
const trendLine = this.api.СreateChartObject(
  "MyTrendLine",
  TObjectType.TREND_LINE,
  0,
  this.api.createFTODate(1641024000000), // Jan 1, 2022
  1.2,
  this.api.createFTODate(1641110400000), // Jan 2, 2022
  1.21
);

// Create a text label
const textLabel = this.api.СreateChartObject(
  "MyLabel",
  TObjectType.TEXT,
  0,
  this.api.createFTODate(1641024000000),
  1.2
);

// Create a triangle
const triangle = this.api.СreateChartObject(
  "MyTriangle",
  TObjectType.TRIANGLE,
  0,
  this.api.createFTODate(1641024000000),
  1.2,
  this.api.createFTODate(1641110400000),
  1.21,
  this.api.createFTODate(1641196800000),
  1.205
);

Removes all chart objects of a specified type.

Syntax

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

Parameters

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`);

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

• : Creates a new chart object.

• : Removes all objects from a chart.

• : Checks if a chart object exists.

• : Retrieves the text of a chart object.

• : Retrieves the type of a chart object.

• : Retrieves the name of a chart object.

• : Retrieves the count of objects on a chart.

• : Removes a specific chart object.

• : Sets the text of a chart object.

• : Retrieves a property of a chart object.

• : Sets a property of a chart object.

Click on any function name to view its detailed documentation.

This section provides functions to configure and customize indicators. These functions allow you to set styles, buffers, and other properties of indicators.

Available Functions

• : Adds a level to an indicator.

• : Sets the style of an indicator index.

• : Creates an index buffer with arguments.

• : Sets the output window for an indicator.

• : Sets the number of digits for an indicator.

• : Retrieves the number of counted bars.

• : Sets the buffer shift for an indicator.

• : Retrieves information about a buffer.

• : Sets the draw begin index for an indicator.

• : Retrieves the minimum value of a buffer.

• : Retrieves the count of a buffer.

• : Retrieves the maximum value of a buffer.

• : Sets a value in a buffer.

• : Retrieves a value from a buffer.

• : Sets the label for an indicator index.

• : Sets the symbol for an indicator index.

• : Sets the visibility of an indicator index.

• : Sets the buffer for an indicator index.

• : Creates an index buffer.

• : Manages indicator buffers.

• : Sets the value of a level.

• : Sets the indicator to always recalculate.

• : Sets the back offset for calculation.

• : Sets fixed min and max values for an indicator.

• : Sets the ID key for an indicator.

• : Sets the empty value for an indicator.

• : Sets the short name for an indicator.

Click on any function name to view its detailed documentation.

Adds a horizontal level line to the indicator.

Syntax

Parameters

• value - A number representing the Y-value where the level should be drawn.

• style - A value from the enum specifying the line style.

• width - A number representing the line width in pixels.

• color - A string hex color value for the level line.

• opacity - A number between 0 and 1 representing the opacity of the line.

Return Value

This method does not return a value.

Description

The AddLevel method adds a horizontal level line to the indicator window. This is commonly used for indicators like RSI or Stochastic to mark overbought and oversold levels.

See for available line styles

Example

Removes a chart object with the specified name.

Syntax

Parameters

Description

The RemoveChartObject method removes a specified chart object from the chart. The object is identified by its unique name. If the object is static (persists across all timeframes), set the isStatic parameter to true.

Example

Returns the total number of chart objects.

Syntax

Parameters

Return Value

Returns a number representing the total count of chart objects.

Description

The GetObjectCount method returns the total number of objects in the chart. It can count either regular objects or static objects, depending on the isStatic parameter.

Example

Checks if a chart object with the specified name exists.

Syntax

Parameters

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

Retrieves a property value from a chart object.

Syntax

Parameters

Return Value

Returns either a number or string depending on the property type.

Description

The GetObjectProperty method retrieves a property value from a specified chart object. It can return either numeric or string properties depending on the property identifier provided.

See for a complete list of available object properties.

Example

Sets a property value for a chart object.

Syntax

Parameters

Return Value

Returns boolean - true if the property was set successfully, false otherwise.

Description

The SetObjectProperty method sets a property value for a specified chart object. It can handle both numeric and string properties, and automatically converts time values from FTODate to the internal format.

Example

Sets the text content and formatting for a chart object.

Syntax

Parameters

Return Value

Returns boolean - true if the text was set successfully, false otherwise.

Description

The SetObjectText method sets the text content and formatting properties for a specified chart object. This method is primarily used with text-based objects like labels, but can also be used with other objects that support text properties.

Example

Returns the name of a chart object by its index.

Syntax

Parameters

Return Value

Returns a string representing the object's name.

Description

The GetObjectName method retrieves the name of a chart object based on its index in the list of objects. Objects are indexed from 0 to GetObjectCount() - 1. This method is useful for iterating through all objects on a chart.

Example

Sets the visual style for a buffer.

Syntax

Parameters

• bufferIndex - A number representing the index of the buffer to style.

• type - A value from the enum specifying how to draw the buffer.

• style - A value from the enum specifying the line style.

• width - A number representing the line width in pixels.

• clr - A string hex color value for the buffer.

• isVisible - (Optional) A boolean indicating whether the buffer should be visible.

Return Value

This method does not return a value.

Description

The SetIndexStyle method sets the visual appearance of a buffer on the chart. This includes the drawing style (line, histogram, etc.), line style (solid, dashed, etc.), width, color, and visibility.

See for available drawing styles, for line styles

Example

Creates a new buffer with specified display properties.

Syntax

Parameters

• index - A number representing the buffer index.

• aLabel - A string containing the label for the buffer.

• drawStyle - A value from the enum specifying how to draw the buffer.

• style - A value from the enum specifying the line style.

• width - A number representing the line width in pixels.

• color - A string hex color value for the buffer.

Return Value

Returns a TIndexBuffer object that can be used to store indicator values.

Description

The CreateIndexBufferWithArgs method creates a new buffer with specified display properties and assigns it to the given index. This is a convenient way to create and configure a buffer in a single call.

Example

Sets the starting bar for drawing a buffer.

Syntax

Parameters

• bufferIndex - A number representing the index of the buffer.

• paintFrom - A number representing the bar index to start drawing from.

Return Value

This method does not return a value.

Description

The SetIndexDrawBegin method sets the starting bar for drawing a buffer. This is useful for indicators that require a certain number of bars to initialize before they can produce meaningful values. By setting the draw begin point, you can prevent the indicator from displaying potentially misleading values during its initialization period.

Example

Sets the window where the indicator will be displayed.

Syntax

Parameters

• outputWindow - A value from the enum specifying where the indicator should be displayed.

Return Value

This method does not return a value.

Description

The SetOutputWindow method determines where the indicator will be displayed on the chart. Indicators can be displayed either in the main chart window or in a separate window below the main chart.

See for the complete list of available window types.

Example

Finds the minimum value in a buffer within a specified range.

Syntax

Parameters

• buffer - A number representing the buffer index.

• index1 - A number representing the start of the range.

• index2 - A number representing the end of the range.

Return Value

Returns a number representing the minimum value found in the specified range of the buffer.

Description

The GetBufferMin method finds the minimum value in a buffer within the range specified by index1 and index2. This can be useful for scaling or normalizing indicator values.

Example

Retrieves information about a buffer.

Syntax

Parameters

• index - A number representing the buffer index.

Return Value

Returns a object containing information about the buffer.

Description

The GetBufferInfo method retrieves information about a buffer, such as its label, drawing style, line style, width, color, and visibility. This can be useful for dynamically adjusting buffer properties based on the current state.

See for more information about the buffer information structure.

Example

Sets the number of decimal places for indicator values.

Syntax

Parameters

• digits - A number representing the number of decimal digits to display for indicator values.

Return Value

This method does not return a value.

Description

The IndicatorDigits method sets the number of decimal places that will be used when displaying indicator values. This affects how values are formatted in tooltips, indicator configuration panels, and other UI elements.

Setting the appropriate number of decimal places is important for readability and precision. For example, oscillators that range between 0 and 100 might use 1 or 2 decimal places, while price-based indicators might need 4 or 5 decimal places for currency pairs.

Example

Sets the horizontal shift for a buffer.

Syntax

Parameters

• bufferIndex - A number representing the index of the buffer.

• shift - A number representing the number of bars to shift the buffer.

Return Value

This method does not return a value.

Description

The SetBufferShift method sets the horizontal shift for a buffer. This allows you to offset the display of the buffer by a specified number of bars. Positive values shift the buffer to the right (into the future), while negative values shift it to the left (into the past).

Example

Finds the maximum value in a buffer within a specified range.

Syntax

Parameters

• buffer - A number representing the buffer index.

• index1 - A number representing the start of the range.

• index2 - A number representing the end of the range.

Return Value

Returns a number representing the maximum value found in the specified range of the buffer.

Description

The GetBufferMax method finds the maximum value in a buffer within the range specified by index1 and index2. This can be useful for scaling or normalizing indicator values.

Example

Sets the visibility of a buffer.

Syntax

Parameters

• index - A number representing the index of the buffer.

• isVisible - A boolean indicating whether the buffer should be visible.

Return Value

This method does not return a value.

Description

The SetIndexVisibility method sets whether a buffer should be visible on the chart. This can be used to hide buffers that are used for calculations but should not be displayed to the user.

Example