API for custom indicators

Read the attached [AI-scripting.txt] https://mobchart.com/docs/public/AI-scripting.txt file and use it as the only reference for the MobChart scripting API.

Create a custom indicator that plots a 20-period EMA and a 50-period EMA on the chart. Color the candles green when EMA20 is above EMA50 and red otherwise.

Use only the documented API. Do not invent functions. Return the complete indicator code.

define("My Indicator", "Shows EMA line", "onchart", true, false);

define("Window max", "Label at the highest visible high", "onchart", true, true, { fullRange: true });

const length = input.number("Period", 14, 1, 100, 1);
const type = input.select("Type", 'sma', ['sma', 'ema']);
const color = input.color("Line Color", "#FF0000");
// pairs to include / exclude, picked from the tickers of the chart exchange
const include = input.tickers("Include pairs", []);
const exclude = input.tickers("Exclude pairs", []);

const length = style.number("Size", 14, 1, 100, 1);
const color = style.select("Background Color", '#FF0000', ["#FF0000", "#AA0000", "#BB0000"]);
const color = style.color("Background Color", "#FF0000");

[
    {
        "open": 115886.17,
        "high": 115911.96,
        "low": 115764.27,
        "close": 115815.16,
        "volume": 228.41528,
        "startTime": 1757699100000
    },
    {...},
    ...
]

[
    {
        "data": {
            "asks": {
                "109425": 5.467,
                "109495": 3.564,
                ...
            },
            "bids": {
                "33000": 3.746,
                "35000": 16.49,
                ...
            }
        },
        "startTime": 1757699100000
    },
    {...},
    ...
]

[
    {
        "data": {
            "totalBuy": 16053385,
            "totalSell": 20490989,
            "0.8654": { "buy": 286845, "sell": 336689 },
            "0.8653": { "buy": 271848, "sell": 259167 },
            "0.8652": { "buy": 318814, "sell": 373497 },
            ...
        },
        "startTime": 1757699100000
    },
    {...},
    ...
]

[
    {
        "data": {
            "totalBuy": 16053385,
            "totalSell": 20490989,
            "0.8654": { "buy": 286845, "sell": 336689 },
            "0.8653": { "buy": 271848, "sell": 259167 },
            "0.8652": { "buy": 318814, "sell": 373497 },
            ...
        },
        "startTime": 1757699100000
    },
    {...},
    ...
]

[
    {  
        "data": {
            "FR": 0.00003777, // Funding Rate
            "OI": { // Open Interest Candle
                "open": 85645.708,
                "close": 83496.225,
                "high": 85801.04,
                "low": 83397.918
            },
            "LS": { "l": 0.5426, "s": 0.4574 }, // Long/Short Ratio
            "taLS": { "l": 0.552, "s": 0.448 }, // Top Traders Account Ratio
            "tpLS": { "l": 0.5996, "s": 0.4004 } // Top Traders Position Ratio
        },
        "startTime": 1757699100000
    },
    {...},
    ...
]

{
    "asks": {
        "109425": 5.467,
        "109495": 3.564,
        ...
    },
    "bids": {
        "109400": 1.2,
        "109390": 0.8,
        ...
    }
}

const candles = source.ohlcv(); // The exchange, ticker, and timeframe parameters default to the current chart.
const closes = candles.map(c => c.close);

{
    "BTCUSDT": {
        "asks": {
            "109500": {
                "price": 109500,
                "quantity": 42.5,          // size in the base asset
                "quantityUSDT": 4653750,   // size in the quote currency
                "distance": 0.62,          // from the current price, percent
                "duration": 184,           // minutes the order has been standing
                "touches": 2,
                "currentTouches": 1,
                "filledPercent": 12.4,
                "strength": 95.5,          // percent, see the screener
                "diversity": 11,
                "isContinuous": true,
                "date": "2026-10-10T06:12:03.000Z"
            },
            ...
        },
        "bids": { ... },
        "volume1hTotal": 183000000
    },
    ...
}

// the big orders around the price of the chart market as horizontal lines, labelled with the size and the lifespan
const candles = await source.ohlcv();
const lastDate = candles.at(-1).startTime;
const levels = await source.levels(currentExchange, { tickers: [currentTicker], nearness: 3, size: 300000, lifespan: 30 });
const own = levels[currentTicker] || { asks: {}, bids: {} };
for (const [type, color] of [["asks", "#ef5350"], ["bids", "#26a69a"]]) {
    for (const [price, level] of Object.entries(own[type])) {
        plot.horizontalLine(`${type} ${price}`, +price, color, 0.8, Math.min(4, 1 + level.quantityUSDT / 1e6));
        plot.text(`${type} ${price} label`, `${(level.quantityUSDT / 1e6).toFixed(2)}M · ${level.duration}m`, lastDate, +price, 10, color);
    }
}

{
    "BTCUSDT": {
        "price": 79776.57,            // current price
        "updatedAt": 1788707880000,
        "bootstrapped": true,         // false while the history of the ticker is still being collected
        "nearest": 0.08,              // distance of the nearest level, percent
        "matches": 5,                 // levels inside the distance range
        "daily":  { "start": 1788652800000, "open": 79700, "high": 79985, "low": 79710, "openApprox": false,
                    "distance": { "open": -0.1, "high": 0.26, "low": -0.08 } },   // percent from the price, signed
        "prevDay": { ... }, "weekly": { ... }, "prevWeek": { ... },
        "monthly": { ... }, "prevMonth": { ... }, "yearly": { ... }, "prevYear": null   // null: no data for the period yet
    },
    ...
}

// the key levels of the chart market as horizontal lines
const candles = await source.ohlcv();
const lastDate = candles.at(-1).startTime;
const rows = await source.keyLevels(currentExchange, { tickers: [currentTicker], periods: ["daily", "prevDay", "weekly"] });
const own = rows[currentTicker];
if (own) {
    for (const period of ["daily", "prevDay", "weekly"]) {
        const level = own[period];
        if (!level) continue;
        for (const [field, color] of [["high", "#ef5350"], ["low", "#26a69a"], ["open", "#90a4ae"]]) {
            if (level[field] == null) continue;
            plot.horizontalLine(`${period} ${field}`, level[field], color, 0.8, 1);
            plot.text(`${period} ${field} label`, `${period} ${field.toUpperCase()}`, lastDate, level[field], 10, color);
        }
    }
}

{
    "exchange": "binanceFutures",
    "hours": 24,
    "snapshotMinutes": 5,
    "latestAt": 1792102098685,
    "summary": { "snapshots": 287, "uniqueLevels": 217, "uniqueTickers": 118, "activeNow": 180, "bidsNow": 102, "asksNow": 78, "usdNow": 119294436 },
    "series": [                                   // one point per snapshot, oldest first
        { "at": 1792015822555, "bids": 24, "asks": 21, "bidsUsd": 1851345, "asksUsd": 1228883, "tickers": 20 },
        ...
    ],
    "tickers": {                                  // per ticker, over the period
        "BTCUSDT": { "now": 3, "nowUsd": 95710480, "snapshots": 63, "bids": 3, "asks": 0, "levels": 3,
                     "maxUsd": 42347880, "maxDuration": 8220, "maxStrength": 100 },
        ...
    },
    "levels": [                                   // the lifecycle of every level, active ones first
        { "ticker": "BTCUSDT", "side": "bids", "price": 52050, "usd": 42347880, "quantity": 813.6, "distance": 19.8,
          "duration": 8220, "strength": 100, "continuous": 1, "firstSeen": 1792015822555, "lastSeen": 1792102098685,
          "snapshots": 63, "maxDuration": 8220, "maxStrength": 100, "active": true },
        ...
    ],
    "levelsTotal": 217
}

// $ size of the strong levels of the chart market per candle
const candles = await source.ohlcv();
const data = await source.levelsMetrics(currentExchange, { tickers: [currentTicker], hours: 24, minDuration: 60, minStrength: 90, stableOnly: true });
const series = data.series;           // oldest first
let j = 0;
const buy = [], sell = [];
for (let i = 0; i < candles.length; i++) {
    const end = candles[i + 1] ? candles[i + 1].startTime : candles[i].startTime + (candles[1].startTime - candles[0].startTime);
    while (j + 1 < series.length && series[j + 1].at < end) j++;   // the last snapshot inside the candle
    const point = series[j] && series[j].at < end ? series[j] : null;
    buy.push(point ? point.bidsUsd : null);
    sell.push(point ? point.asksUsd : null);
}
plot.areaSeries("Buy levels ($)", buy, "#26a69a", 0.3, "#26a69a", 1, 1, 0);
plot.areaSeries("Sell levels ($)", sell, "#ef5350", 0.3, "#ef5350", 1, 1, 0);

{
    ok: true,                 // status 200–299
    status: 200,              // HTTP status, 0 when the request was not sent
    headers: { "content-type": "application/json", ... },
    data: { ... },            // response body parsed as JSON, null when the body is not JSON
    text: "...",              // raw response body
    error: null               // reason when the request failed: "timeout", "url not allowed", "too many requests", ...
}

define("Fear & Greed", "Crypto Fear & Greed index", "offchart", true, true);

const res = http.get("https://api.alternative.me/fng/?limit=30");
if (!res.ok) logger.log("request failed:", res.status, res.error);

// res.data = { data: [{ value: "71", timestamp: "1757635200" }, ...] }
const byDay = {};
(res.data?.data || []).forEach((row) => { byDay[Number(row.timestamp) * 1000] = Number(row.value); });

const candles = source.ohlcv();
const values = candles.map((c) => c ? byDay[c.startTime - (c.startTime % 86400000)] ?? null : null);
plot.lineSeries("Fear & Greed", values, "#00C8FF");

const candles = source.ohlcv();
const last = candles.at(-1);

const res = http.post(
    "https://example.com/api/signals",
    { exchange: currentExchange, ticker: currentTicker, close: last.close },
    { headers: { "x-api-key": "YOUR_KEY" } } // private code only
);
logger.log("signal sent:", res.ok, res.status, res.data);

const candles = source.ohlcv(currentExchange, currentTicker, currentTimeframe);
const closes = candles.map(c => c.close);

// a Coinbase-style ticker on Binance Futures: resolved to ETHUSDT
const depths = source.depths("binanceFutures", "ETH-USD");
// the ticker of a Binance chart on Coinbase: ETHUSDT becomes ETH-USD
const spot = source.ohlcv("coinbase", currentTicker, currentTimeframe);

const candles = source.ohlcv();
logger.log("First candle:", candles?.[0]);

plot.text("Text object", "Hello world!", 1757699100000, 115000, 10, "#00C8FF", 0.5);
plot.straightLine(`${namePrefix} Open`, level.timeStart, level.open, level.timeEnd, level.open, color);
plot.circle(`${namePrefix} High`, level.timeStart, level.high, 3, color);

plot.lineSeries("EMA", ta.ema(closes, 20), "#00C8FF");
// every candle keeps its own color: green where the close is above the EMA, red below it
plot.lineSeries("Close", closes, (v, i) => v > ema[i] ? colorBuy : colorSell);
plot.barSeries("Premium %", premiumPercents, ((d) => d > 0 ? color1 : color2), 1);
plot.candleSeries(
    "Candles",
    opens, closes, highs, lows,
    (v, i) => {
        return opens?.[i] > closes?.[i] ? colorBuy : colorSell
    }
);
plot.areaSeries("Volume", volumes, "#00C8FF", 0.3);
// area colored per candle, more opaque on the bigger candles
plot.areaSeries("Delta", deltas, (v, i) => v >= 0 ? colorBuy : colorSell, (v, i) => Math.min(1, Math.abs(v) / maxDelta));

// pressure band between the close and 1% below it, colored and shaded by the imbalance ratio of the candle
plot.bandSeries(
    "Bid pressure",
    closes,
    closes.map(c => c * 0.99),
    (upper, lower, i) => ratios[i] > 0 ? bidColor : askColor,
    (upper, lower, i) => Math.abs(ratios[i]) / 100
);

// volume profile of the chart, the same picture as the built-in tool
const rows = await source.clusters();
plot.profile("Volume", rows.map((r) => r?.data ?? null), { step: 5 });

// only large trades, delta coloured, on the left edge
const minSize = input.number("Min trade size", 50, 0, 100000, 1);
const big = rows.map((r) => {
    if (!r?.data) return null;
    const out = {};
    for (const [price, c] of Object.entries(r.data)) {
        if (price === "totalBuy" || price === "totalSell") continue;
        if (c.buy + c.sell >= minSize) out[price] = { buy: c.buy, sell: c.sell };
    }
    return out;
});
plot.profile("Large trades", big, { step: 5, delta: true, orient: "left" });

// the live order book as a profile on the right edge: bids in the buy colour, asks in the sell colour
const book = await source.orderbook();
const rows = {};
for (const [price, qty] of Object.entries(book.bids)) rows[price] = { buy: qty };
for (const [price, qty] of Object.entries(book.asks)) rows[price] = { sell: qty };
plot.histogram("Order book", rows, { step: 5, width: 25, valueArea: false, poc: false });

// your own histogram: cluster volume of the last 100 candles, recent candles weigh more
const rows = await source.clusters();
const weighted = {};
rows.slice(-100).forEach((r, i, arr) => {
    if (!r?.data) return;
    const weight = (i + 1) / arr.length;
    for (const [price, c] of Object.entries(r.data)) {
        if (price === "totalBuy" || price === "totalSell") continue;
        const cell = weighted[price] || (weighted[price] = { buy: 0, sell: 0 });
        cell.buy += (c.buy || 0) * weight;
        cell.sell += (c.sell || 0) * weight;
    }
});
plot.histogram("Weighted volume", weighted, { step: 5, orient: "left", delta: true });

const candles = await source.ohlcv();
const closes = candles.map((c) => c.close);
const rsi = ta.rsi(closes, 14);
const last = rsi.at(-1);
const change = (closes.at(-1) / closes.at(-25) - 1) * 100;

plot.table("Stats", [
    ["Metric", "Value"],
    ["RSI 14", { text: last.toFixed(1), color: last > 70 ? "#ef5350" : last < 30 ? "#26a69a" : undefined }],
    ["Change 24 bars", { text: change.toFixed(2) + "%", align: "right" }],
    ["Volume", candles.slice(-24).reduce((s, c) => s + c.volume, 0).toFixed(0)],
], { position: "top-right", header: true });

const candles = source.ohlcv();
const closes = candles.map(c => c.close);
const rsiValues = ta.rsi(closes, 14);
plot.lineSeries("RSI", rsiValues, "#00C8FF");

const alertVolumeThreshold = alertInput.number("Volume threshold", 1000, 0, 10000000, 1);

if (candle.volume > alertVolumeThreshold) {
    alert.fire("High volume", `vol ${candle.volume}`, candle.startTime);
}

// simple: fires every time the shape is plotted for a new date
plot.box(...).alert("High volume", `vol ${candle.volume}`);

// callback: return nothing to skip, [title, message] to fire
plot.box(...).alert((shape) => {
    if (candle.volume > alertVolumeThreshold)
        alert.fire("High volume", `vol ${candle.volume}`, candle.startTime);
});

plot.lineSeries("RSI", rsiValues, color).alert((rsi, date) => {
    if (rsi > alertRsiThreshold) alert.fire("RSI high", `RSI ${rsi.toFixed(1)}`, latestCandle.startTime);
});

const title = "Volume alerts";
const description = "Shows boxes on high-volume candles";
define(title, description, "onchart", true, true);

const color = style.color("Color", "#00C8FF");
const volumeThreshold = input.number("Volume threshold", 1000, 0, 10000000, 1);
const alertVolumeThreshold = alertInput.number("Alert volume threshold", 5000, 0, 10000000, 1);
const alertCloseThreshold = alertInput.number("Alert close threshold", 100000, 0, 10000000, 1);

const candles = source.ohlcv();
const latestCandle = candles.at(-1);
const closes = candles.map(c => c.close);

// series alert: checks the latest close
plot.lineSeries("Closes", closes, color).alert((close, date) => {
    if (close > alertCloseThreshold) alert.fire("Close above threshold", `close ${close}`, latestCandle.startTime);
});

for (let i = 0; i < candles.length; i++) {
    const candle = candles[i];

    if (candle.volume > volumeThreshold) {
        const right = i < candles.length - 1 ? candles[i + 1].startTime : candle.startTime + 60000;

        // shape alert: checked against the user's alert threshold
        plot.box(`Volume ${i}`, candle.startTime, candle.high, right, candle.low, "#00C8FF", 0.3)
            .alert(() => {
                if (candle.volume > alertVolumeThreshold)
                    alert.fire("High volume", `vol ${candle.volume}`, candle.startTime);
            });
    }
}

const title = "Your first indicator";
const description = "Shows closes lines on the chart";
const indicatorType = "onchart";

define(title, description, indicatorType, true, true);

const color = input.color("Line Color", "#00C8FF");
const candles = source.ohlcv();
const closes = candles.map(c => c.close);
plot.lineSeries("Closes", closes, color);

define("Example Indicator", "Demonstrates basic plotting", "onchart", true, true);

const color = input.color("Line Color", "#00FF99");
const candles = source.ohlcv();
const closes = candles.map(c => c.close);

const ema20 = ta.ema(closes, 20);
plot.lineSeries("EMA 20", ema20, color);

const title = "Colored Volume Bars";  
const description = "Volumes colored based on candle direction.";  
const indicatorType = "onchart";  
const isPublic = true;  
const isPublicCode = true;  

define(title, description, indicatorType, isPublic, isPublicCode);  

// Get OHLC candles
const candles = source.ohlcv();  

const colorUp = style.color("Color 1", "#2BB462"); // Greenish color for rising prices
const colorDown = style.color("Color 2", "#FB4C51"); // Reddish color for falling prices
const volumes = candles.map(candle => candle.volume);  

plot.barSeries("Volume", volumes, (value, index) => {
    const currentCandle = candles[index];  
    return currentCandle.close >= currentCandle.open ? colorUp : colorDown;  
});

define('Coinbase Premium Index', 'Coinbase Premium Index', 'offchart', true, false);

const color1 = style.color("Color 1", "#2BB462");
const color2 = style.color("Color 2", "#FB4C51");

// Get OHLC candles
const cbCandles = source.ohlcv('coinbase', 'BTC-USD');
const binanceCandles = source.ohlcv('binance', 'BTCUSDT');

// Extract closes
const cbCloses = cbCandles.map(c => c.close);
const binanceCloses = binanceCandles.map(c => c.close);

// --- Coinbase Premium Index calculation ---
const premiumPercent = cbCloses.map((cb, i) => {
    const b = binanceCloses[i];
    return ((cb - b) / b) * 100;
});

// Plot premium index
plot.barSeries("Premium %", premiumPercent, ((d) => d > 0 ? color1 : color2)) // Percentage difference

const title = "Candles";
const description = "Simple candles draw";
const indicatorType = "offchart";
const isPublic = true;
const isPublicCode = true;
define(title, description, indicatorType, isPublic, isPublicCode);

const colorBuy = style.color("Buy Color", "#2BB462");
const colorSell = style.color("Sell Color", "#7a3d3f");
const candles = source.ohlcv();
const closes = candles.map(c => c.close);
const opens = candles.map(c => c.open);
const highs = candles.map(c => c.high);
const lows = candles.map(c => c.low);
plot.candleSeries(
    "Candles",
    opens, closes, highs, lows,
    (v, i) => {
        return opens?.[i] > closes?.[i] ? colorBuy : colorSell
    }
);

const title = "Order Book Pressure";
const description = "Bid / ask depth imbalance bands around the price";
define(title, description, "onchart", true, true);

const minBidRatio = input.number("Min bid ratio %", 20, 0, 100, 1);
const minAskRatio = input.number("Min ask ratio %", 20, 0, 100, 1);
const depthFrom = input.select("Depth from", "0%", ["0%", "1%", "2.5%", "5%"]);
const depthTo = input.select("Depth to", "5%", ["1%", "2.5%", "5%", "10%"]);

const bidColor = style.color("Bid fill color", "#a5d6a7");
const askColor = style.color("Ask fill color", "#f1627e");
const extremeColor = style.color("Extreme color", "#ffff00");
const highlight = style.boolean("Highlight extremes", true);
const showRef = style.boolean("Show reference lines", true);

const alertMinRatio = alertInput.number("Alert min |ratio| %", 40, 0, 100, 1);

const bounds = [1, 2.5, 5, 10]; // depth bands in % from the close
const from = parseFloat(depthFrom);
const to = parseFloat(depthTo);

const candles = source.ohlcv();
const depths = source.depths();
const liveBook = source.orderbook();

// orderbook of every candle: depths()[i] is the snapshot of candles[i] (the biggest limit orders), the latest candle uses the live book
const lastIndex = candles.length - 1;
const books = candles.map((c, i) => {
    if (!c) return null;
    if (i === lastIndex && ta.bestBid(liveBook)) return liveBook;
    return depths[i]?.data || null;
});
const closes = candles.map(c => c ? c.close : null);

// imbalance ratio of every band in % (positive = bids dominate, negative = asks dominate)
const ratios = bounds.map((upper, b) => {
    const lower = b === 0 ? 0 : bounds[b - 1];
    return candles.map((c, i) => {
        const book = books[i];
        if (!c || !book) return null;
        const bid = ta.sumBids(book, upper, c.close) - ta.sumBids(book, lower, c.close);
        const ask = ta.sumAsks(book, upper, c.close) - ta.sumAsks(book, lower, c.close);
        const total = bid + ask;
        return total > 0 ? ((bid - ask) / total) * 100 : 0;
    });
});

// a stronger ratio -> a more opaque band, extreme ratios get the extreme color
const bandOpacity = (ratio) => Math.min(0.95, Math.abs(ratio || 0) / 70 * 0.95);
const bandColor = (ratio) => highlight && Math.abs(ratio || 0) >= 63 ? extremeColor : (ratio >= 0 ? bidColor : askColor);

bounds.forEach((upper, b) => {
    const lower = b === 0 ? 0 : bounds[b - 1];
    if (from > lower || upper > to) return; // the band is outside of the selected depth range

    const bidUpper = closes.map(c => c != null ? c * (1 - lower / 100) : null);
    const bidLower = closes.map(c => c != null ? c * (1 - upper / 100) : null);
    const askLower = closes.map(c => c != null ? c * (1 + lower / 100) : null);
    const askUpper = closes.map(c => c != null ? c * (1 + upper / 100) : null);

    if (showRef) {
        plot.lineSeries(`Bid ${upper}%`, bidLower, bidColor, 0.4);
        plot.lineSeries(`Ask ${upper}%`, askUpper, askColor, 0.4);
    }

    // bid pressure: the band is filled only on the candles where bids dominate by more than the min ratio
    plot.bandSeries(
        `Bid pressure ${lower}-${upper}%`,
        bidUpper.map((v, i) => ratios[b][i] >= minBidRatio ? v : null),
        bidLower,
        (upper, lower, i) => bandColor(ratios[b][i]),
        (upper, lower, i) => bandOpacity(ratios[b][i])
    );

    // ask pressure
    plot.bandSeries(
        `Ask pressure ${lower}-${upper}%`,
        askUpper.map((v, i) => ratios[b][i] <= -minAskRatio ? v : null),
        askLower,
        (upper, lower, i) => bandColor(ratios[b][i]),
        (upper, lower, i) => bandOpacity(ratios[b][i])
    );

    // alert on the latest candle
    const latestRatio = ratios[b][lastIndex];
    if (latestRatio != null && Math.abs(latestRatio) >= alertMinRatio) {
        alert.fire(`Pressure ${lower}-${upper}%`, `ratio ${latestRatio.toFixed(1)}%`, candles[lastIndex].startTime);
    }
});