DEV Community: Nyria

Evaluate an options alert service before you pay

Nyria — Thu, 22 Oct 2026 20:41:20 +0000

Originally published at nyria.io.

Every options alert service looks the same from the outside: a price, a screenshot, a channel you cannot see into. This guide is how to grade one from the inside, with its own posts, on a paper account that costs nothing, before a month's fee or a single live order. It ranks no services and names none.

What a usable alert contains

Five fields. An alert missing any of them is a trade idea, and a bot cannot place a trade idea.

Ticker The underlying, written as the exchange lists it: SPY, not "spiders". A call with no ticker is commentary.
Side and action Call or put, and whether the post opens or closes. BTO, STC and the rest, or plain words such as "out of SPY calls here". An exit that is implied, not posted, cannot be counted and cannot be traded.
Strike The exact strike, as listed. A strike that is not on the chain gets no contract, and a bot checks the chain rather than rounding for the caller.
Expiry Month and day. A call with no expiry takes the nearest listed expiration, which can be today's, even late in the day. If the caller leaves the date off, that is the trade they are posting.
Price The price the caller got. Without it there is nothing to compare a fill against, and the record is a list of tickers.

The notation does not matter; the fields do. Paste a week of the room's posts into the alert tester and see which ones read as an order and which get a refusal. Nothing is traded and no account is needed.

A worked example: one call, graded

An entry and its exit as a room would post them, and the three numbers a paper bot gives you for each.

Entry, posted at 9:47

BTO SPY 775c 11/20 @ 1.85

Exit, posted at 10:12

STC SPY 775c 11/20 @ 2.40

The paper bot reads the first as buy to open the SPY 775 call expiring Nov 20, sized from its own budget per entry, and the second as sell to close. Its Logs tab stamps the alert and the order, so for each call you hold three numbers side by side: the price the caller posted, the time the post arrived, and the price the paper bot filled at. Over a few weeks that table is the track record.

Grade it on paper, not on a screenshot

Run the service on a free paper bot for a few weeks and let the caller's real posts fire. Two ways in. If the caller publishes the calls as a Nyria strategy, subscribe and deploy a bot on Nyria Paper. If you run the server or the Telegram group, link it under Integrations, create a strategy with that channel as the alert source, and add an author filter so only the caller's posts count.

Read the paper numbers for what they are. Nyria Paper fills a market order at the quoted bid or ask, so it pays the spread but never slips, and a limit exit inside the spread fills at once at its own price. Paper P&L reads better than live. A service that cannot hold up on paper will not hold up live; one that does has passed a test, not every test.

Count the exits. A position closes only when a post reads as an exit, so calls the caller never closed in writing stay open in the paper account, and they would stay open at your broker.

Fill timing: a person versus a bot

The caller fills first, then types. A reader then sees the post, opens the broker and types again. That is two gaps, and a bot removes only the second one. Discord and Telegram stamp every message, so compare the caller's posted price with where the contract was trading at the stamp. A gap of seconds is normal. A gap of minutes, on a contract expiring today, is the whole edge.

A bot does not wait for a better price either. On Telegram, an entry Nyria handles more than a minute after it was posted is not placed at all; the strategy log says so, and a close in the same message still runs. Whatever the source, the paper fill tells you what the post was worth by the time anything could act on it.

Red flags

A promise about returns A percentage on a banner is a claim, not a record. The only record you can audit is the channel history: scroll it, count the entries, match each to its exit, and note the ones that never closed.
No exits posted A room that posts entries and leaves the exit to you is half a service, and the half you cannot grade. Partial exits and trims count if they are posted every time.
Alerts that change after the fact An edited or deleted post is a different record from the one that was traded. Nyria does not read an edit again, and editing or deleting a post after it trades does not undo the order, so what the bot logged is what was posted at the time.
A track record that is a screenshot A picture of a month's P&L shows one account on one day. It does not show which calls were skipped, which were closed late, or what a reader could have filled at.
Calls mixed into chat Alerts in a channel of their own, from one author, in one notation, can be read at a glance and by a bot. A channel where calls, chat and screenshots share the stream is slower to read by eye and harder for anything else to read at all.

Going live later, with your own broker

When the paper table holds up, deploy a bot on the live account, or edit the paper bot and pick the live account. The first live deploy asks you to accept the risk disclosure. Orders go to Charles Schwab, Tradier, tastytrade or Alpaca, in your own account, and the money never leaves your broker.

Paper did not test slippage, partial fills, broker rejections or assignment, so start with a budget per entry you can afford to lose in full, and hold capital for both the entry and the exit.

Questions

Can Nyria read a paid Discord I only belong to?

No. Nyria reads channels in servers you run, and groups or channels you administer on Telegram. If the caller publishes the calls as a Nyria strategy, you subscribe to it and deploy a bot in your own account.

How long should the paper test run?

Long enough to see the service in more than one kind of week. The docs ask for one to two weeks of paper before a first live bot; for grading a service you are about to pay for, a few weeks is a fairer sample.

What does the test cost?

Nothing. Paper is free. Live trading from $15 a month.

Grade an alert service on a paper bot

Start a paper bot free.

No-code trading bot: stock and option alerts in, orders out

Nyria — Thu, 22 Oct 2026 20:18:15 +0000

I write code for a living, and the trading setup I actually run has no code in it. The signal lives in a TradingView chart. The alert is one line of text. The thing on the other end turns that line into an order at my broker. I used to run a VPS with a Flask app in the middle, and I don't miss it.

Disclosure: I build Nyria, which is the thing on the other end here. Everything below is how it actually behaves, including the parts that will annoy you.

Where the alert comes from

Three sources, one destination.

TradingView: an alert on an indicator or a strategy, with the strategy's webhook URL pasted into the alert's webhook field. The message can be plain text.

Discord or Telegram: a channel in a server or group you run. It reads the posts, with an author or keyword filter so chatter does not trade. The post can name the contract itself.

Anything that can POST to a URL: TrendSpider, a Zapier step, your own scanner.

The alert for a stock, or for an options strategy that picks its own contract, is this:

SPY long entry

and the exit is this:

SPY long exit

That is the whole template. Ticker, direction, action. JSON works too if your source speaks it, but for a chart alert I use text so I can read it in the TradingView alert log.

The strategy is a form, and the form decides four things

What each alert does. Four alert kinds: long entry, long exit, short entry, short exit. Under Long behavior and Short behavior you say whether an entry opens a position, closes the other side, or does nothing, and whether exits close. A long-only setup can treat short entries as its exits, which is handy when the indicator only knows "flip".
How the option contract is picked. "From my rules": one to four legs, each finding its strike by delta, by price, by strikes from the money, or by offset from another leg, with buy or sell, call or put, and a DTE range. "Provided in alert": the message names the strike and expiry (Discord, Telegram, your own bot).
Order type, duration and limit target. Market or limit, set separately for entries and exits on each side. A limit takes its price from Bid, Ask, Mid, a custom number, or the price in the alert. Duration is Day, GTC or FOK. Tradier has no FOK, so FOK goes there as Day.
Trading window and stacking. "Limit trading hours" drops entries outside your window and still lets exits through. "Allow multiple entries" is off by default, so a second entry on an open position is skipped and logged, not stacked.

The bot is the strategy on one account with one budget

Deploying a bot is: pick a connected account, set a budget per entry. That is it.

Stocks size in whole shares. $500 on a $50 stock buys 10. Options size per contract, and a contract is 100 shares, so a $2.00 premium costs $200: a $500 budget buys 2 and leaves $100 unspent. If one contract costs more than the budget, the deploy is refused up front when a live quote shows it. You cannot deploy a bot that can never trade.

The same strategy on a second account is a second bot, with its own stats.

A real one, start to finish

Strategy: options, From my rules, one leg: Buy, Call, 0.40 delta, 14 to 31 DTE. Long behavior: Enter position, with Close on exit alerts on. Entries limit at Ask, exits limit at Bid, Day. Bot on the built-in paper broker, $500 per entry.

SPY long entry arrives at 10:14. The bot picks the listed SPY call closest to 0.40 delta inside 14 to 31 DTE with a live quote. The ask is $2.00, so it buys 2. SPY long exit at 2:50 sells the 2 it holds.

What breaks, from my own logs:

No contract inside the DTE range within 0.25 of the target delta: entry skipped, nothing placed, the Logs tab says so.
Options market closed: the options alert is refused. Stocks on the built-in paper broker fill at any hour, which makes an evening test look fine and a 9:25 AM live alert fail.
An exit arrives and nothing is tracked as open, because the bot was paused or I closed by hand at the broker: logged as Skipped, not Failed. It tracks what it placed, not your whole account. Give it an account of its own.
Two alerts 100 ms apart can arrive out of order. To flip, send one reversing alert, not an exit and then an entry.

Paper first, and what paper does not prove

The built-in paper broker is free, up to 10 bots. A market order there fills at the quoted bid or ask: it pays the spread, never slips and never partially fills, so paper P&L reads better than live. What a paper run proves is that the alert fires, the text is read the way you meant, each exit closes its entry, and the quantity is what you expected. It cannot see a broker rejection such as an options approval level.

For the broker's own rejections, connect the broker's paper account instead. Alpaca paper takes an API key generated with the dashboard toggled to Paper; keys start with PK, and a live AK key is refused on paper. Tradier sandbox takes the sandbox account number and token from developer.tradier.com, runs on 15-minute delayed data, and on weekends marks resting limit orders as filled at prices that never traded. Read Tradier sandbox results on weekday regular hours only.

Run a week or two. Then deploy on the live account, or edit the bot to point at it. The first live deploy makes you accept the risk disclosure.

What it will not do

Market and limit orders only. No stop or stop-limit, no bracket, no OCO, no trailing stop. A position closes when an exit alert arrives, or when an opposite entry is set to close it, and that is the entire exit model. No futures, no forex; an index alert trades as an option. No guessing at "thinking about SPY?", which places nothing. And no opinion on whether the strategy makes money.

Live brokers: Charles Schwab, Tradier, tastytrade, Alpaca. Paper is free; live is from $15 a month. The strategy settings are documented here. To run the SPY example above on a paper bot, start on Nyria.

Send alerts from your Python script to your broker

Nyria — Thu, 22 Oct 2026 19:47:43 +0000

I run a couple of scanners in Python. For a long time their output was a Telegram message to myself, then me opening the broker app and typing the order by hand. The script knew the trade thirty seconds before I did, and I was still the slow part.

Disclosure up front: I build Nyria, and the webhook in this post is its webhook. I also use it exactly this way, which is why the gotchas below are specific.

What the script sends

One HTTPS POST per alert, to a URL that belongs to one strategy:

https://trades.nyria.io/webhooks/{token}

The token is 64 lowercase hex characters and it is the only authentication. No Authorization header, no HMAC signature, no IP allowlist. Treat the URL as a secret. If it ends up in a screenshot or a repo, rotate it from the strategy's Integration tab. The old URL dies instantly, so every sender you pointed at it needs the new one.

The body is JSON. The smallest one that places a trade is two fields:

{"ticker": "AAPL", "action": "buy"}

I don't send that one from a script. buy is read against the strategy's state: on a long-only strategy it opens a long, but on a strategy that trades both sides it covers an open short first and only otherwise opens a long. From code I want to say exactly what I mean:

{"ticker": "AAPL", "action": "OPEN", "direction": "LONG", "order_type": "market"}

action is OPEN or CLOSE (MODIFY and CANCEL exist for working limit orders). direction is LONG or SHORT. order_type is market or limit, and it is only read on an alert that names action and direction like this one; on anything else the strategy's default applies. price is the limit price when you send limit.

There is no quantity field. I tried. quantity and notional are ignored on an entry; size always comes from the bot's budget per entry. Duration (Day, GTC, FOK) is a strategy setting too, not an alert field. The one exception is MODIFY, which can re-size a working order on Tradier and Alpaca.

Options are a separate case. If the strategy is set to "From my rules", the alert is the same as above and the strategy picks the strike and expiry. If it is set to "Provided in alert", you send a legs array with symbol, side, action, strike and expiration per leg, up to 4 legs.

The sender

import requests

WEBHOOK_URL = "https://trades.nyria.io/webhooks/REPLACE_WITH_YOUR_TOKEN"

payload = {
    "ticker": "AAPL",
    "action": "OPEN",
    "direction": "LONG",
    "order_type": "market",
}

r = requests.post(WEBHOOK_URL, json=payload, timeout=10)
r.raise_for_status()
body = r.json()
if body.get("status") == "processed":
    print("alert accepted, handed to the bots")
else:
    print("not acted on:", body)

A good response looks like this:

{
  "status": "processed",
  "webhook": true,
  "originalAlert": "...",
  "structuredAlert": {"instrument": "AAPL", "action": "OPEN", "direction": "LONG"}
}

Two things in that script I got wrong the first time.

raise_for_status() only catches 4xx and 5xx. A rejected alert and a duplicate both come back as 200 with a status that is not processed. Check status too, or your script logs a green tick on a trade that never happened.

timeout=10. The endpoint answers fast, but a hung socket on your side stalls the whole scanner loop and the next three alerts queue behind it.

To close: same ticker, "action": "CLOSE", "direction": "LONG". It closes the whole tracked position. There is no partial close through the webhook.

What the responses mean

200 with status: processed. Read and handed to the bots. Not a fill. The bot's Logs tab shows what the broker did.
200 with rejected: true. The strategy is not Active (draft, paused, archived).
200 with status: rejected. Ticker not in the strategy's list, that direction turned off, or nothing open to close. The reason is in the body.
200 with status: duplicate. See below.
400 or 404. Bad or unknown token. Copy the URL again.
413. Body over 256 KB.
422. Unusable alert: missing field, unknown symbol, no strike in the DTE range, more than 4 legs. userMessage says which.
429. Burst limit is 10 at once, then 1 per second. Honor Retry-After.
503. Temporary, usually market data. Retrying is safe.
500. Everything else. The strategy's Logs tab has the reason.

If there is no row on the Logs tab at all, the request never arrived: wrong host, http instead of https, or a proxy ate it. One exception: a duplicate is only logged once every 5 minutes, so a missing row can also be a repeat.

The duplicate rule, and the scale-in it ate

An identical body within 30 seconds is a duplicate. So is an identical body within 5 minutes if nothing else came in between. Only the first one trades.

That saved me when requests retried after a flaky connection. It also silently dropped a second scale-in I sent 90 seconds after the first with the same payload. The response was 200 with status: duplicate, which my script was not checking at the time.

The fix is a unique metadata.message_id per intended order:

payload["metadata"] = {"message_id": f"scalein-{int(time.time())}"}

Dedup matches on that id when it is present, and on a hash of the whole body when it is not.

The broker sandbox gotcha

I test against three paper accounts and they behave differently, which matters when a test "passes".

The built-in paper broker fills or refuses every order instantly. A limit order never rests there, so MODIFY and CANCEL have nothing to act on. Test those against a real broker's paper account.

Alpaca paper: generate the keys with the dashboard toggled to Paper. A paper key starts with PK, a live key with AK, and each only works on its own endpoint. Paste a live key into the paper slot and the connection check fails; Alpaca answers 401 to a key on the wrong host. Outside market hours an Alpaca paper market order sits as accepted until the open, which is correct, and which confused me the first Sunday I tried this.

Tradier sandbox: it connects with the sandbox account number and access token from developer.tradier.com, not a tradier.com login. Its data is 15 minutes delayed, and on weekends it marks resting limit orders as filled at prices that never printed. A Friday 3:59 PM limit can show as filled on Saturday morning. The API reports it as a fill, so the bot records a fill and waits for an exit. Judge Tradier sandbox runs on weekday regular hours only.

Before the first real post

Paste the body into the alert tester. It shows the order it would build, or the exact refusal text. No account, nothing traded. Then paste the same body on the strategy's Integration tab as the example for that trade type and select Check format. The strategy only goes Active after that passes, and an inactive strategy answers every post with rejected.

Then point the script at a paper bot, send one OPEN, open the bot, and look at the quantity on the order. That number is your budget per entry divided by the price, floored to whole shares. If it is what you expected, you are done.

Every field and a curl example per broker is in the webhook payload reference. Paper bots are free, up to 10, no card. Start on Nyria.