Quick Create — Type in natural language or formula NLP

RSI(14) < 30 SMA(50) > SMA(200) ATR > 100 EMA of RSI Close > BB Upper Indicators.RSI < 30 Close > SMA(200)

Generate with AI — describe the expression; AI builds it, validates it, loads it here

RSI 14 below 30 Close crosses EMA 200 Price move 5t / 10s EMA of RSI RSI + MACD combo

JSON Import — paste a full expression JSON object (advanced) JSON

click to expand / collapse

Expression Name 0 chars

⬅️ Left Side

Element Type

Select an element type above

Operation

Compare

Math

Logic

Right Side ➡️

Element Type

Select an element type above

Unary Operations & Modifiers Optional

Left Side

Right Side

Repeat Condition (Min/Max Bars) Optional

True for at least X bars

Up to X bars maximum

Repeat Timeframe

Expression Preview

Build your expression above to see a preview here

Expression Tree 0 expressions

State Machine Expression

Build a reusable state-machine expression from saved expressions. SEQ = sequential state machine, AND = all must be true, OR = any one true.

State Machine Policy

Getter

Reset Expression

Steps (0)

Click "Add Step" or drag expressions from your library

Custom Code Operand C++

Desktop custom code uses a reviewed custom handler project structure. Select the requested expressions and frames here, then open the full workspace to implement the handler in the allowed user-code files. GTS validates the code and packages it as a reusable expression for your workspace.

Default path: submit code from the desktop workspace and let GTS validate it for you. Advanced path: experienced users may also bring an approved external project when it matches the GTS custom-code contract.

Desktop flow: write the logic, validate it, inspect the result, then use the approved expression directly on this machine.

Requested Expressions

Save expressions first

Drag expressions from the left library or click to toggle them here.

Requested Frames

1Min 5Min 15Min 30Min 1Hour 4Hour Daily

Open Full Code Workspace

Use the separate IDE-style workspace for project files, header/source tabs, generated metadata, compile output, and the shared-library build flow used by GTS desktop and SaaS.

The workspace saves your project and builds an approved runtime handler. Extra uploaded files are workspace inputs only and do not create a second runtime target.

API Reference — Callback Surface

API	Type	Description
`onBarClose(const BarParams& inBar)`	callback	Main bar callback. Use `inBar.symbol`, `inBar.frame`, `inBar.openBidPrice`, `inBar.closeBidPrice`, `inBar.barMaxPrice`, `inBar.barMinPrice`, `inBar.volume`, and the open/close date strings.
`onExpressionValue(const std::string& name, float value, const std::string& date)`	callback	Receives every requested expression update by exact key. Cache `name` and `value` in your user class, then act in `onBarClose(...)`.
`onOpenPosition / onClosePosition`	callback	Optional string callbacks for position lifecycle events passed through the wrapper.
`onObjectDetails / onObjectDoneDetails`	callback	Optional object event strings forwarded by the wrapper if your handler needs them.
`handleTBT / handleChartValue`	callback	Optional tick-by-tick and chart-value callbacks exposed by the wrapper/base class.
`setOpenBid / setOpenAsk / setCloseBid / setCloseAsk`	base-class setters	Raise trade action flags from your user code. The wrapper reads and clears these flags when GTS asks for open/close actions.
`generated/requested_expressions.json`	generated input	Builder-selected expression keys routed into `onExpressionValue(...)`.

Implementation rule: Store incoming values in onExpressionValue(...), evaluate in onBarClose(...), then raise action flags through the base-class setters.

Lua Code Extension Lua

Checking Lua runtime availability...

What this builds: a Lua-backed expression that returns true or false. It is saved as a named expression (for example abc) and is then used exactly like any other expression — nothing is called from the code.
Procedure: select the expressions and bar frames this Lua expression may use, then write one Lua function named evaluate(). No class, inheritance, or special reference is needed. The runtime gives the function a ready-to-use gts object.
Code contract: read inputs with gts.bar("5Min") and gts.expr("DX_14_1m"), calculate your condition, then return only true or false.

Requested Expressions & Frames optional AI infers these from your code — set only to constrain

Code Review Workspace

Write code, test it with sample data, then submit it for review.

Most submissions are reviewed quickly. If something needs attention, you get clear feedback right away — adjust and resubmit, or ask the team to take a closer look.

Test output

Code Submission Status expand to view review progress

Intervals

Loading...

No file open

No file Ctrl+Z undo · Ctrl+Y redo

API Reference — gts_base.lua Getters

How to write the Lua code: define one function: function evaluate(). The runtime provides gts automatically; do not call require(). Inside it, read only the inputs you selected above, such as gts.bar("5Min") for candle data or gts.expr("DX_14_1m") for a saved expression value. Calculate your condition and return true when the signal should fire, otherwise return false. You do not create a class, inherit anything, or connect to the server yourself. After submit, GTS reviews and validates the script, then makes the approved expression available for use.

Getter	Returns	Description
`gts.bar()`	table	Last received bar (any frame): `{symbol, period, open, close, high, low, volume, date}`
`gts.bar("5Min")`	table	Latest bar for a specific frame (not overwritten by other frames).
`gts.bars()`	table	All bars keyed by frame: `{"1Min"=bar, "5Min"=bar, ...}`
`gts.symbol()`	string	Current symbol name this script is handling.
`gts.expr("name")`	number	Expression value by name.
Auto-provisioned getters — no pre-selection needed; call `:value()`
`getInd("RSI","30Min")`	handle	Any indicator (RSI/EMA/MACD/ATR/...). `getInd("RSI"):value() < 30`
`getCdl("ENGULFING","5Min","Bearish")`	handle	Candle pattern (trend Bullish/Bearish); compare `:value() > 0`.
`getPricePattern("BullFlag",10,"5Min")`	handle	Chart pattern formation; `:value() > 0` on OnFormationDone.
`getAshi("DIRECTION","15Min")` · `getRenko("ON_BAR_CREATION","5Min",15)`	handle	Heikin-Ashi / Renko bar fields.
`getAccount("Balance")` · `getOpenPos("TotalUnits")` · `getLastPos("CurrentProfitTicks")`	handle	Account & position metrics (no manual position loops).
`getExt("FvgDetector","15Min")`	handle	Extended/ICT indicators (200). Multi-output → pass a field. `:value() > 0`
`getTickRev("TickRevEvent",10,"Bid")`	handle	Tick-reversal bar (field, tickRevVal, direction). Fields: TickRevEvent, Direction, Close Price…
`getFibo("TickRevRatioEvent",28,100)`	handle	Fibonacci bar (field, tickRevRatio, minLenAB).
`getTrend("FastPrice","5Min",9,21)`	handle	Trend object (field, frame, fastSize, slowSize). Fields: FastPrice, SlowPrice, TrendSide…
`getChannel("UpperChannel","5Min",20,5)`	handle	Channel (field, frame, minWidth, doneTicks). Fields: UpperChannel, LowerChannel, CurrentLeg…
`getPivot("Pivot Point","5Min")`	handle	Pivot levels (field, frame). Fields: Pivot Point, Support 1-3, Resistance 1-3.
`getQuote("Bid")`	handle	Live quote. Fields: Bid, Ask, MidPrice, SpreadInTicks, TicksInPoint, OpenDate.
`getFund("revenue","annual",0)`	handle	Fundamentals (89): revenue, netIncome, epsBasic, operatingCashflow… (field, periodMode, offset).
`getMove("Direction","5Min")`	handle	Price move (field, frame). Fields: onPriceMove, Direction, getCurrentWidth/Speed/Duration.
`getABC("Direction","AB",28,2)`	handle	ABC wave (field, wave, tickRevVal, numElements). Fields: Direction, Distance, Start/End Price…
`getConsensus("SignalA","SignalB")`	handle	Composite score over real selected signal expressions; compare the score (e.g. `:value() > 0.6`).
`getInd("RSI"):zscore():meandev(4)`	handle	Unary history transforms chain on ANY getter: `zscore(n) meandev(n) momentum(n) max(n) min(n) accel(n) pctrank(n) signmomentum(n)`. End with `:value()`.
`gts.has_bar() / has_bar("5Min")`	boolean	True if any bar / specific frame bar has been received.
`gts.has_expr("name")`	boolean	True if expression has been received at least once.
`gts.has_tick()`	boolean	True if any tick has been received.
`gts.has_open() / has_open(id)`	boolean	True if any / specific open position exists.
`gts.has_closed() / has_closed(id)`	boolean	True if any / specific closed position exists.
`gts.tick()`	table	Last tick: `{symbol, bid, ask, volume, date}`
`gts.current_open()`	table/nil	First/only open position, or nil if none.
`gts.last_closed()`	table/nil	Most recently closed position (by closeDate), or nil.
`gts.open_positions()`	table	All open positions keyed by id.
`gts.closed_positions()`	table	All closed positions keyed by id.
`gts.bar_count() / gts.tick_count()`	number	Running counters of received bars and ticks.

C++ Custom Handler C++ · private

Checking code submission availability...

What this builds: a C++ backed expression that returns true or false — same as a Lua one. Use it in a strategy slot, as an alert, or both. If you enable alert + position on the same handler, the position trigger also sends the alert.
Procedure: select the expressions and bar frames this may use, then write one decision that returns a bool. Read inputs inline — no class, no callbacks: bar().closeBidPrice, expr("RSI_14"), getInd("RSI","30Min").value(), hasBar(), hasExpr("name"). After submit, GTS reviews and validates the handler, then makes the approved expression available for use.

Script name shown in review, tabs, and strategy selection

Select saved expressions or getter atoms your code should receive, or write SDK calls like getInd(...).value() directly. GTS auto-provisions SDK calls; selected values are also readable with expr("name"). Selected frames feed onBar() and bar(), so your code can combine GTS signals, prices, and state.

Requested Inputs & Frames optional AI infers these from your code — set only to constrain

Code Review Workspace

Write code, test it with sample data, then submit it for review.

Most submissions are reviewed quickly. If something needs attention, you get clear feedback right away — adjust and resubmit, or ask the team to take a closer look.

Code Submission Status expand to view review progress

Test run = preview, nothing saved

Intervals Start

Loading...

Draft handler

Draft Ctrl+Z undo · Ctrl+Y redo

Test output

API Reference — what you can call

How to write it: you write one decision — just the body that ends in return <true/false>;. No class, no callbacks, no includes — GTS wraps it for you. Read only the saved expressions/getters and frames you selected above. Bar + input values are cached, so you read them inline. You can also write SDK getter calls directly, e.g. getInd("RSI","30Min").value(); GTS resolves them to expression values before compile.

Call	Returns	Description
`bar()`	BarParams	The latest bar. Fields below.
`hasBar()`	bool	True once a bar has been received (guard before reading `bar()`).
`expr("RSI_14")`	float	The latest value of a selected saved expression or getter atom. This is the normal call. UserExpression, LuaScriptOperand, CustomizedUserOperand, and provisioned getters are all selected by saved name. (Returns 0 only at the very start, before its first value — see `hasExpr()`.)
`expr("RSI_14", 50)`	float	Optional: the same value, but returns `50` instead of 0 during that brief start-up window before RSI_14 has produced any value. Use it only if a 0 at start would confuse your logic.
`hasExpr("RSI_14")`	bool	True once that expression has a value.
`getInd("RSI","30Min").value()`	float	C++ SDK getter call. GTS provisions the expression dependency, then `.value()` reads its latest value.
`getCdl("ENGULFING","5Min","Bearish").value()`	float	Candle pattern handle. Compare `> 0` for active.
`getAshi("DIRECTION","15Min").hasMember("DIRECTION")`	bool	SDK metadata helper. Use `.members()`, `.membersCsv()`, and `.print("label")` for discovery/debug.

bar() fields (all float unless noted): symbol (string), frame (string), openBidPrice, openAskPrice, closeBidPrice, closeAskPrice, barMaxPrice, barMinPrice, volume, openDate (string), closeDate (string).

Loading...

Shared

Private (per-user)

History Requests

Runtime Events

Failure Details

Select a case on the left to see its storyline.

Plan distribution

Recent billing events

Per-user totals

Status / channel totals

Recent workflow rows

GTS Monitor loads inside this admin tab.

DB Manager loads inside this admin tab.

Local-only operator tools. Each launcher runs on the SaaS API host; you must be on the same machine for desktop GUIs to appear.

Host processes

Launchers

GTS Monitor GUI

gts_home/GTS_GUI

Launches the desktop GTS monitor binary. Opens on the local X display of the SaaS host.

DB Browser (HTML)

localhost:8788

Opens the running ClickHouse / DB HTML viewer in a new tab.

Open

Containers

docker ps

Jump to the Containers tab to see live shared / per-user docker state.

0

Total Signals

0

Sent

0

Today

0

Failed

0

Deployed Expressions

Quota Period

-

Alert Fires

-

External Sends

-

Selected Range Channels

-

Time	Expression	Strategy	Symbol	Left Value	Op	Right Value	Result	Channel	Status	Actions

Showing 0 of 0

Request Name

From

To

Selected to run Add strategies from the left — the run executes exactly these. 0 strategies0 / 1000 symbols 0 selected

No strategies selected yet — add them from the left.

My History Requests

0 shown

						Result	Actions
No history requests yet. Submit one above.

Plans & Pricing

GTS Trading plans for strategy building, history runs, runtime capacity, and notifications.

First opening period: GTS Trading is available on the Free plan while we refine the first public version.

Free

The built-in open/close position alert — custom expression alerts need a paid plan.

$ 0 /mo

Strategies · 1 (paper)
Open positions · 5 total across strategies
Total saved expressions · 5
Watched symbols · 1
History backtests · 5/mo · 1 year
Open/close position alert · 1
Custom expression alerts · not included
AI tokens · JSON + code generation · not included
In-app alert table · 1,000/mo
Outbound notifications · 10/mo
Email notifications · not included
Telegram delivery
Paper only
Shared free pool
End-of-day deployment
Mass permutations · not included · no sessions retained

Starter

Run up to 10 strategies and backtest up to 3 years of history.

$ 9.99 /mo

Strategies · 10 max
Open positions · 50 total across strategies
Total saved expressions · 50
Watched symbols · 10 · RT or history
History requests · 30/mo max
History depth · 3 years max per supported categories · bars from 1-minute and up
In-app alert table · 10,000/mo
Outbound notifications · 1,000/mo
Email notifications · 30/mo max
SMS · 30/mo to Israel, US/Canada numbers
AI tokens · JSON + code generation · 250,000/day
Standard notification channels
Paper only
Shared paid runtime + history server
End-of-day deployment
Mass permutations · 10/run
latest 1 session retained

Pro

1,000 strategies, 300 backtests/mo, dedicated private infrastructure.

$ 19.99 /mo

Strategies · 500 max
Open positions · 2,500 total across strategies
Total saved expressions · 2,500
Watched symbols · 50 · RT or history
History requests · 300/mo max
History depth · 5 years max per supported categories · bars from 1-minute and up
In-app alert table · 30,000/mo
Outbound notifications · 5,000/mo
Email notifications · 500/mo max
SMS · 100/mo to Israel, US/Canada numbers
AI tokens · JSON + code generation · 500,000/day
Standard notification channels
Paper/demo exchanges · Bybit, FXCM
Account Snapshot formulas + account alerting
Dedicated private container + history server
Immediate deployment for expressions, strategies, history runs, and code
Lua or C++ code expressions
End-of-day deployment
Mass permutations · 1k/run
latest 5 sessions retained

Private

Quant-shop scale: 1k strategies, mass research, all exchanges, exclusive hardware.

$ 39.99 /mo

Strategies · 1k max
Open positions · 5k total across strategies
Total saved expressions · 5k
Watched symbols · 100 · RT or history
History requests · 1,000/mo max
History depth · 10 years max per supported categories · bars from 1-minute and up
In-app alert table · 100,000/mo
Outbound notifications · 10,000/mo
Email notifications · 1,000/mo max
SMS · 300/mo to Israel, US/Canada numbers
AI tokens · JSON + code generation · 1,000,000/day
Private notification channels
Paper/demo exchanges · Bybit, FXCM
Account Snapshot formulas + account alerting
Dedicated private container + history server · exclusive hardware
Lua or C++ code expressions
Immediate deployment for expressions, strategies, history runs, and code
Mass permutations · 5k/run
latest 10 sessions retained

Alerts Comparison

Feature	Free	Starter	Pro	Private
Strategies & expressions
Strategies (saved)	1	10	500	1k
Open positions (total across strategies)	5	50	2,500	5k
Total saved expressions	5	50	2,500	5k
Watched symbols	1	10	50	100
History playback (powered by 12data)
History requests / month	5/mo	30/mo	300/mo	1,000/mo
Depth (calendar reach)	1 year	3 years	5 years	10 years
Concurrency	Shared queue (traffic-dependent)	Shared queue (traffic-dependent)	Immediate private server (1 at a time)	Immediate private server (1 at a time)
Alerts & notifications
In-app alert table	1,000/mo	10,000/mo	30,000/mo	100,000/mo
Outbound notifications	10/mo	1,000/mo	5,000/mo	10,000/mo
Email notifications	—	30/mo	500/mo	1,000/mo
SMS · Israel, US/Canada numbers	—	30/mo	100/mo	300/mo
AI tokens / day (JSON + code generation)	not included	250,000	500,000	1,000,000
Paper trading
Paper trading	Yes	Yes	Yes	Yes
Live trading
Demo exchanges (Bybit, FXCM)
Account Snapshot reports + alerting			Private server only	Private server only
Mass research
Mass permutations	not included	10/run · latest 1 session retained	1k/run · latest 5 sessions retained	5k/run · latest 10 sessions retained
Infrastructure
Runtime container	Shared free	Shared paid	Dedicated private container	Dedicated (exclusive HW)
History server	Shared	Shared	Dedicated (private)	Dedicated (exclusive)
Lua or C++ code submission			Reviewed code expressions	Reviewed code expressions

All quotas are use-them-or-lose-them: daily quotas reset the next day, monthly quotas the next month, and so on per period. Unused allowance does not roll over and is not refunded.

Frequently Asked Questions

Why are helper expressions capped too?

Because helpers still consume shared RT compute. Capping both alerts and helpers keeps one user from overwhelming the shared pool.

Are strategy, history, or trading tools included?

Yes. These plans cover the hosted trading workflow here, including strategy building, history usage, and runtime behavior according to your tier. Live brokerage execution and any separate desktop/runtime products remain distinct.

What does a retained permutation session mean?

A session is one saved result set from a mass-permutation run. The per-run number caps one job size, and the retained-session number caps stored result history. Free retains 0, Starter retains 1, Pro retains 5, and Private retains 10 sessions; submit is blocked at the cap so storage cannot grow without bound.

Verified strategy signals

Marketplace

Follow creators, inspect platform-computed performance, and buy verified signal subscriptions when marketplace billing is enabled.

Live on GTS

Find strategies that actually ran.

Every marketplace listing is designed around GTS-generated evidence: live status, symbol, return, win rate, drawdown, trade history, subscribers, and delivery channels. Free channels: Telegram, Discord, Web Push. Paid add-ons: SMS, Mail / Email.

Before selling

1One symbol per strategy, with at least 3 years of 1-minute history proof.

2At least 10 closed trades executed in that history run.

3Net profitable over the run (a light gate — clearly losing strategies can't be sold).

4At most one open position per side — no pyramiding/stacking.

5Runs at a fixed 10 units; stats are platform-computed from history and can't be edited.

Top live strategies

Marketplace subscriber dashboard

Subscriber Dashboard

Subscriber view for paid strategy subscriptions, delivered alerts, missed delivery attempts, monthly spend, and alert history. Free channels: Telegram, Discord, Web Push. Paid add-ons: SMS, Mail / Email.

0Paid subscriptions

0Alert history

0Missed alerts

$0.00Monthly spend

Subscriptions

Purchased strategies and delivery channels attached to each subscription.

Alert History

All paid alerts for this subscriber, including what was delivered and what was missed.

Marketplace creator plan

Creator Plan

Sell verified live strategy signals from strategies that ran on GTS. You set the signal price, GTS handles delivery and marketplace billing once creator checkout is enabled.

Creator plan

$9.99 / month

Publish strategies, build followers, and sell signal subscriptions from verified platform-run results.

Up to 5 RT marketplace strategies per store
One creator can operate multiple stores
Up to 500 total expressions across marketplace strategies
Creator profile plus verified-live badge
Telegram, Discord, and Web Push signal delivery included
Set per-strategy signal price up to $9.99/mo

Cancel anytime. The dedicated creator billing product still needs backend checkout wiring; Private runtime is the current publishing gate.

Per-creator limits

5RT strategies/store

∞Stores/creator

500Expressions

3Categories

Categories: Crypto, Forex, Stocks. Every paid marketplace strategy is one symbol; units come from the original GTS strategy and are locked for fair comparison.

Signal delivery

TelegramFree channel

DiscordFree channel

Web PushFree channel

SMSPaid add-on

Mail / EmailPaid add-on

Before you can publish and sell

1One symbol · 3-year history proof
Single-symbol strategy that has cleared a completed 3-year, 1-minute-bar history run.

2Minimum 10 trades
At least 10 closed trades executed in that history run (a real track record, not a few lucky fills).

3Net profitable
Profitable over the run — a light gate so clearly losing strategies stay off the shelf.

4One position per side
No pyramiding/stacking — the run must hold at most one open position per side.

5Fixed 10 units · platform-computed stats
Listings run at a fixed 10 units. Returns, win rate, drawdown and positions are computed by the platform from your history — you can't edit them.

6Strategy report attached
The verified history report is attached to the listing as proof for subscribers.

Fees

GTS marketplace commission5%

Payment processorshown separately

Max signal price$9.99 / mo

The $9.99 cap keeps the marketplace accessible and consistent. GTS takes 5% of subscription income.

Example — $9.99/mo subscriber

Buyer pays$9.99

Lemon Squeezy feeshown separately

GTS commission (5%)- $0.50

Seller receivesnet after processor + 5%

0Stores

0Total strategies

0Total trades

+0.00Total made ($)

0 / 0Win / loss strategies

0%Win ratio

0.00Profit factor

+0.0%Total PnL

Strategy PnL

Profit by strategy across all marketplace stores.

Store Updates

Store-level view. Sold products stay locked; draft-only stores can be renamed.

Store Owner Reports

Daily report for the current week. Select a store or a single strategy.

Publish Pipeline

Edit the strategy in My Strategies, move it into a store slot, then submit for marketplace admin review. Approved listings become visible and deployed during EOD.

1 Edit Strategy 2 Move To Store 3 Price + Category 4 Visible + Deployed After Review

Market Arena RT

Running strategy slots for this creator across marketplace stores.

Store Strategies

These are strategies already in marketplace stores. Select rows to move between stores or inspect their stats.

0 selected

Delivery rules

Free Telegram, Discord, Web Push Paid add-ons SMS, Mail / Email

Publish checklist

One fixed symbol Strategy units locked Category set Verified 3-year stats RT shard assigned Once uploaded, listing is immutable Once stats are recorded, listing is immutable Paid buyers keep access until period end unless refunded Payout after period clears, minus 5% commission Cancellation, dispute, or refund can return/hold payout

Account Overview

Your Channels

Loading channels…

Quick Actions

System Parameters — static risk limits for runtime startup

Three levels — per Account, per Symbol, per Strategy — saved before the engine process starts and applied by the runtime/backtest engine as risk-management gates. 0 = no limit (the shared-server default). Changes take effect on the next runtime start/restart, not inside an already-running process.

Free Notification Plans

Free plan notification channels.

Telegram Bot delivery is included on the Free plan.
Email, Discord, HTTP webhooks, and browser push are advanced delivery channels for users on paid plans.

Notification Channels

HTTP Notification Endpoint

Callback URL

GTS will POST alert payloads to this URL

Auth Token

Sent as Authorization header

Fundamental Data API

Pull SEC fundamental data (income statement, balance sheet, cash flow, 10-K/10-Q) over HTTP using your personal key. Paid plans only. Treat this key like a password.

Your API key

—

Example

Rate limit applies per account (default 120 requests/min).

Provider Accounts Configure broker/data provider credentials, demo/real mode, and the active provider used by account monitoring and supported runtime operations.

API Key Agentic access key for Codex, Claude, IDE scripts, CI, and external services using the programmatic /api/v1 API. Treat it like a password.

Send it as the X-API-Key or Authorization: Bearer header on protected calls. The key lets agents create expressions, manage strategies, run history requests, inspect results, and use SDK/code routes according to the API scope. Never share it or commit it.

See the API documentation for endpoints and examples. Regenerating immediately revokes the previous key.

Trading-code SDK routes include /api/v1/getters/types, /api/v1/getters/scan, /api/v1/code/lua/dryrun, and /api/v1/code/cpp/dryrun.

Last Updated

May 6, 2026

1. Scope

These Terms apply to the SignalSaaS web builder, account services, expression library, community import/publish flows, alert delivery features, and related SaaS tools. If you do not agree, do not use the service.

2. No Financial Advice

Content, expression templates, community examples, software output, alerts, and historical tests are provided for informational and tooling purposes only. They are not investment advice. Trading involves risk, including loss of capital.

3. Market Data, Alerts, and Execution Risks

SignalSaaS may connect to third-party chart, data, notification, checkout, auth, hosting, or catalog providers. GTS does not control and is not responsible for:

Data inaccuracies, data delays, missing symbols, or provider outages.
API interruptions, notification latency, duplicate alerts, missed alerts, or blocked delivery.
Software defects, browser storage issues, network failures, or service interruptions.
Trading decisions, order routing, slippage, broker errors, or execution results outside the SaaS builder.

The SaaS builder does not execute live trades. Alerts are notifications, not orders. You are solely responsible for monitoring accounts and verifying any trading activity outside SignalSaaS.

4. Accounts and Access

You are responsible for maintaining the confidentiality of credentials, sessions, API keys, webhook tokens, and notification-channel secrets you configure.
You may not attempt to bypass subscription limits, quotas, licensing, security, or access controls.
You are responsible for expression JSON you create, import, export, publish, or deploy elsewhere.

5. Acceptable Use

No abuse, scraping beyond allowed use, reverse engineering, attack traffic, or interference with service operation.
No unlawful use, including violations of market rules, platform rules, intellectual-property rights, privacy rights, or applicable regulations.
No publishing community content that includes secrets, private account data, unlawful content, or content you are not allowed to share.

6. Payments and Refunds

If paid plans are offered, pricing and plan details are displayed on the Plans, Pricing, or checkout flow. Refund eligibility and timing are governed by the Refund Policy. In case of conflict, the Refund Policy and checkout terms control the refund process.

7. Disclaimer of Warranties and Limitation of Liability

The service is provided "as is" and "as available" without warranties of any kind to the maximum extent permitted by law. SignalSaaS does not warrant that the service will be uninterrupted, error-free, secure, free of defects, profitable, or suitable for any market.

To the maximum extent permitted by law, GTS is not liable for indirect, incidental, special, consequential, or punitive damages, including trading losses, missed signals, missed opportunities, incorrect data, software bugs, outages, or reliance on historical simulation results.

8. No Fiduciary Relationship

Your use of SignalSaaS does not create any fiduciary, advisory, agency, brokerage, partnership, or investment-management relationship between you and GTS.

9. Indemnification, Changes, and Contact

You agree to defend, indemnify, and hold harmless GTS and its operator from claims arising out of your use of the service, your violation of these Terms, your content, or your violation of applicable law. We may update these Terms from time to time. Continued use after changes means you accept the revised Terms. Questions: support@gts-trade.com.

Last Updated

May 6, 2026

SaaS privacy promise. SignalSaaS is a hosted signal-builder and alert-management service. It handles your account, subscription state, saved expression JSON, alert settings, notification channels, symbol selections, and the items you explicitly choose to import or publish through community features. It is not the GTS desktop runtime and it does not execute live trades from this SaaS builder.

What We Collect

Email address, display name, plan, user id, login/session state, and password hash when password login is used.
Billing or subscription references used to manage plan access. Card details are handled by the payment provider, not by the builder app.
Saved expressions, helper expressions, imported community expressions, alert settings, symbols selected for alerts, channel preferences, and exported/imported expression metadata.
Operational records such as quota counters, notification delivery status, diagnostics, security events, browser type, IP-derived request logs, and timestamps needed to operate and protect the service.

What We Do Not Collect

Your broker API keys or trading credentials, unless a future integration explicitly asks for them and you configure it yourself.
Your live positions, orders, broker account contents, or portfolio balances through this SaaS builder.
Live order execution instructions from the SaaS expression builder. Alerts are notifications, not orders.
Private expressions are not published automatically. They are shared only when you deliberately publish, export, or otherwise send them.

How We Use Information

Operate, maintain, and improve the SignalSaaS builder, account services, expression library, symbol catalog, and alert flows.
Process billing, manage subscriptions, enforce plan limits, and maintain expression quotas.
Save, edit, duplicate, import, export, and display expression JSON and related metadata.
Send alert notifications through channels you configure, such as email, Telegram, Discord, phone app delivery, or HTTP webhooks.
Detect abuse, secure accounts, troubleshoot failures, and protect service integrity.

Browser Storage, Cookies & Analytics

The SaaS app uses browser storage for theme preference, login/session state, builder UI state, expression cache, symbol catalogs, community catalogs, and user preference data. See the Cookie & Storage Notice for detail.

We do not sell your personal information. Third-party chart, checkout, auth, or notification tools may use their own cookies when you open those features.

Community & Shared Content

Community expressions are visible to other users. Importing a community expression into Mine creates your own copy with your user id attached to the created expression. Publishing or sharing is a deliberate user action; nothing is published automatically.

How We Share Information

Payment providers, when needed for subscription and billing management.
Authentication providers, only when you choose that sign-in method.
Notification providers, only for channels you configure or test.
Hosting, storage, logging, and support providers needed to run the SaaS service.
Legal or security disclosures if required by law or needed to protect the service.

We do not sell, rent, or trade your personal information.

Data Retention, Deletion & Your Rights

Account and expression data is retained while your account is active, plus what is required for billing, security, operations, and legal compliance.
Operational logs are retained only as long as reasonably needed for diagnostics, abuse detection, fraud prevention, or investigations.
You can export expressions, delete expressions you created, update account details, and contact support for account, correction, access, or deletion requests.

Security, Minors & Contact

Hosted SaaS traffic should be protected with HTTPS/TLS.
Passwords are stored as one-way hashes, never plaintext, when password login is used.
Administrative access is limited and used for service operation, support, and security.
SignalSaaS is not intended for anyone under 18.

Privacy questions and data requests: support@gts-trade.com.

Last Updated

May 6, 2026

Cookies and Similar Storage

The SaaS app may use cookies and/or browser storage, including localStorage and sessionStorage, to keep the builder functioning and remember preferences. This follows the GTS website cookie policy model, with SaaS-specific storage for expressions, catalogs, and alerts.

Typical Uses

Theme preference, selected builder page, form state, and UI preferences.
Session/auth state for logged-in areas.
Cached expression library data, community list state, symbol catalogs, and pattern template metadata.
Notification-channel configuration hints and delivery settings you choose to save.
Basic diagnostics to help prevent abuse and troubleshoot issues.

Third-Party Content

Some pages may embed third-party services, such as charts, payment checkout, or notification providers. Those providers may set their own cookies or storage when their widgets are opened.

Controls

You can clear cookies and site storage in your browser settings. Clearing storage may sign you out, reset theme and builder preferences, and force the app to reload expression, symbol, and community catalogs.

Contact

Questions about cookies and storage on this SaaS app? Email support@gts-trade.com.

Last Updated

May 6, 2026

1. Trial Access

If a SignalSaaS trial is offered, you may evaluate the SaaS builder, expression library, alerts, and account features before subscribing to a paid plan. No charges are applied during a free trial unless the checkout flow clearly states otherwise.

2. Subscription Billing

Subscriptions are billed in advance on a recurring basis, monthly or yearly depending on your selection. You may cancel your subscription to prevent future billing cycles. Cancellation does not retroactively refund previously paid subscription periods.

3. Refunds

Due to the nature of digital SaaS access, subscription fees are generally non-refundable once access has been granted.

If you believe you were billed in error or experienced a technical issue preventing reasonable use of the SaaS builder, contact us for review. Refund requests are evaluated case by case. Nothing in this policy limits rights granted under applicable consumer protection laws.

4. How to Contact Us

To request assistance or a billing review, email support@gts-trade.com and include:

Your account email.
Order, plan, or invoice details.
A brief description of the billing or access issue.

Last Updated

May 6, 2026

Trading Risk

Trading securities, derivatives, foreign exchange, and cryptoassets involves substantial risk of loss and is not suitable for all users. You are responsible for your own trading decisions and risk controls.

No Investment Advice

SignalSaaS provides software for strategy research, signal-expression building, monitoring, historical testing, and alert delivery. Nothing in the SaaS app constitutes investment advice, financial advice, trading advice, tax advice, or legal advice.

GTS does not provide recommendations, signals, or guarantees of profitability. You are solely responsible for your trading decisions and for complying with all applicable laws and regulations in your jurisdiction.

Alerts Are Not Orders

The SaaS builder is an alert and expression-building environment. It does not execute live trades. Alert delivery can be delayed, missed, duplicated, blocked by provider limits, or affected by network and third-party service outages.

No Guarantees

GTS makes no representations or warranties regarding:

Profitability
Performance
Accuracy of results
Data completeness
Market suitability
Past performance and historical tests do not guarantee future results.
Market data, symbol catalogs, pattern templates, and community expressions may be incomplete, delayed, inaccurate, or unsuitable for your use case.

All use of the platform is at your own risk.

Provider and Data Responsibility

Where SignalSaaS connects to third-party data, chart, notification, authentication, checkout, or hosting providers, GTS does not control and is not responsible for provider API failures, data inaccuracies, service interruptions, latency issues, or third-party outages.

Software Limitation of Liability

The platform is provided "as is" and "as available" without warranties of any kind, either express or implied.

Trading losses
Missed opportunities
System downtime
Software bugs
Data errors
Indirect or consequential damages

Feature Availability and Marketing Language

Features may change, be modified, or be removed at any time. GTS and SignalSaaS should be presented as research tools and user-controlled environments. Avoid statements that imply guaranteed performance or profits.

Contact

Questions about this disclaimer? Email support@gts-trade.com.

Open a completed history request to view its monitor here.

What we're building here — in plain English

You have a trading idea — say “alert me when RSI drops below 30” or “buy when price breaks the upper band.”

1 · Expression — turn the idea into one signal: Left OP Right (e.g. RSI(14) < 30). Choose a data source for each side, an operation, and a timeframe.

2 · Handler & Strategy — combine expressions with AND / OR / SEQ and attach an action: fire an alert, open/close a paper/demo position with size and SL/TP, or do both. If alert + position are enabled on the same handler, every position trigger also creates the alert.

3 · Run it — backtest on 10-year, 1-minute history, or go live: alerts to your channels, or paper/demo execution on real markets.

Everything below is the toolbox for steps 1 & 2 — the blocks you snap together. No coding required, and Lua or C++ code acts as the same kind of reusable expression.

AI Services, Agent API & Trading SDK

Full Agent API

External agents can use scoped API keys to inspect schemas, create expressions, submit Lua/C++ logic, run dry checks, control strategies, and read history/report results.

API workflow

Quote-to-Expression AI Parser

Type a trading idea in natural language and GTS converts it into validated expression JSON: indicators, candles, quotes, account fields, position logic, transforms, and strategy gates.

Parser examples

AI Code Generation

The built-in AI, Codex, Claude, or your own service can generate Lua and C++ algo logic using the GTS SDK, then GTS validates, provisions dependencies, and prepares the code for review/deploy.

Code workspace

GTS Algo SDK

One documented SDK contract powers users and agents. Getter families include indicators, candles, trend/channel objects, quotes, account, positions, fundamentals, and transforms.

SDK reference

GTS SDK for Algo Trading

The GTS SDK is the shared programming contract for human developers, the built-in AI, and external agents. It lets strategy code read indicators, candle patterns, market structure, quotes, account state, open/closed positions, fundamentals, and derived transforms without manually wiring every expression dependency.

Lua SDK

Use getter handles such as getInd("RSI","30Min"):value(), getCdl("ENGULFING","5Min","Bearish"):value(), and getOpenPos("TotalUnits"):value().

C++ SDK

Use the same getter contract with C++ syntax: getInd("RSI","30Min").value(), getTrend("TrendSide","5Min",9,21).value(), and certified handler deploy flows.

SDK Discovery API

Agents can call /api/v1/getters/types, /api/v1/getters/fields, /api/v1/getters/describe, and /api/v1/getters/scan before writing code.

SDK Reference

Open the complete Lua/C++ reference for getter families, examples, member fields, transforms, and AI-safe authoring patterns.

Open SDK reference

Quick Start Guide

Build an Alert

1️⃣

Choose Element Types

Pick a data source — OHLC, indicator, candle, quote, account — for each side.

2️⃣

Set Operation

Compare (< > = ≠ ≤ ≥), math (+ − × ÷), or logic (AND/OR).

3️⃣

Pick Channels

Route it to Email · SMS (supported areas) · Telegram · Discord · Web Push · Webhook.

4️⃣

Toggle Alert On

Save — it fires the moment your condition is met. No trade needed.

Build a Strategy

1️⃣

Build Expressions

Combine signals into a handler with AND / OR / SEQ.

2️⃣

Wire Open / Close

Bind handlers to actions: Open / Close · BID / ASK.

3️⃣

Set Symbol & Risk

Position size, SL/TP, hedging, trailing — full position controls.

4️⃣

Deploy (Paper)

Run live against the real exchange — real prices & fills, no real funds.

Account Reports & Monitoring

Build pure alert strategies, alert boxes, periodic reports, and per-position notifications from Account Snapshot formulas. Combine account operands with expression types, unary transforms, repeat windows, and notification channels.

Private Runtime Operands

Private Alerts can add reviewed Lua/C++ logic and account-aware operands. Shared/archive runtimes cannot add these operands.

Report Workflow

Element Types Reference

Expression Patterns — Binary Tree Concept

        ┌───────── ROOT ALERT ─────────┐
        │   RSI_Cross AND MACD_Bull    │  ← Fires notification
        └──────┬──────────────┬────────┘
               │              │
        ┌──────┴──────┐ ┌─────┴──────┐
        │ RSI(14)<30  │ │ MACD > 0   │  ← Child expressions
        │ UserExpr    │ │ UserExpr   │
        └─────────────┘ └────────────┘

  Each expression = binary node (Left OP Right)
  Parent expressions can reference child UserExpressions
  Alerts fire at ROOT level through all enabled channels
  Binary tree depth is unlimited (compose complex signals)

Unary Operations Reference

Extended Indicator Documentation

One-page references for each in-house extended indicator, including logic, output fields, parameter meanings, example rules, and runtime field mapping.

Expression Builder

Generate with AI — describe the expression; AI builds it, validates it, loads it here

JSON Import — paste a full expression JSON object (advanced) JSON

Expression Preview

Expression Tree 0 expressions

State Machine Expression

Custom Code Operand C++

Lua Code Extension Lua

C++ Custom Handler C++ · private

Popular Templates

My Expressions

Admin Console

Shared

Private (per-user)

History Requests

Runtime Events

Failure Details

Plan distribution

Recent billing events

Per-user totals

Status / channel totals

Recent workflow rows

Host processes

Launchers

My Strategies

Sign in to view your strategies.

Signal Monitor

History Requests

My History Requests

Plans & Pricing

Alerts

Free

Starter

Pro

Private

Alerts Comparison

Frequently Asked Questions

Marketplace

Find strategies that actually ran.

Subscriber Dashboard

Subscriptions

Alert History

Creator Plan

Per-creator limits

Signal delivery

Before you can publish and sell

Fees

Example — $9.99/mo subscriber

Store Dashboard

Strategy PnL

Store Updates

Store Owner Reports

Publish Pipeline

Market Arena RT

Store Strategies

Personal Area

Settings

Terms of Service

1. Scope

2. No Financial Advice

3. Market Data, Alerts, and Execution Risks

4. Accounts and Access

5. Acceptable Use

6. Payments and Refunds

7. Disclaimer of Warranties and Limitation of Liability

8. No Fiduciary Relationship

9. Indemnification, Changes, and Contact

Privacy Policy

What We Collect

What We Do Not Collect

How We Use Information

Browser Storage, Cookies & Analytics

Community & Shared Content

How We Share Information

Data Retention, Deletion & Your Rights

Security, Minors & Contact

Cookie & Storage Notice

Cookies and Similar Storage

Typical Uses

Third-Party Content