What You Can Build with Indie

Six capabilities you do not get from a fixed indicator library. Each one is a few lines of Indie, and each example below is taken from a page in this documentation where it is explained in full. New to the language? Why Indie covers the reasoning; Quick start covers the first script.

1. Your own data next to price

Macro figures, on-chain metrics, funding rates, your own trading journal — anything you can publish as a CSV over HTTPS becomes a series on the chart, read as candles, as typed rows, or directly with request_series.

External candle close

# indie:lang_version = 5
from indie import indicator, sec_context, MainContext, TimeFrame
from indie.data import sources

@sec_context
def ExternalCandles(self):
    return self.close[0]

@indicator('External candle close')
class Main(MainContext):
    def __init__(self):
        self._ext_close = self.calc_on(
            ExternalCandles,
            time_frame=TimeFrame.from_str('1D'),
            source=sources.Csv('https://example.com/candles.csv'))

    def calc(self):
        return self._ext_close[0]

No exchange offers this, because it is not exchange data. It is yours.

Scripts using external data cannot be published to the Marketplace — they stay private to your account.

External data →

2. A summary that stays on the chart

Session statistics, current values, signal counts, risk numbers — in a table pinned to a corner of the chart, so the reader does not have to hover over a line to find them.

Market summary table

# indie:lang_version = 5
from indie import MainContext, color, indicator
from indie.drawings import Table, TableCell, TableRow, RelativePosition, vertical_anchor as va, horizontal_anchor as ha

@indicator('Market summary', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        self._table = Table(
            position=RelativePosition(va.TOP, ha.RIGHT, 0.05, 0.95),
        )

    def calc(self):
        if not self.is_last_bar:
            return self.close[0]

        self._table.clear()
        self._table.append(TableRow([
            TableCell('Metric', bg_color=color.GRAY(0.5)),
            TableCell('Value', bg_color=color.GRAY(0.5)),
        ]))
        self._table.add_row(['Close', str(self.close[0])])
        self._table.add_row(['Bar', str(self.bar_index)])

        self.chart.draw(self._table)
        return self.close[0]

Tables hold up to 50 rows and 20 columns. Drawings: lines, labels, tables →

3. Another instrument, or a faster timeframe

An indicator on the hourly chart can calculate its logic on the minute chart, or pull the daily high and low of a different instrument. Context.calc_on() runs a second context and merges the result into your timescale.

Minimal calc_on example

# indie:lang_version = 5
from indie import indicator, MainContext, sec_context, param

@sec_context
def SecMain(self):
    return self.high[0], self.low[0]

@indicator('Minimal calc_on example', overlay_main_pane=True)
@param.time_frame('sec_time_frame', default='1D')
class Main(MainContext):
    def __init__(self, sec_time_frame):
        self._sec_high, self._sec_low = self.calc_on(SecMain, time_frame=sec_time_frame)

    def calc(self):
        return self._sec_high[0], self._sec_low[0]

Higher and lower timeframes are both supported — lower ones since v5.14. Request additional instruments →

4. Candles coloured by your own rule

Instead of a signal in a separate pane that you have to correlate with price by eye, colour the bars themselves — volume spikes, trend shifts, whatever your rule says.

Volume Spike Bar Color

# indie:lang_version = 5
from indie import indicator, param, plot, color
from indie.algorithms import Sma


@indicator('Volume Spike Bar Color', overlay_main_pane=True)
@param.int('volume_ma_len', default=20, min=1, title='Volume MA Length')
@param.float('spike_coef', default=2.0, min=1.0, max=1000.0, title='Spike coefficient')
@plot.bar_color(title='Bar Color')
def Main(self, volume_ma_len, spike_coef):
    volume_ma = Sma.new(self.volume, volume_ma_len)
    spike = self.volume[0] > volume_ma[0] * spike_coef

    # Color bars with high volume in yellow, others use default coloring
    return plot.BarColor(color.YELLOW if spike else None)

Returning None leaves the bar with its default colour. Data plotting →

5. Your own trading sessions

Market hours differ by venue, and most rules only make sense inside a session. A schedule is a set of rules with a timezone and its own exceptions, and any bar can be tested against it.

Session schedule

# indie:lang_version = 5
from indie import indicator, MainContext
from indie.schedule import ScheduleRule, Schedule, WORKDAYS, WEEKEND
from datetime import time, datetime

@indicator('Example')
class Main(MainContext):
    def __init__(self):
        rule1 = ScheduleRule(start=time(hour=9), end=time(hour=18), days=WORKDAYS)
        rule2 = ScheduleRule(start=time(hour=12), end=time(hour=15), days=WEEKEND)
        self.schedule = Schedule(rules=[rule1, rule2], except_once=[datetime(year=2025, month=4, day=5)], timezone="America/New_York")

    def calc(self):
        # using self.schedule, e.g.
        return 1 if self.time[0] in self.schedule else 0

Overnight sessions, 24/7 markets and single-day exceptions are all covered. Schedules and trading sessions →

6. Rules that place orders — and get tested

An indicator that places orders is a strategy. The same file that drew your signal can open, reverse and close a position, then be measured over history in the Strategy tester.

Inside Bar strategy

# indie:lang_version = 5
from indie import strategy, param
from indie.strategies import order_side


@strategy('InSide Bar Strategy', overlay_main_pane=True, initial_capital=4200000.0)
@param.float('order_size', default=10.0, title='Order size', min=0.1, max=100.0)
@param.str('order_size_unit', default='% of cash', title='Order size unit', options=['% of cash', 'quantity'])
def Main(self, order_size, order_size_unit):
    desired_pos_size = order_size if order_size_unit == 'quantity' else self.trading.cash * order_size / 100 / self.close[0]
    if self.high[0] < self.high[1] and self.low[0] > self.low[1]:
        pos_size = self.trading.position.size
        if self.close[0] > self.open[0] and pos_size <= 0:
            # reverse previous position if exists or open a new one
            self.trading.place_order(order_side.BUY, size=desired_pos_size + abs(pos_size)).submit()
        elif self.close[0] < self.open[0] and pos_size >= 0:
            self.trading.place_order(order_side.SELL, size=desired_pos_size + abs(pos_size)).submit()

Limit and stop prices, take profit, stop loss, amend and cancel are all available on the order builder. Strategies and backtesting →

Where to go next

Quick start

Your first indicator, step by step.

Build it with AI

Describe the idea and let an LLM write and validate the Indie code.

Code examples

Longer, ready-to-run indicators and strategies.

Documentation

1. Your own data next to price

2. A summary that stays on the chart

3. Another instrument, or a faster timeframe

4. Candles coloured by your own rule

5. Your own trading sessions

6. Rules that place orders — and get tested

Where to go next

Quick start

Build it with AI

Code examples

​1. Your own data next to price

​2. A summary that stays on the chart

​3. Another instrument, or a faster timeframe

​4. Candles coloured by your own rule

​5. Your own trading sessions

​6. Rules that place orders — and get tested

​Where to go next

Quick start

Build it with AI

Code examples

1. Your own data next to price

2. A summary that stays on the chart

3. Another instrument, or a faster timeframe

4. Candles coloured by your own rule

5. Your own trading sessions

6. Rules that place orders — and get tested

Where to go next