Oak is the scripting layer on NEXUS, similar to native scripts like TradingView’s Pine Script: an indicator or a strategy is a short piece of plain JavaScript over the candles, run in a sandbox in your own browser. If you have written Pine, you already know most of it. This page maps the concepts, migrates one strategy end to end, and says plainly what Oak does not do.

Have a Pine script already? Press From Pine… in the Oak editor and paste it. A Pine Script v4, v5 or v6 indicator or strategy is converted for you, in your browser: the Pine never leaves the page. The Oak it writes walks the bars one at a time the way Pine runs, so close[1], var and every ta.* call keep their own history and give the numbers Pine gives. Boxes, lines and labels (box.new, line.new, label.new, and moving or deleting them afterwards) come across as what is standing after the last bar; so do tables, and a linefill between two level lines. Anything it cannot convert — another symbol or timeframe through request.security, arrays, polylines, and the stops and targets of strategy.exit — is listed by its Pine line number, so a partial conversion says it is partial. The rest of this page is for writing Oak by hand, which is shorter and easier to read than what the converter writes.

1 · What an Oak script is

A function body. It receives three things and hands back one object:

//@oakversion=1
// candles: [{ t, open, high, low, close, volume }, ...]  oldest first
// params:  { fast: 9, slow: 21 }   whatever you declared, as numbers
// ta:      sma, ema, rsi, stdev, close, high, low, open, volume
const c = ta.close(candles);
return {
  pane: "overlay",                       // or "separate"
  lines: [{ name: "EMA", data: ta.ema(c, params.length), color: "#00f5ff" }],
  histogram: undefined,                  // { name, data, up, down }
  patterns: undefined,                   // [{ kind, points: [{ i, price }], label }]
  signals: undefined,                    // [{ i, side: "long"|"short"|"flat", price?, note? }]
  boxes: undefined,                      // [{ from, to, top, bottom, color?, label?, open? }]
  segments: undefined,                   // [{ from, to, price, price2?, color?, label?, style?, open? }]
  labels: undefined,                     // [{ i, price, text, color?, below? }]
  events: undefined,                     // [{ i, text, kind?, price? }]  not drawn: what "Alert on events" fires on
  tables: undefined,                     // [{ position: "top_right", bg?, cells: [{ col, row, text, color?, bg? }] }]
};

The first line, //@oakversion=1, is the version of the Oak contract the script was written for — what //@version=5 is to Pine. It is a comment, so it costs nothing; the editor adds it if it is missing, and a script that declares a version this site does not run is refused with a sentence rather than failing inside.

Every series is an ordinary array the same length as candles, with null where a value does not exist yet (an EMA of length 20 is null for the first 19 bars). There is no hidden time series type, no [1] history operator, no var persistence — you index the arrays yourself, and a loop is a loop.

The sandbox is the point. A script runs in a Web Worker inside a null-origin frame with fetch, XMLHttpRequest, WebSocket, storage and importScripts removed from the prototype chain, a fresh scope per run, a 2-second budget, a 64 KB source limit and a 200,000-point output cap. That is why a script written by a stranger is fine to add to your chart: it can reach the bars it is given and nothing else — not the page, not your wallet, not the network. The server never runs a script.

2 · Pine → Oak, concept by concept

3 · One strategy, migrated

The EMA cross, in Pine:

//@version=5
strategy("EMA cross", overlay=true)
fast = input.int(9, "Fast")
slow = input.int(21, "Slow")
f = ta.ema(close, fast)
s = ta.ema(close, slow)
plot(f, color=color.aqua)
plot(s, color=color.red)
if ta.crossover(f, s)
    strategy.entry("L", strategy.long)
if ta.crossunder(f, s)
    strategy.entry("S", strategy.short)

The same thing in Oak — this is the library's own EMA cross strategy, unchanged, with {"fast": 9, "slow": 21} in the params box:

//@oakversion=1
// Long when the fast EMA crosses above the slow one, short when it crosses
// below. One decision per cross, made on the bar that closed the cross.
const c = ta.close(candles);
const fast = ta.ema(c, params.fast), slow = ta.ema(c, params.slow);
const signals = [];
for(let i = 1; i < c.length; i++){
  if(fast[i] == null || slow[i] == null || fast[i-1] == null || slow[i-1] == null) continue;
  if(fast[i-1] <= slow[i-1] && fast[i] > slow[i]) signals.push({ i, side: "long", price: c[i] });
  if(fast[i-1] >= slow[i-1] && fast[i] < slow[i]) signals.push({ i, side: "short", price: c[i] });
}
return { pane: "overlay", lines: [
  { name: "Fast", data: fast, color: "#00f5ff" },
  { name: "Slow", data: slow, color: "#ff2d78" },
], signals };

Paste it into the Oak editor under the chart (the Oak tab), press Run on chart, and the two lines and the triangles appear. Save keeps it under My scripts in the indicator picker; Share… puts it in a Stack and in the picker's Community group for everyone.

4 · What Oak does not do

• No multi-timeframe requests. A run sees one series: the chart's symbol and timeframe. A script that needs the 1h trend while drawing on 5m does not exist yet.
• No state between runs. Every run starts from the bars. That is a feature — a script cannot quietly depend on what it saw last time — and it means there is no var.
• No drawing API beyond lines, fills, levels, a histogram, patterns, signals, boxes, segments, labels and tables. No polygons, and nothing a script draws can be dragged: it is the script's answer and changes when the bars do.
• No orders. A strategy produces decisions; it places nothing. A signal alert can post to a webhook your bot listens on, or make a paper trade in an isolated paper wallet on that alert's market. Real orders are your bot's business, with your keys.
• No server-side execution of your own code. Seven of the built-ins — the EMA cross and 9/13/9 strategies, and a Use as strategy rule on an unedited EMA, SMA, RSI, MACD or Bollinger Bands — run on Nexus as their settings, so their signal alerts keep firing with your browser closed. An edited or custom script, and every other built-in, runs only in your browser's sandbox, so its alert fires while a chart with it is open. NEXUS does not run your own code on its server.
• Two seconds. A run that takes longer is stopped and the legend says so. Every library script runs in well under that on 5,000 bars.

5 · Sharing and alerts

Share… from the editor or from an indicator's settings posts the script — name, code, inputs, params, pane — to a Stack thread with the chart as it was, and lists it in the picker's Community group. Anyone can read the code, add it to their chart (it runs in their sandbox, and their chart measures its own checks), star it, fork it from the editor, and see which version they run when you publish a new one. Every version's text is kept.

For a strategy, Alert on signals… in its settings window delivers each closed-bar signal to a webhook, a paper trade, Discord and email. The details are on the webhooks page.

Nothing on this page is a claim about what any script will do on a market. A strategy's numbers in its settings window are a plain walk over the bars on screen, and say so.

A strategy on your chart can tell your bot when it signals. Three steps: put a strategy on the chart, set an alert with your bot's URL and a message in the shape your bot expects, and receive it — signed, once per closed bar. Strategies, and the webhooks and signal feed they deliver to, come with a paid plan: Essential runs 3 at a time and Pro 5. The webhook is the signed instruction; your receiving bot decides whether to place an order. Direct exchange connection inside Nexus remains locked during review.

1 · Three steps

• Put a strategy on the chart. Open the indicator picker (fx on the rail) and pick one from Strategies, or write your own in the Oak editor: a script that produces signals (how). Triangles appear at its signals.
• Set the alert. Click the strategy in the legend to open its settings and press ⚡ Alert on signals…. Paste your bot's https URL, write the message (a JSON template is filled in for you), add a secret if your bot checks signatures, and choose whether to also paper trade. The modal shows the message exactly as your bot will receive it.
• Receive it. On every bar that closes with a signal, our server queues one delivery of your rendered message. If the message is JSON it is sent as application/json; otherwise as text. Transient failures retry with the same delivery and signal IDs, so your receiver can safely recognize a repeat.

2 · The message and its placeholders

The message is a template, the way TradingView's alert message is. Placeholders are replaced when the alert fires; a number renders as a number, a string is escaped for JSON but not quoted (the template holds the quotes), and an unknown placeholder is left as written so a typo shows up in your bot's log rather than as a silent blank.

The default message:

{"source":"nexus","strategy":"{{strategy}}","symbol":"{{symbol}}","timeframe":"{{timeframe}}",
 "action":"{{action}}","price":{{price}},"barTime":{{barTime}},"signalId":"{{signalId}}"}

Your bot wants a different shape? Write it. A token your bot checks can go straight in: {"token":"your-long-random-token","side":"{{action}}"}. A one-line text message works too: {{action}} {{symbol}} @ {{price}}.

3 · A receiver you can paste

This receiver checks the timestamp-bound signature, rejects messages older than five minutes, and writes each delivery to a durable inbox once. It responds quickly; a separate worker can process only rows whose state is pending and use the delivery ID as its venue idempotency key. Synthetic tests are stored as test, never pending.

import hmac, hashlib, json, sqlite3, time
from flask import Flask, request, abort

SECRET = b"the secret you typed into the alert"
DB = "nexus-inbox.db"
app = Flask(__name__)

with sqlite3.connect(DB) as db:
    db.execute("""create table if not exists inbox (
      delivery_id text primary key, body text not null,
      received_at integer not null, state text not null)""")

@app.post("/hook")
def hook():
    body = request.get_data()
    header = request.headers.get("X-Nexus-Signature-V2", "")
    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
    stamp, supplied = parts.get("t"), parts.get("v1", "")
    try:
        fresh = stamp and abs(int(time.time()) - int(stamp)) <= 300
    except ValueError:
        fresh = False
    if not fresh:
        abort(401)
    want = hmac.new(SECRET, stamp.encode() + b"." + body, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(supplied, want):
        abort(401)
    json.loads(body)  # reject a malformed JSON message
    delivery = request.headers.get("X-Nexus-Delivery", "")
    if not delivery:
        abort(400)
    state = "test" if request.headers.get("X-Nexus-Test") == "true" else "pending"
    with sqlite3.connect(DB) as db:
        row = db.execute("insert or ignore into inbox values (?,?,?,?)",
                         (delivery, body.decode(), int(time.time()), state))
    return ("queued" if row.rowcount else "duplicate"), 200

The URL must be https and reachable from the internet: a server of your own, or a tunnel (Cloudflare Tunnel, ngrok) in front of a machine at home. Our server will not post to localhost, private addresses or anything that resolves to them — that is a safety rule on our side, not a setting. Redirects are not followed; each request has a ten-second timeout. Network failures, 408, 425, 429 and 5xx responses retry with backoff. Other non-2xx answers are recorded as terminal failures in Automation.

Discord is a different door: set a Discord webhook once under Alerts and your price and book alerts land in that channel as a sentence, and so do a strategy’s signals while a chart with it is open (signals the server fires with your browser closed go to the app, your webhook and paper, not to Discord). A trading bot should use the alert's own webhook, above.

4 · Paper trades instead of, or as well as

Tick Paper trade it on the alert and each signal also trades your paper BTC account: long buys the share of your paper USD you chose, short and flat sell all the paper BTC held. The trade appears in your paper record with source: oak:<strategy>, and in your public receipts if you publish them. Paper trading is BTC only; on any other market the checkbox says so.

5 · A bot on your own computer: the signal feed

A webhook is NEXUS sending to your bot, so your bot needs an address the internet can reach. A bot on your own computer usually has none, and NEXUS will not send to localhost or a home-network address. The signal feed turns that round: your bot asks NEXUS for new signals every few seconds, the way it asks an exchange for prices. Nothing has to reach your computer, so there is no tunnel or server to set up.

• Make a key in the Alerts panel under Local bot feed. It is shown once; NEXUS keeps only a fingerprint of it. Replace key cuts the old one off at once.
• Every strategy alert you have is in the feed, whether it ran on NEXUS or in your browser, and whatever else it sends to.
• Old signals are never sent. The first call gives your bot a starting point, next, and no signals. Pass next back as after every time and nothing is missed or sent twice. A bot that loses its place starts again from now, not from history.
• Ask every 15 seconds or slower. Faster than about 8 times a minute is refused for a minute.
• A 503 means wait, not stop. Now and then NEXUS cannot reach its database for a moment. The answer is then 503 with a Retry-After in seconds: wait that long and ask again with the same after. Nothing is lost, because your place only moves when you pass a new next.

import time, requests

KEY = "nxf_your_key"
URL = "https://nexuspolydex.com/signals/feed"
after = None                        # keep this on disk to survive a restart

while True:
    params = {} if after is None else {"after": after}
    r = requests.get(URL, params=params, headers={"Authorization": "Bearer " + KEY}, timeout=15)
    if r.status_code == 200:
        page = r.json()
        for s in page["signals"]:   # oldest first
            print(s["action"], s["symbol"], s["timeframe"], s["price"], s["strategy"])
            # place your order here; s["signal_id"] is unique, so remember the
            # ones you acted on and skip any you see again
        after = page["next"]
        time.sleep(page.get("poll_seconds", 15))
    elif r.status_code == 503:      # a moment's hiccup: same after, nothing lost
        time.sleep(int(r.headers.get("Retry-After", 15)))
    else:
        time.sleep(60)              # a bad key, or asking too often

Each signal has action (long, short or flat), symbol, timeframe, price (the close of the signal bar), bar_time (that bar's open, in milliseconds), strategy, alert_id and signal_id. Check bar_time before you act: a signal your bot only sees an hour late is an hour old.

6 · When it fires, and when it cannot

• Once per closed bar. The bar still forming is never used — a signal on it can still change. Two tabs, a rebuild, a reload: the server keeps the bar time on the alert, and a second ask for the same bar is a no-op.
• On the alert's symbol and timeframe. An alert set on BTC 5m watches BTC 5m. Switch the chart and it waits.
• Seven built-ins run on Nexus; your own script runs in your browser. The EMA cross and 9/13/9 strategies, and a Use as strategy rule on an unedited EMA, SMA, RSI, MACD or Bollinger Bands, travel to the server as their settings, so Nexus can evaluate them after each closed bar and a webhook fires at 3 a.m. with your browser shut. You do not switch this on: it simply happens where it can. Every other built-in, and an edited or custom script, is code, and code runs in your browser's sandbox — so the browser is what notices its signals, and closing every tab stops them. The alert row says which applies. On its server NEXUS runs only settings it wrote, never your scripts.
• Fire once, then stop is a checkbox for a one-shot alert; otherwise every signal bar fires.

A signal is a script's decision about the bars it saw. It is not advice, and nothing about it is a claim about what a market will do. What you connect to the other end of the webhook, and with what money, is entirely yours.

Market structure, order blocks, fair value gaps and liquidity sweeps are common trading vocabulary with no single agreed definition: two charts drawing "order blocks" on the same candles will often disagree. So this page states the exact rule each NEXUS tool follows. Every one is an Oak script you can open and read (the Code button in its settings), and what is written here is what that script does.

1 · Nothing is drawn before it is known

One rule holds every tool on this page. A mark appears only once the bars that prove it have closed, and once drawn it is never moved or taken back. A zone can end; it cannot change shape or vanish from the past.

This matters because the easy way to draw these concepts looks better than it is. A swing high is only a swing high once later bars have failed to exceed it. A tool that marks it the moment it forms is reading bars that had not happened yet, and its history shows marks that were never there when the bar was live. Ours appear late instead, and stay.

What is drawn is often anchored in the past: a zone starts at the candle that made it, which may be several bars back. That is where it belongs. It still only appears once it is known.

2 · Swing highs and lows

Four of the tools are built on swings, and they all use the same definition.

• A swing high is a bar whose high is above the high of every one of the N bars before it and the N bars after it. A tie is not a swing.
• A swing low is the mirror: a low below the lows of the N bars each side.
• N is the Swing length setting, 5 by default. A larger number finds fewer, larger swings.
• It is known N bars late. With a swing length of 5, a swing is marked when the fifth bar after it closes, and not before.

3 · Market Structure: BOS and CHoCH

• Swing labels. Each swing high is marked HH (higher high) if it is above the swing high before it, otherwise LH (lower high). Each swing low is HL (higher low) or LL (lower low) the same way. The first of each is plain H or L.
• A break is a bar that closes beyond the most recent swing: above the last swing high, or below the last swing low. A wick through the level is not a break. Each swing can be broken once.
• BOS (break of structure) is a break in the direction the last break went: the move continued. The very first break on the chart is a BOS.
• CHoCH (change of character) is the first break against the direction of the last one. It is drawn dashed.
• The line runs from the swing to the bar that broke it, at the swing's price.

4 · Order Blocks

• When one is made. At a break (section 3). A break upward makes a bull order block; a break downward makes a bear one.
• Which candle. For a bull block: the last down candle (close below open) before the breaking bar, searching back no further than the swing low the move started from, and no further than 60 bars. For a bear block: the last up candle, back to the swing high. If there is no such candle, no block is made.
• The box is that candle's whole range, high to low, wicks included.
• When it ends. A bull block ends on the first bar that closes below its low; a bear block on the first close above its high. Price trading into the box, or wicking through it, does not end it.
• Ended blocks are hidden unless Show ended blocks is on.

5 · Fair Value Gaps

• A bullish gap is three candles where the low of the third is above the high of the first. The middle candle moved through that span without the candles either side overlapping in it.
• A bearish gap is the mirror: the high of the third is below the low of the first.
• The box is exactly that span, from the first candle's high to the third's low (or the reverse), starting at the middle candle. It is drawn when the third candle closes.
• Smallest gap. A gap is kept only if it is larger than 0.25 of the 14-bar ATR, so the noise of ordinary bars is left out. Set it to 0 to see every gap.
• Filled means price has traded through all of it: a later low at or below the bottom of a bullish gap, or a high at or above the top of a bearish one. A partial dip into the gap leaves it standing, at its original size.

6 · Liquidity Sweeps, equal highs and lows

Stop orders tend to rest just beyond swing highs and lows. This tool tracks the last 20 swing highs and the last 20 swing lows that price has not yet traded beyond.

• A level is taken the first time any bar trades beyond it (a high above a swing high, a low below a swing low). It is then removed from the list, whatever happens next.
• A sweep is a level taken by a bar that closes back inside: its high went above the swing high and its close is below it. The level was reached and price did not hold beyond it. It is marked "Sweep" with a dashed line back to the swing.
• A bar that closes beyond the level took it without sweeping it. Nothing is marked.
• Equal highs (EQH) are two untaken swing highs within 0.1 of the 14-bar ATR of each other, joined by a dotted line. Equal lows (EQL) are the same for swing lows.

7 · Premium / Discount Range

The highest high and the lowest low of the last 50 bars, and the midpoint between them (the "equilibrium"). The upper half is called premium and the lower half discount. It says where price sits inside its own recent range, and nothing more: it is not built on swings and involves no judgement.

8 · Support and Resistance

• A level starts at the price of a swing high or swing low.
• A later swing joins it if its price is within 0.5 of the 14-bar ATR of a standing level. That counts as another touch. The level keeps the price of its first swing, so a line never moves once drawn.
• It is shown once it has 2 touches (the Touches needed setting).
• It ends when closes move from one side of it to the other by more than that same tolerance. An ended level is removed.
• R or S is only where the level sits now: above the latest close is R, below is S. The same level changes letter when price moves past it without closing clean through.

9 · Previous High / Low / Close

The high, low and close of the previous day, week or month, drawn across the current one. Periods are UTC, because these markets do not close; a week starts on Monday. Nothing is drawn for the first period on the chart, since there is no period before it.

10 · Events and alerts

Six of these tools also report events: the moment something on this page became known. In a tool's settings, ⚡ Alert on events tells you when one happens, for any event or one kind.

• An event belongs to the bar that made it known, not the bar it is anchored to. A BOS event is on the bar that closed beyond the swing.
• Once per closed bar. The bar still forming is never judged.
• From now on. A new alert never fires for something already on the chart when you made it.
• With your browser closed, for the tools as they ship. An alert on one of these tools, unedited, on a Hyperliquid perpetual (not the stock, index and other contracts listed by other Hyperliquid venues), runs on NEXUS from its own copy of the rules above, so it fires whether or not you have a chart open. An alert on a copy you have edited, or on a Kraken market, runs in your browser instead, and fires while a chart with the tool on it, on that market and timeframe, is open in a tab. The tool's settings window says which.
• It is an alert, and counts as one. It uses one of your alert slots, like a price alert. It sends the in-app notification, and your Discord hook and email if you have set them. It places nothing and sends no webhook: that is what a strategy's signal alert is for.

11 · What these tools are not

• They are not the same as another site's. A tool with the same name elsewhere may use a different swing rule, count a wick as a break, or shrink a zone as price enters it. If two charts disagree, compare the rules, not the pictures.
• They do not know who traded. "Order block" and "liquidity" are names for patterns in candles. Nothing here sees orders, stops or who placed them. For what actually rested in the book and what actually traded, see Market Depth and Order Flow.
• They are descriptions of the bars. A mark says a rule was met. It is not advice, and it is not a claim about what a market will do next.

Every rule above is a setting or a line of code you can change. Open a tool's settings, press Code, and edit your own copy; the Oak reference covers the boxes, segments, labels and events these scripts return.