BRINOVS Block GuideOpen BRINOVS

BRINOVS blocks: Alerts, testing and licensing (45 to 51)

Plain guide to the BRINOVS blocks that keep a trade journal, send alerts, narrate the bot, replay a digit rule on past ticks and license shared bots.

BRINOVS blocks: Alerts, testing and licensing (45 to 51)

This part of the guide covers three menus of the BRINOVS blocks in the Bot Builder: Alerts and logging (blocks 45 to 47), Testing (block 48) and Brinovs identity and licensing (blocks 49 to 51). The first two menus are for you, the person who builds and watches a bot. The third menu is for bots that are shared through the BRINOVS Plug & Play library. All three menus sit inside the BRINOVS menu of the Blocks list.

A few words used below. A tick is one new price from the market. A stake is the money you put on one trade. A trade (or contract) is one purchase. A trade is settled when it has finished and its result is known. The Journal is the log panel of the Bot Builder, where the bot writes messages to you. A CSV file is a plain table file that opens in Excel or Google Sheets. Like all Deriv blocks, a BRINOVS block only works when it sits inside one of the four main blocks: 1. Trade parameters, 2. Purchase conditions, 3. Sell conditions or 4. Restart trading conditions.

Nothing here promises profit. These blocks record, warn, test and protect shared bots. They do not make a strategy win.

Alerts and logging (blocks 45 to 47)

These three blocks tell you what the bot did, and why. Trade journal keeps a saved record you can download. Alert shows you a message when something you care about happens. Bot narration says in plain words what the bot is doing as it goes. They write and show messages inside the app, and nothing leaves it except files you choose to download. One block has a stronger power: an Alert can also pause new purchases if you tick its box. A normal order is to switch the Trade journal and Bot narration on in Run once at start, and to place Alert blocks where the event happens.

Trade journal

  • Kind: BRINOVS custom, block #45
  • Type id: bnv_trade_journal
  • Shape: Action block
  • Where it goes: inside any of the four main blocks, in the middle of a stack of action blocks. "Start recording" belongs in Run once at start of 1. Trade parameters. It can be used more than once (for example one to start, one to write notes).
  • What it does: Keeps a record of what the bot did that is still there after you refresh the page. You can add notes of your own and download everything as a CSV file.
  • Inputs:
    • Trade journal: start recording (put it in Run once at start), write a note, download as a CSV file or clear the saved journal (default: start recording).
    • note text (for "write a note"): a text socket (the toolbox gives my note).
  • How it works: Once recording is on, the bot writes one row for each of these: bot started or stopped, a buy request, a purchase that was refused (with the rule and the reason), the contract id, a buy that failed, a settlement with its profit, a sell, a market change and a batch result. Rows of one purchase are linked by a request id, and each row carries the bot version. Ticks and balance updates are not recorded. Tokens and secret links are never written. The last 5000 rows are kept, and the same row twice within 2 seconds is written once.
  • Example:
┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Trade journal:                                           │
│     [ start recording (put it in Run once at start) ▾ ]    │
│     note text (for "write a note") ( "my note" )           │
└────────────────────────────────────────────────────────────┘

From now on the bot logs every buy, refusal and result. The real block shows "Trade journal:" and the choice on one row.

  • Good to know:
    • "write a note" with an empty text stops the bot with a message ("the note is empty").
    • A phone browser may block the CSV download. The journal stays saved, so you can download it later from a computer.
    • If the browser storage is full or blocked, the bot keeps running and says so once in the log. Some rows may then be missing.
    • "download" with nothing recorded only tells you the journal is empty.

Alert

  • Kind: BRINOVS custom, block #46
  • Type id: bnv_alert
  • Shape: Action block
  • Where it goes: inside any of the four main blocks, in the middle of a stack of action blocks, usually under an if. It can be used many times.
  • What it does: Shows you a message in the Journal, with live values filled in, and an optional sound. It can also pause new purchases. An alert alone does not stop anything.
  • Inputs:
    • message: a text socket. Use {time}, {balance}, {currency}, {session_pl} (net result of real trades this session) and {runs} where you want live values. Any other {word} stays as you typed it. The toolbox gives Session result {session_pl} {currency} after {runs} runs.
    • severity: info, warning or critical (default info). It changes the colour and the sound.
    • channel: in the app or in the app with a sound (default in the app).
    • at most once every (N) seconds: a number socket (toolbox 60). The first alert always goes out.
    • also pause new purchases until the bot restarts: a tick box, off by default. It switches itself on when you pick critical (you can change it after).
  • How it works: The bot fills in the live values and shows the message. The same alert (same text, severity and channel) is shown at most once per the seconds you set. With the tick box on, every later purchase is refused until you stop the bot and run it again.
  • Example:
┌─ 3. Sell conditions ───────────────────────────────────────┐
│ if  < ... a rule you built ... >                           │
│ then  Alert: message ( "Net {session_pl} {currency}" )     │
│       severity [ critical ▾ ]                              │
│       channel [ in the app with a sound ▾ ]                │
│       at most once every ( 60 ) seconds                    │
│       also pause new purchases until the bot restarts ☑    │
└────────────────────────────────────────────────────────────┘

When the rule is true, you see and hear a critical message with the session result, and the bot buys nothing more until you restart it.

  • Good to know:
    • It does not send messages outside the app. For Telegram, use the Notify Telegram block that Deriv already provides.
    • An alert does not enforce a limit. Only the tick box makes it a real pause, and that pause only covers new purchases.
    • The bot stops with a message if the text is empty or longer than 300 characters, or the seconds are not a number from 0 to 86400.
    • The pause needs the BRINOVS execution layer (the part that buys for the bot). If it is switched off, an alert with the tick box on stops the bot with a message.

Bot narration

  • Kind: BRINOVS custom, block #47
  • Type id: bnv_bot_narration
  • Shape: Action block
  • Where it goes: inside any of the four main blocks, in the middle of a stack of action blocks. "Start" belongs in Run once at start of 1. Trade parameters. It can be used more than once.
  • What it does: The bot tells you, in plain words, what it is doing: it started, what it is buying, what a rule refused and why ("skipped: ..."), how a trade ended (won or lost), what it sold, a market change, and the stop. It only talks. It changes nothing in the bot.
  • Inputs:
    • Bot narration: start telling me what you do (put it in Run once at start), say my line, download the last 200 lines or clear the saved lines (default: start).
    • my line (for "say my line"): a text socket (the toolbox gives skipped: payout below minimum).
    • detail: beginner (short) or pro (ids and rule names) (default beginner).
  • How it works: After "start", the bot listens to what happens and writes a line for each event. Beginner keeps lines short. Pro adds contract ids, request ids, rule names and smaller steps. To keep it readable, only one line is shown every 2.5 seconds; the others wait in a short queue of up to 20. If too many pile up, the oldest minor ones are dropped and counted ("n lines were left out"). The same sentence twice within 10 seconds is shown once. The last 200 lines are kept and can be downloaded as a text file.
  • Example:
┌─ 2. Purchase conditions ────────────────────────────────────┐
│ if  < ... a rule you built ... >                            │
│ then  Bot narration: [ say my line ▾ ]                      │
│       my line (for "say my line") ( "skipped: payout low" ) │
│       detail [ beginner (short) ▾ ]                         │
└─────────────────────────────────────────────────────────────┘

When the rule is true, "BRINOVS says: skipped: payout low" appears in the Journal (after any waiting lines).

  • Good to know:
    • "say my line" with an empty line stops the bot with a message. A line is cut at 200 letters.
    • Tokens and secret links are never written.
    • A busy bot can show lines a few seconds late, because of the one-line-per-2.5-seconds rule.

Testing (block 48)

Testing means trying a rule on past prices instead of risking money. The one Testing block replays a simple digit rule over the latest stored ticks of a market. Everything it shows is simulated: it buys and sells nothing and does not touch your real trade history. Use it in a separate test bot, never in the bot that trades.

Replay test (simulated)

  • Kind: BRINOVS custom, block #48
  • Type id: bnv_replay_test
  • Shape: Action block
  • Where it goes: inside any of the four main blocks, in the middle of a stack of action blocks, normally in Run once at start of a test bot. It can be used more than once.
  • What it does: On the block it reads "Replay test (SIMULATED)". It plays one digit rule over the latest ticks of a market, one tick at a time, and writes the result to the Journal. The last trade log is saved and can be downloaded as a CSV file.
  • Inputs:
    • action: run the test or download the last trade log (default run).
    • market (empty = the traded market): a text box, empty by default. Letters, digits and _, for example R_100.
    • contract: Over, Under, Matches, Differs, Even or Odd (default Over).
    • prediction digit: a number socket (toolbox 4); Over 0 to 8, Under 1 to 9, Matches and Differs 0 to 9; Even and Odd ignore it.
    • stake: a number socket above 0 (toolbox 1).
    • ASSUMED profit on a win (percent of the stake): 1 to 1000 (toolbox 95). A loss loses the whole stake. Deriv's real payout differs, so this is your assumption.
    • contract length (ticks, 1 to 10): toolbox 1.
    • ticks to test (100 to 1000): toolbox 1000.
    • warm-up ticks (no trades): 0 up to the ticks to test minus 50 (toolbox 50).
    • development period (percent of the ticks): 10 to 90 (toolbox 70). The rest is the evaluation period.
    • buy: at every chance, after this digit (below) or after this many equal digits in a row (below) (default at every chance).
    • digit, or number of equal digits, for the rule: toolbox 5. For "after this digit" it is 0 to 9; for "equal digits in a row" it is 2 to 10.
  • How it works: The bot asks Deriv for the latest ticks (at most 1000) and plays the rule on them. It never looks at a later tick when it decides. It reports the development period (where you may tune the rule) and the evaluation period (the honest one) apart, with trades, wins, losses, win rate, net result, biggest drop and longest losing streak. It also tells you the win rate you need just to break even with your assumed payout.
  • Example:
┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Replay test (SIMULATED): [ run the test ▾ ]              │
│   market (empty = the traded market) [ R_100 ]             │
│   contract [ Over ▾ ]                                      │
│   prediction digit (Even and Odd ignore it) ( 4 )          │
│   stake ( 1 )                                              │
│   ASSUMED profit on a win (percent of the stake) ( 95 )    │
│   contract length (ticks, 1 to 10) ( 1 )                   │
│   ticks to test (100 to 1000) ( 1000 )                     │
│   warm-up ticks (no trades) ( 50 )                         │
│   development period (percent of the ticks, the rest is    │
│     the evaluation) ( 70 )                                 │
│   buy [ after this digit (below) ▾ ]                       │
│   digit, or number of equal digits, for the rule ( 5 )     │
└────────────────────────────────────────────────────────────┘

The Journal gets lines starting "BRINOVS replay (SIMULATED, not real trades)", one for each period, plus the break-even win rate and warnings.

  • Good to know:
    • It warns you when Deriv gave fewer ticks than asked, when ticks are missing, and when a period has fewer than 30 trades (too few to mean anything).
    • It describes what a rule would have done in the past. It does not say what the rule will do next. A rule tuned on the same ticks it is judged on looks better than it is, so trust the evaluation period.
    • It needs a connection and the BRINOVS execution layer (the part that buys for the bot, on unless switched off) to read ticks. If the ticks cannot be read, or too few come back, nothing is tested.
    • The bot stops with a message if a number is outside its range, a market name has odd characters, or the market box is empty and the traded market is not known.

Brinovs identity and licensing (blocks 49 to 51)

These three blocks are not for everyday personal bots. They are for bots published through the BRINOVS Plug & Play library. Plug & Play is the tab where clients load bots, free ones and premium ones, that the developer has put there. The developer (the person who publishes the bot) adds the three blocks to the bot. When the developer publishes the bot, the BRINOVS platform writes a seal into the BRINOVS core block. The seal is made from the bot's blocks.

A client who loads the bot can change the numbers (for example the stake, take profit or stop loss). The client cannot change the blocks: adding, removing or rearranging blocks, picking a different dropdown choice or changing a text makes the bot count as changed, and a changed bot does not buy. Premium bots are also loaded in a locked mode, where they cannot be saved, downloaded or have blocks moved or deleted. The three blocks go in Run once at start of 1. Trade parameters and are not preloaded in a fresh Bot Builder, so a personal bot never carries them.

All three work on new purchases only. They never block the Stop button, never block selling, and never stop the bot watching contracts that are already open. An honest limit: anything that runs in a browser can be changed by an expert. Together with locked mode and the BRINOVS server, these blocks make copying and misuse hard and traceable, not impossible.

BRINOVS core

  • Kind: BRINOVS custom, block #49
  • Type id: bnv_brinovs_core
  • Shape: Action block
  • Where it goes: only in Run once at start of 1. Trade parameters. A bot has exactly one.
  • What it does: Says who the bot is: its id, its version and the BRINOVS app version it needs. When the developer publishes the bot on the platform, the platform writes the seal into the manifest box. If the bot is changed after that, it no longer matches its seal and does not buy.
  • Inputs:
    • bot id: a text box, default my-bot. 3 to 64 letters, digits, - or _, starting with a letter or digit.
    • version: a text box, default 1.0.0. Three whole numbers with dots.
    • needs app version (..) or newer: a text box, default 1.0.0. Three whole numbers with dots, or empty.
    • manifest (written by the platform when published): a text box, empty by default. Leave it alone: the platform fills it in.
  • How it works: When the bot starts, the block works out a fingerprint of the bot's blocks and compares it with the seal in the manifest. Positions, folding and plain numbers are not part of the fingerprint, so moving blocks around and changing numbers is fine. A bot with no manifest (not published) just says who it is. If this page is older than the app version the bot needs, the bot stops and asks you to reload.
  • Example:
┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   BRINOVS core: bot id [ brinovs-over4 ]                   │
│   version [ 1.0.0 ]                                        │
│   needs app version [ 1.0.0 ] or newer                     │
│   manifest (written by the platform when published)        │
│     [ v1:9f2c...:Qm8x... ]                                 │
└────────────────────────────────────────────────────────────┘

This bot calls itself brinovs-over4, version 1.0.0. The manifest shown is shortened here; the platform writes the full seal.

  • Good to know:
    • If the bot was changed after publishing, the Journal says so and every purchase is refused with "Nothing was bought". Load the bot again from Plug & Play.
    • The bot stops with a message if the id or version is badly written, if the manifest is damaged, if the bot has two core blocks with different ids, or if the app is too old.
    • The bot id in the Licence gate and Remote switch blocks must be the same as here.
    • This is a seal, not a lock. It makes casual changes useless; it cannot stop an expert who controls his own browser.

Licence gate

  • Kind: BRINOVS custom, block #50
  • Type id: bnv_license_gate
  • Shape: Action block
  • Where it goes: only in Run once at start of 1. Trade parameters, next to BRINOVS core, with the same bot id as the core block.
  • What it does: Decides if this bot is free or premium. A premium bot asks the BRINOVS server, every time it starts, whether the client who is logged in may run it now. Without a yes, the bot places no new purchases.
  • Inputs:
    • bot id: a text box, default my-bot. Same rules as in BRINOVS core.
    • this bot is: free or premium (default free).
    • a pass lasts at most (N) hours: a whole number from 1 to 72 (toolbox 12). It also applies when the server cannot be reached.
  • How it works: Free: nothing is checked. Premium: the bot asks the server. The server knows who the client is from his Deriv login, and decides from the access the developer gave (by login id or by a code). Yes gives a pass for at most the hours you set. No (no access, expired, revoked, or a changed copy of the bot) gives no new purchases, with the reason and the way to get access. A pass that runs out while the bot runs is renewed at the next purchase, at most once a minute.
  • Example:
┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Licence gate: bot id [ brinovs-over4 ]                   │
│   this bot is [ premium ▾ ]                                │
│   a pass lasts at most ( 12 ) hours (also when the server  │
│     cannot be reached)                                     │
└────────────────────────────────────────────────────────────┘

A client with access gets a pass of up to 12 hours. A client without access sees the reason in the Journal, and no purchase is made.

  • Good to know:
    • If the server cannot be reached, a pass from the last hours still works. Without one, there are no new purchases until it can be reached.
    • A "no" tells the client to open Plug & Play and use "Chat with dev / Request code".
    • The server decides, never a claim made by the browser. The bot only sends its id, version, fingerprint and seal, plus which of the client's accounts runs it.
    • The bot stops with a message if the id is bad, the hours are not a whole number from 1 to 72, or the id differs from the core block's id.
    • A developer can also switch on a free trial of 10 runs for demo accounts; the server decides that.

Remote switch

  • Kind: BRINOVS custom, block #51
  • Type id: bnv_remote_kill_switch
  • Shape: Action block
  • Where it goes: only in Run once at start of 1. Trade parameters, next to BRINOVS core, with the same bot id as the core block.
  • What it does: Lets the developer switch the bot off from the BRINOVS server, for one bot, one client, one version or all of them. The bot checks the switch when it starts and every N minutes.
  • Inputs:
    • bot id: a text box, default my-bot. Same rules as in BRINOVS core.
    • check every (N) minutes: a whole number from 1 to 1440 (toolbox 10).
    • if it cannot be checked: keep trading or stop new purchases (after two missed checks) (default keep trading).
    • when it is switched off: stop new purchases or stop new purchases and sell the open contracts (default stop new purchases).
  • How it works: Switched off: no new purchases, with the developer's message in the Journal. If you chose to sell, the bot also tries to sell the open contracts once; any that cannot be sold settle by themselves. Switched on again: the bot trades again. If the switch cannot be checked, it either keeps trading or stops new purchases, as you chose. With the stop choice, the bot also stops new purchases when no check has ever worked, or none has worked for two rounds.
  • Example:
┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Remote switch: bot id [ brinovs-over4 ]                  │
│   check every ( 10 ) minutes                               │
│   if it cannot be checked [ keep trading ▾ ]               │
│   when it is switched off [ stop new purchases ▾ ]         │
└────────────────────────────────────────────────────────────┘

The bot asks the server every 10 minutes. If the developer switches it off, it makes no new purchases.

  • Good to know:
    • Open contracts are always still watched, and the Stop button always works.
    • The bot stops with a message if the id is bad, the minutes are not a whole number from 1 to 1440, a choice is missing, or the id differs from the core block's id.
    • It is a rule on new purchases. It cannot stop a determined expert who controls his own browser.
BeforeBRINOVS blocks: Control, state and statistics (38 to 44)

Build a bot with these blocks

BRINOVS is free to open. Sign in with Deriv, open the Bot Builder, and try everything on a demo account.

Open BRINOVS

BRINOVS Digits is a free bot builder and trading page built on Deriv's Bot Builder. Trading carries risk and you can lose money. Nothing in this guide is financial advice or a promise of profit. Test every bot on a demo account first.

Guide home · Open BRINOVS