Plugin

Bollinger Bands (how to write an indicator)

A short streaming indicator to copy from: one bar in, the middle, upper and lower band out.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

This plugin exists to be read. It shows the whole shape of an indicator plugin in one file: a class that takes one bar per update, keeps only the window it needs, returns None while it warms up, and exposes extra lines as properties beside value.

The engine already has Bollinger Bands built in (ctx.ind("bb")), drawn on the chart and available in every language. Use that one in a strategy; use this one as the starting point for an indicator of your own.

Parameters

Name	Type	Default	Range or options	Description
`period`	int	`20`	min 2, max 200	Bars in the window the average and the standard deviation are taken over.
`mult`	float	`2`	min 0.5, max 5	How many standard deviations the upper and lower band sit from the middle.

Use it in a strategy

pythonbands = ctx.plugin_indicator("bollinger_bands", "bollinger", {"period": 20, "mult": 2.0})
if bands is not None and bands.value is not None:
    close = ctx.bars(1)[-1].close
    if close < bands.lower:
        ctx.signal("LONG")

What it provides

`value`Value	The middle band, the simple moving average of the close. None during warm up.
`upper`Value	The middle band plus mult population standard deviations.
`lower`Value	The middle band minus mult population standard deviations.

Limits

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{
  "lower": 1.0793,
  "upper": 1.0911,
  "value": 1.0852
}

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"""Bollinger Bands streaming indicator.

Example plugin. A streaming indicator carries O(1) state, takes one bar per
update, and reads back through properties. value is the middle band (the SMA), and
upper and lower sit mult standard deviations away. All values are None during the
warm up window, the same convention as the engine's built in indicators. A
strategy reads it through ctx.plugin_indicator("bollinger_bands", "bollinger",
{"period": 20, "mult": 2.0}).
"""

import math
from collections import deque


class BollingerBands:
    """update(bar) then read value (middle), upper, and lower."""

    def __init__(self, period=20, mult=2.0):
        self.period = max(2, int(period))
        self.mult = float(mult)
        self._window = deque()

    def update(self, bar):
        close = bar["close"] if isinstance(bar, dict) else bar.close
        self._window.append(float(close))
        if len(self._window) > self.period:
            self._window.popleft()

    def _stats(self):
        if len(self._window) < self.period:
            return None
        mean = sum(self._window) / self.period
        variance = sum((v - mean) ** 2 for v in self._window) / self.period
        return mean, math.sqrt(variance)

    @property
    def value(self):
        s = self._stats()
        return s[0] if s else None

    @property
    def middle(self):
        return self.value

    @property
    def upper(self):
        s = self._stats()
        return s[0] + self.mult * s[1] if s else None

    @property
    def lower(self):
        s = self._stats()
        return s[0] - self.mult * s[1] if s else None


def make(params):
    params = params or {}
    return BollingerBands(params.get("period", 20), params.get("mult", 2.0))


def register(api):
    api.register_indicator(
        "bollinger",
        "Bollinger Bands",
        make,
        [
            {"key": "period", "label": "Period", "type": "int", "default": 20, "min": 2, "max": 200},
            {"key": "mult", "label": "Std dev multiple", "type": "float", "default": 2.0, "min": 0.5, "max": 5.0},
        ],
    )
    api.log("Bollinger Bands indicator registered")