Plugin

Heikin Ashi

Heikin Ashi candles for a strategy: HA open, high, low and close, the candle color, the run of same colored candles and a no opposite wick flag.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

Heikin Ashi smooths candles by averaging. This plugin computes the classic definition (Dan Valcu, Technical Analysis of Stocks & Commodities, 2004) bar by bar: HA close = (open + high + low + close) / 4; HA open = (previous HA open + previous HA close) / 2; HA high = max(high, HA open, HA close); HA low = min(low, HA open, HA close).

The first bar has no previous HA candle, so its HA open is seeded with (open + close) / 2 of that bar, the classic seed. Each later HA open halves the distance to the seed, so after ten bars the seed's share is below 0.1%. The seed is the first bar the indicator sees, so a run that starts on a different day shows slightly different first values.

The chart can already draw Heikin Ashi candles (Chart options); this plugin hands the same kind of values to a strategy. It has no parameters: pass {}.

Use it in a strategy

pythonha = ctx.plugin_indicator("heikin_ashi", "heikin_ashi", {})
if ha is not None and ha.value is not None:
    # Three rising candles in a row, the last without a lower wick.
    if ha.color == 1 and ha.run >= 3 and ha.no_opposite_wick:
        ctx.signal("LONG")
    elif ha.color == -1:
        ctx.signal("EXIT")

The indicator library has this as heikin_ashi: ctx.ind("heikin_ashi") reads the same candles, direction (the color here), run and no_opposite_wick, and the chart, Blocks, Rust and the Rust core have it too. This template stays as an example of a plugin indicator.

What it provides

`value`Value	The HA close, the same as ha_close. None before the first bar.
`ha_open`Value	The HA open: the midpoint of the previous HA candle's body.
`ha_high`Value	The HA high: the highest of the bar's high, the HA open and the HA close.
`ha_low`Value	The HA low: the lowest of the bar's low, the HA open and the HA close.
`ha_close`Value	The HA close: the average of the bar's open, high, low and close.
`color`Value	1 when the HA close is above the HA open (rising), -1 when below (falling), 0 when they are equal.
`run`Value	How many candles in a row have this color, this one included. A candle with color 0 has a run of 0 and ends the run before it.
`no_opposite_wick`Value	True for a rising candle without a lower wick or a falling candle without an upper wick, often read as a strong candle. False otherwise.

When values are known

Each value is final at the close of its bar and never changes when later bars arrive.

Limits

HA prices are averages, not prices that traded. Orders still fill at the real bid and ask, so a backtest that enters at the HA close would not match its fills.
The first values depend on the seed bar, the first bar the indicator sees: a run that starts on another day shows slightly different HA values for its first few bars.
A plugin indicator is not drawn on the chart and is not available in Blocks, Pine, Rust or C#; it runs on the run's own instrument only.

Preview

json{
  "color": 1,
  "ha_close": 1.08515,
  "ha_high": 1.08561,
  "ha_low": 1.08462,
  "ha_open": 1.08462,
  "no_opposite_wick": true,
  "run": 4,
  "value": 1.08515
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""Heikin Ashi candles as a streaming indicator.

The classic definition (Dan Valcu, "Using the Heikin-Ashi Technique",
Technical Analysis of Stocks & Commodities, February 2004):

    HA close = (open + high + low + close) / 4
    HA open  = (previous HA open + previous HA close) / 2
    HA high  = max(high, HA open, HA close)
    HA low   = min(low, HA open, HA close)

The first bar has no previous HA candle, so its HA open is seeded with
(open + close) / 2 of that bar: the classic seed. Every later HA open halves
the distance to the seed, so after ten bars the seed's share is below 0.1%.

A strategy reads it through
ctx.plugin_indicator("heikin_ashi", "heikin_ashi", {}). Each value is final at
the close of its bar and never changes when later bars arrive.
"""


def _ohlc(bar):
    """open, high, low, close of an engine Bar or of a plain dict."""
    if isinstance(bar, dict):
        return float(bar["open"]), float(bar["high"]), float(bar["low"]), float(bar["close"])
    return float(bar.open), float(bar.high), float(bar.low), float(bar.close)


class HeikinAshi:
    """update(bar) then read ha_open, ha_high, ha_low, ha_close, color, run and
    no_opposite_wick. Everything is None before the first bar."""

    def __init__(self):
        self.ha_open = None
        self.ha_high = None
        self.ha_low = None
        self.ha_close = None
        self.color = None
        self.run = None
        self.no_opposite_wick = None

    def update(self, bar):
        o, h, low, c = _ohlc(bar)
        if self.ha_open is None:
            ha_open = (o + c) / 2.0  # the classic seed
        else:
            ha_open = (self.ha_open + self.ha_close) / 2.0
        ha_close = (o + h + low + c) / 4.0
        self.ha_open = ha_open
        self.ha_close = ha_close
        self.ha_high = max(h, ha_open, ha_close)
        self.ha_low = min(low, ha_open, ha_close)

        # Color: 1 for a rising candle, -1 for a falling one, 0 when open equals close.
        if ha_close > ha_open:
            color = 1
        elif ha_close < ha_open:
            color = -1
        else:
            color = 0

        # Run: how many candles in a row have this color, this one included.
        # A candle with color 0 breaks a run and has a run of 0.
        if color == 0:
            self.run = 0
        elif color == self.color:
            self.run += 1
        else:
            self.run = 1
        self.color = color

        # No opposite wick: a rising candle without a lower wick (its low is its
        # open) or a falling candle without an upper wick (its high is its open).
        # Compared against the bar's own low or high, so no float equality test.
        if color == 1:
            self.no_opposite_wick = ha_open <= low
        elif color == -1:
            self.no_opposite_wick = ha_open >= h
        else:
            self.no_opposite_wick = False

    @property
    def value(self):
        """The HA close, the main line."""
        return self.ha_close


def make(params):
    return HeikinAshi()


def register(api):
    api.register_indicator("heikin_ashi", "Heikin Ashi", make, [])
    api.log("Heikin Ashi indicator registered")