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

Example

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 inside the method.

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

• Access the value with this.MyFlag.value.

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.

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

Returns the number of bars that have already been calculated in previous calls.

Syntax

Counted_bars(): number

Parameters

This method does not take any parameters.

Return Value

Returns a number representing the count of bars that have already been calculated.

Description

The Counted_bars method returns the number of bars that have already been processed in previous calls to the indicator's calculation function. This is useful for optimization, as it allows the indicator to only calculate values for new bars rather than recalculating all bars.

Example

If strategies are the brain and hands of trading, indicators are the eyes.They don’t open or close trades for you, but they help you see the market more clearly — drawing lines, showing averages, or highlighting trends. Think of them as your personal set of night-vision goggles: they light up what’s happening on the chart so you can decide what to do next (or let your strategy decide).In short:

• Strategies = decision-makers (they trade)

• Indicators = signal-givers (they show the picture)

With indicators, you can track momentum, spot entry points, or just make your charts look way cooler. Ready to add some trading super-vision? Let’s dive in!\

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.

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

First things first — you’ll need Cursor IDE.

If you don’t have it yet, go ahead and install it (full setup guide is right ).

Once Cursor is ready, set up your project.

If you’re new to the FTO Indicator API, don’t worry — that same guide also covers how to prep your environment so you’re good to go.

This guide shows you how to prepare your environment so you can start writing your own custom indicator for FTO.

To use the custom indicator API, you’ll first need an example to work from. Don’t worry, we’ve got you covered — you can either browse a few ready-made examples here, or just grab the suggested starter file below. Think of it as your “Hello World” for indicators.

Why start with an example?

Jumping into custom indicators from scratch can feel like walking into a movie halfway through — you’ll miss the setup.

That’s why we suggest starting with a ready-made example:

• You see the basic structure in action

• You avoid silly mistakes on the first steps

• You can tweak and play instead of reinventing the wheel

It’s faster, safer, and way more fun. Once you’re comfortable, you can always build your own indicator logic from scratch.

Open and Set Things Up

Open the example project in Cursor (or any IDE you like — but honestly, Cursor makes life easier).

Next, click the little terminal icon (see Picture #1) — it’s that black box where all the behind-the-scenes magic happens.

Now run:

Once the dependencies are in place, it’s time to build your project.

Pop open your terminal (still in that same black box of magic) and run:

This will compile your indicator into a nice, ready-to-use .js file.

Think of it as baking the dough you just mixed — after this step, you’ll actually have bread instead of just flour and water.

If everything goes well, you should see a fresh build appear in your dist folder. That’s your indicator, ready for action!

After building, you’ll see a fresh file named my-indicator-project.js appear in your dist folder. That’s your ready-to-use indicator, hot and shiny.

Curious about the next step? Head over to the to learn how to bring your indicator into FTO and watch it in action on a chart.

Introduction

Want to build your own indicator from scratch? You’re in the right place.

This tutorial walks you through creating a custom indicator using Cursor IDE.

Don’t worry if it sounds complicated — we’ll go step by step, with screenshots and examples. By the end, you’ll have your very own indicator running in FTO, powered by Cursor’s AI.

f you’ve already run the npm run build command and everything went smoothly, you should now have a file called my-indicator-project.js sitting inside your dist folder. That’s the one we’re going to upload.

Open FTO, head over to your project, and in the Indicators tab hit Upload Indicator. Then just drag-and-drop your .js file into the upload area or select it manually (see Picture #1 and Picture #2).

Pro tip: Treat this file like your golden ticket — once it’s in FTO, you’ll finally get to see your indicator in action.

After uploading, your indicator will show up in the “My Indicators” dropdown menu (see Picture #3).

From here, just pick it, hit Apply, and watch it come alive on your chart.

Pro tip: If you don’t see it right away, double-check that you uploaded the .js file from your dist folder — that’s the only one FTO recognizes.

To open the Cursor AI panel, press Ctrl+L or click the icon in the top right corner of the Cursor IDE (see Picture #1).

This will open the chat interface — your command center for talking to the AI (yes, it listens — and it’s surprisingly helpful). In Cursor version 1.3.9, there are three available modes: Agent, Ask, and Background (see Picture #2).

Choosing Your AI Mode

Each one plays a different role in your coding adventure.

Agent Mode

Think of it as your AI pair programmer. It sees your project, suggests edits, and you can thumbs-up or thumbs-down its ideas like a benevolent overlord.

Ask Mode

Your Q&A corner. Need to know how a moving average works? Why your code screams in red? Ask away.

Background Mode

This one works behind the scenes. Cursor quietly watches your code and offers suggestions only when relevant. It won’t interrupt you — unless it has something genuinely useful to say. The real magic? You can feed Cursor extra context from your files or docs — like giving it caffeine for smarter replies.

For now, select Agent Mode.

Choosing the Right Brain for the Job

Next to the mode selector, you’ll also see an AI model dropdown. Just leave it on Auto for now — let Cursor pick the right brain for the job (see Picture #3).

Quick warning:

Skip Gemini. Cursor and Gemini aren’t exactly BFFs — context issues, buggy behavior, you name it. If you do want to pick a model manually, stick to Claude or OpenAI. Cursor was trained to jam with them, and the experience is smooth.

Once you’ve taken this quick tour, you’re all set to dive into building your first custom indicator. Next step — sleeves up (real or metaphorical) and let’s create something awesome for 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 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).

Cursor has a Rules feature — basically a way to teach the AI how you want it to behave when generating code.

Think of it as house rules for a guest: “shoes off, fridge is fair game, don’t touch the cat.”

By setting up rules that explain how indicators work in FTO, you’re giving Cursor the context it needs to create consistent, accurate code. No more random guesses — just well-informed suggestions.

To set global rules:

1. Click the Settings icon (see Picture #1)

1. From the Settings menu, click on Rules (see Picture #2).

This is where you’ll drop in the custom guidelines that will teach Cursor how to behave when working with your indicators.

Think of this as setting the ground rules before starting a board game — once everyone knows the rules, things run smoother (and there’s less arguing).\

1. In the User Rules field (see Picture #3), paste in the contents of the file called Rules.txt.

That’s your playbook — the set of instructions that teaches Cursor how to “think” when working with indicators in FTO.

Pro tip: It’s like giving your AI a cheat sheet before the test. The more detail you put in here, the less Cursor will bother you later with questions.

Now that Cursor knows the rules, let’s give it the actual manual.

By uploading the official FTO indicator documentation, Cursor will have a knowledge base it can use to generate better code for you. No more guessing, no more “hmm, what does this method do?” — Cursor will actually know.

Here’s how to do it:

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

   Think of this step as handing Cursor the instruction booklet — without it, it’s like trying to build IKEA furniture without the tiny hex key.

2. Next stop: Features.

Think of it as the secret drawer where all the cool settings live. Click on Features in the left sidebar — that’s where you’ll find everything you need to feed Cursor the right docs. (See Picture #2.)

1. Almost there! Scroll down the Features page until you spot the Docs section — that’s your gateway to feeding Cursor some serious brain food. (See Picture #3.)

1. Time to feed Cursor some serious knowledge! Hit the “Add new doc” button and paste this link: https://fto-2.gitbook.io/fto-indicators-docs.

   This tells Cursor, “Here’s everything you need to know about indicators in FTO — study up!” (See Picture #4.)

Once you add the link, Cursor will take a moment to index the docs. Grab a coffee (or stretch your fingers) while it works.

After that, Cursor will have all the smarts it needs to reference the documentation and help you craft your shiny new indicators like a pro.

1. Download and Install Cursor

First, grab the Cursor editor from cursor.com/downloads.

Run the installer and, when it asks about options, tick all the checkboxes — trust us, you’ll want those extras (see Picture #1).

Think of it like ordering pizza with all the toppings. The more boxes you check, the more powerful Cursor becomes.

2. Install Node.js and Get the Example Project

Next up, you’ll need Node.js. If you don’t already have it, grab it here: .

Run the installer and follow the steps — nothing fancy.

Once Node.js is ready, download the indicator example archive we’ve provided below and extract it to a convenient spot. Desktop, Downloads — anywhere you’ll remember.

Tip: Keep it somewhere easy to find — we’ll open it in Cursor soon.

3. Open the Project in Cursor

Once you’ve unzipped the archive, open the Moving Average folder.

Inside, you’ll find another folder called custom_indicator — that’s where the action is.

Open it with Cursor (see Picture #2 and #3).

Tip: If you see those folders exactly as described, you’re in the right place. Cursor is now ready to load your project.

4. Trust the Authors

If a pop-up appears saying something like “Do you trust the authors?”, don’t panic. It’s just Cursor being cautious.

Click “Yes, I trust the authors” — this simply lets the IDE know it’s safe to open the files.

Tip: This is a normal step whenever you open a project for the first time. Cursor just wants to make sure you’re cool with the code you’re about to run.

5. Open the Terminal and Install Dependencies

Next, click the little terminal icon (see Picture #5) — it’s your gateway to the behind-the-scenes magic. Once it’s open, type this command and hit Enter:

This will download and set up everything your indicator needs to run. Think of it as unpacking your toolbox before you start building.

Tip: If your screen starts showing a bunch of green and white text, you’re doing great — Cursor is fetching all the right pieces.

6. Start Writing and Build Your Indicator

Once the dependencies are installed, it’s showtime — open the index.ts file and start coding your indicator. This is your playground: add logic, tweak parameters, and let your creativity flow. When you’re happy with your code, it’s time to turn it into something FTO can actually use.

Open the terminal again and run:

7. Find Your Finished Indicator

Once the build is complete, you’ll see a shiny new file appear in your dist folder called my-indicator-project.js (or whatever name you gave it). This is your ready-to-use indicator — the one you’ll upload into Forex Tester Online.

Tip: Don’t move or rename it yet; FTO expects it just like this when you upload.

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

Once you’ve uploaded the file, your indicator will appear in the “My Indicators” dropdown menu (see Picture #8).

From here, it’s just a click away: pick your indicator, apply it, and watch it show up on your chart.

That’s a wrap!

You’ve gone from setting up Cursor to building, uploading, and running your own custom indicator in Forex Tester Online. Now you know how to prepare your environment, guide the AI, and see your work come to life on a chart. Keep experimenting, keep refining, and if you ever get stuck, teams like are there to help. Build more, debug less, and enjoy the process!

Alright, the warm-up is done — now it’s time to get your hands dirty (figuratively).

This is where we actually start writing code for your custom indicator.

Before we dive into coding, make sure your setup is ready to roll. You’ll need access to the FTO Indicator API to make things work smoothly.

Not there yet? No problem — check out the first, get your environment prepped, and then come back here. It’s a quick read and will save you a ton of head-scratching later.

For this example, we’ll let Cursor do some of the heavy lifting: we’ll ask it to create the On Balance Volume (OBV) indicator for us. We’ll start simple — with a completely empty file — so you can see the process from scratch. Later, when you’re more comfortable, you can speed things up by using some of our pre-built indicator foundations (you’ll find them in ).

Think of this as baking your first cake from flour and sugar — once you’ve got the hang of it, you can use ready-made mixes to save time.

Below you’ll find three example files — grab them, test them in FTO, and use them as a base for your custom indicators.

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)

Ready to create your first custom indicator? Let’s start with a classic: the Moving Average.

In this tutorial, we’ll walk step by step through building, coding, and running this popular indicator in FTO.

Don’t worry — even if you’re new to indicators, this one’s a great warm-up. By the end, you’ll have a working Moving Average ready to test and tweak on your charts.

To see how things work in practice, start by downloading the archive with the indicator example.

Once it’s on your computer, open it in any IDE you like — but we highly recommend Cursor IDE for the smoothest experience.

You can download the archive of Moving Average from here

How Custom Indicators Are Built

Every custom indicator in FTO starts with a simple but powerful idea: extend the IndicatorImplementation class from the forex-tester-custom-indicator-api library.

This class gives you all the building blocks you need — methods, structures, and tools — so you can focus on your logic instead of reinventing the wheel.

You can see a working version of this in action in the Moving Average example, which we described earlier in the section. It’s a great place to peek at the code and understand how everything fits together.

Indicator Parameters

Every custom indicator can have its own set of adjustable parameters — things like periods, colors, or calculation methods.

These parameters are defined using the class, which handles different types (numbers, booleans, lists, etc.) and makes them easy to edit.

When you add or edit your indicator in FTO, these parameters will appear in a user-friendly window where you (or your users) can tweak the settings to get just the right behavior.

Think of it as the dashboard for your indicator — all the knobs and switches in one place.

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

Registering Parameters

Defining parameters is only half the story — to actually use them in your indicator, they need to be registered inside the function. This is where you “introduce” your parameters to FTO so they’ll show up in the indicator settings window.

Without registration, your parameters will just sit quietly in the code, never making it to the user interface.

Think of Init as the guest list at a party — if you don’t put your parameter on the list, it won’t get through the door.

You can see the methods for registering parameters in the

Where to Find Registration Methods

All the methods you’ll need to register your parameters live in the section of the API.

That’s the place where FTO tells you: “Here’s how to make your parameters visible in the UI and ready for users to tweak.”

So whenever you’re setting up parameters in the Init function, just look back at those definitions — they’re your cheat sheet for getting everything hooked up the right way.

Tip: Without registration, parameters stay hidden in the code. With registration, they become clickable, adjustable settings in the indicator window.

Buffers setup

are the backstage crew of your indicator.

They’re used to store all those calculated values and then display them as lines, histograms, or other visuals right on your chart.

Think of them as the buckets where your indicator keeps its data before painting it onto the screen.

No buffers = no output. With buffers, your calculations finally become visible magic on the chart.

Buffers need to be both declared as class fields and initialized inside the function.

Connecting Buffers to the Chart

Creating buffers is just the start — now you need to tell FTO how many buffers will actually show up on the chart, and then bind each one by its index (starting from 0).

Each index must be unique, like seat numbers in a cinema.

In this example, we only need one buffer, so the setup looks like this:

• IndicatorBuffers(1) → tells FTO, “I’ve got one buffer to draw.”

• SetIndexBuffer(0, this.SSMA) → assigns our buffer SSMA to slot #0 on the chart.

Tip: If you ever add more buffers later (say, for multiple lines), just increase the number in IndicatorBuffers() and assign each one to its own index.

Configuring Buffers

Each registered buffer isn’t just a data bucket — you can also how it’s displayed on the chart.

For example:

• SetIndexLabel(0, "MA") → gives your buffer a friendly name (“MA”) so it shows up in the legend.

• SetIndexStyle(...) → sets how it looks: here it’s a solid red line with thickness 1.

• SetIndexDrawBegin(...) → defines the point on the chart where drawing should start (usually after enough data has been collected).

Tip: Don’t be afraid to play with colors, line styles, and labels. It’s your indicator — make it not only useful but also easy to read at a glance.

Other settings

Always Recalculate (or Not?)

Inside the function, you can use a handy setting called . By default, FTO calculates each buffer index only once to save resources. That’s efficient, but sometimes it means your indicator won’t be as accurate as you’d like.

If your calculations aren’t too heavy for the processor, we recommend always enabling this option. It ensures your indicator updates on every tick, keeping results fresh and reliable.

Tip: Think of it as “live mode” for your indicator — better accuracy in exchange for a tiny bit more CPU work.

Give Your Indicator a Name

Every indicator deserves an identity. With ., you set the name that will show up in the indicator settings window and the context menu.

Think of it as the little nametag your indicator wears — something short, clear, and easy to recognize when you’re scrolling through the list.

Tip: Keep it simple (like “Moving Average” or “OBV”) so you instantly know what it is at a glance.

Choose Where to Draw

By default, some indicators want to open their own little subwindow under the main chart. But for a Moving Average, it makes much more sense to see it directly on the main chart, hugging the price candles where it belongs.

That’s where comes in — it tells FTO exactly where to draw your indicator. In this case, we point it to the main chart so the Moving Average is right there in the action.

Tip: If you’re building other indicators (like oscillators), you can send them to their own window instead. For Moving Average, keep it on the main chart for the clearest view.

Skip the Zeroes

Sometimes indicators calculate values that are just 0 — and honestly, those don’t tell us much. With , you can tell FTO not to draw these points at all.

That way, the chart stays clean, without random flat lines cluttering your view.

Tip: Think of it like editing out background noise from a song — you only keep the meaningful parts, so the final output looks and sounds better.

Indicator's main function

At the heart of every custom indicator is the function. This is where the real action happens — all the math, logic, and updates take place here on each tick.

Changing parameters

Sometimes you want your indicator to react when the user changes its settings — that’s where the method comes in.

This method lets you add custom logic that runs right after parameters are updated. For example, in the Moving Average indicator it’s used to handle the horizontal shift, so the line moves correctly on the chart when the shift value changes.

OnParamsChange is especially handy if your indicator uses custom objects or needs to redraw elements whenever a parameter is tweaked.

Tip: Think of it as your indicator’s “refresh button” — it makes sure the chart always reflects the latest settings the user has chosen.

Wrapping Up

And there you have it — you’ve just built and understood your first custom indicator: the Moving Average.

From setting up parameters and buffers to configuring styles and handling recalculations, you now know the essential steps behind making an indicator come alive in FTO.

This is a solid foundation — once you’ve mastered the Moving Average, you’re ready to experiment, tweak, and create even more powerful custom tools for your trading.

Remember the documentation we uploaded back in Step 3? Now it’s time to make Cursor use it like a pro.

Here’s how:

• Switch Cursor to Ask Mode (it’s the one for questions and answers).

• In your request, type @ and choose Docs from the drop-down menu (see Picture #1).

This tells Cursor, “Hey, use the official FTO indicator docs for this answer.”

It’s like giving your AI a quick shot of espresso before it writes code — smarter, faster, and right on point.

From that drop-down menu, choose FTO Indicator documentation — the same one we uploaded back in Step 3 (see Picture #2).

This basically tells Cursor, “Hey, use the official playbook for this answer.” It’s like handing your AI the cheat sheet before an exam — fewer mistakes, better results.

Cursor needs to know which file to use for your indicator. You can simply drag and drop it straight from the Explorer panel (on the left) into the chat window, or use the @ menu, scroll down to Files & Folders, and select it from the list (see Picture #3). It’s like pointing Cursor to the right canvas before asking it to paint — now it knows exactly where to put the code.

Once you’ve selected the docs and the right file, Cursor has everything it needs to work its magic. From here, it’s just you, the AI, and some clean indicator-building fun. Time to let the code flow!

The Rules 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

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

Download and install the Cursor editor: , 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.

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

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

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

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.

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

Indicator parameters

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

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

You can see the methods for registering parameters in the

Buffers setup

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

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

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

Each registered buffer can be

Other settings

Also, other methods for configuring the indicator are used in the function. To ensure the indicator recalculates on each tick, use the function . 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: .

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

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

Indicator's main function

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

Changing parameters

To add custom logic after changing the indicator parameters, we use the 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.

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.

Description of the structure

Main methods of each indicator are and , 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.

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.

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

• TOptValue_str

• TOptValue_number

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

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

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 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 implement custom logic that should happen when parameters are modified.

Important: This method is NOT used for the actual parameter values to change — that happens internally. This method is only for custom logic that needs to be executed when parameters are changed.

Syntax

When and Why to Use It

This method is called after the user updates the settings in the indicator panel, but before the indicator is recalculated.

Use OnParamsChange() When You Need To:

• Recalculate internal values based on new parameter values

• Adjust or re-create custom chart objects (lines, labels, etc.)

• Update dependencies between parameters

Don't Use OnParamsChange() If:

• You only need basic parameter changes (values update automatically)

• You don't have any custom logic dependent on parameter changes

• Your indicator works fine with just and

What CAN Be Done in OnParamsChange

Buffer and Display Updates

• Modify buffer properties (styles, labels, visibility)

• Update buffer configuration based on parameter changes

• Reconfigure drawing styles and colors

Chart Object Management

• Create, modify, or remove custom chart objects

• Update object positions based on parameter changes

• Reconfigure object properties (colors, styles, positions)

Internal State Management

• Reset calculation counters or accumulators

• Update lookup tables or cached calculations

• Reconfigure internal algorithms based on parameters

What CANNOT Be Done in OnParamsChange

❌ Forbidden Operations

• Heavy calculations or complex mathematical operations

• Per-bar data processing (this should be in )

• Modifying the actual parameter values (handled internally)

❌ Wrong Approach

✅ Correct Approach

Practical Examples

Example 1: Dynamic Buffer Styling

Example 2: Parameter Validation and Dependencies

Example 3: Chart Object Management

Best Practices

✅ Do This

• Keep it lightweight - only essential parameter-dependent logic

• Use it for setup/configuration that depends on parameters

• Reset internal state when parameters change

❌ Avoid This

• Heavy computational work (belongs in Calculate())

• Complex loops or data processing

• Modifying parameter values

When NOT to Implement OnParamsChange()

You can skip implementing this method if:

• Your indicator only uses basic parameters for calculations

• No custom logic is needed when parameters change

• All parameter-dependent behavior happens in Calculate()

Key Rules Summary

1. OnParamsChange() is optional - only implement if you need custom logic

2. Keep it lightweight - no heavy calculations or data processing

3. Parameter values update automatically - this method is for additional logic only

Pro Tip

Think of OnParamsChange() as your "parameter change reaction" method. It's the perfect place to update anything that depends on parameter values but doesn't belong in the per-bar Calculate() method. Keep it fast and focused on configuration rather than calculation.

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.

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.

What Is It?

TOptValue_DateTime is a class used to define date and time parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust date and time values such as start times, end times, or specific moments in trading history.

You must use the createTOptValue_DateTime() method of the api

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

• Volume : 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.

What Is It?

TOptValue_LineStyle is a class used to define line style parameters for custom indicators. It allows users to configure line appearance (visibility, color, style, width) through the indicator settings panel.

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

When to Use

Use TOptValue_LineStyle when you want to let the user configure line appearance for:

• Support/resistance levels

• Trend lines

• Other visual elements on charts

Syntax

Example

In this example:

• LineStyle allows the user to configure line appearance

• Inside Calculate(), a horizontal line is created with the configured style

• The line is positioned at the current bar's close price

Notes

• Don't forget to register line style parameters using inside the method.

• Use TOptionType.LINE when registering TOptValue_LineStyle parameters.

• Access properties with this.MyLineStyle.isVisible

What Is It?

TOptValue_DateOnly is a class used to define date-only parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust date values without time information, such as specific trading days, start dates, or end dates.

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

When to Use

Use TOptValue_DateOnly when you need a configurable parameter of date only, such as:

• Start date for calculations (without specific time)

• End date for a period (without specific time)

• Specific trading day to highlight or filter

Syntax

Example

In this example:

• StartDate defines the beginning of the analysis period.

• EndDate defines the end of the analysis period.

Notes

• After creating a parameter, don't forget to register it using in the method.

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

• Use TOptionType.DATE_ONLY when registering this parameter type.

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

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

Syntax

Parameters