Welcome to GTS Trading 👋

GTS Trading lets you describe market conditions (e.g. "RSI on the 1h is below 30") and then choose what happens when that condition becomes true: get a signal/alert, or open and close positions on a connected exchange (paper or real).

You do all of this without writing code — though you can bring your own C++ or Lua if you want. The main areas, from the top nav:

🖼️Top navigation barscreenshot: full-width nav — Builder · My Expressions · My Strategies · …

This is the thing to understand. They stack:

1. In Builder → Expression Builder, type a condition in plain English and hit Parse. Save it.
2. Switch to Builder → Strategy & Handler. Pick your expression as the entry condition, set the action (alert or open position).
3. Decide: do you just want to be alerted, or do you want it to open/close positions?
4. Deploy it. Start on paper/demo until you trust it.
5. Open Monitor / Signal Monitor to watch fires and positions live.

• Alert: you get notified (in Signal Monitor and any channels you've set up). Nothing is bought or sold.
• Trade (paper): the strategy opens/closes a position on the GTS paper-trading account — a simulated account GTS manages. This is the default and needs no broker.

There are seven ways in, and they all end at the same place — a saved expression in My Expressions. Pick by how you like to work, not by what the expression does: every route reaches the full operand surface.

Worked example: "EMA(50) was below EMA(200) on the previous bar, and is above it now" — an up-cross. It's a good test case because it is a two-bar event, so it can't live in a single condition. Every route below produces the same three expressions.

1 · Quick Create — the fastest, and free

Type it and press Parse:

EMA(50) crossed EMA(200) 1Hour

The parser auto-expands the cross into all three pieces and loads the combiner for review. Clicking Save creates the two legs at the same time. Names are generated for you: EMA_50_below_EMA_200_prev, EMA_50_above_EMA_200_now, EMA_50_cross_up_EMA_200. Use crossed below for the down-cross.

2 · Builder selection — three passes

1. Leg 1: left = Indicators → EMA, period 50, frame 1Hour, History = 1. Operator <. Right = EMA(200), 1Hour, History = 1. Save as EMA_50_below_EMA_200_prev.
2. Leg 2: same two operands with History = 0, operator >. Save as EMA_50_above_EMA_200_now.
3. Combiner: left = User Expression → ..._prev, operator AND, right = User Expression → ..._now. Save.

3 · Quick Template — not usable here

Templates cover a single indicator against a value. A two-bar cross is out of scope — use route 1 or 2. (Templates remain the fastest path for things like RSI(14) < 30.)

4 · Generate with AI — describe it

EMA 50 crosses above EMA 200 on the 1 hour, as three expressions:
previous-bar leg, current-bar leg, and an AND combiner

Spends tokens; no Free-plan allowance. Say "as three expressions" or the model may try to emit one.

5 · JSON Import — full control

Leg 1, with both operands one bar back:

{
  "ExpressionName": "EMA_50_below_EMA_200_prev",
  "Expression_left_ElementType": "GTSIndicators",
  "Expression_left_ElementValue": "EMA",
  "Expression_left_Frame": "1Hour",
  "Expression_left_historyIndex": 1,
  "Expression_left_UseHistoryElem": true,
  "Expression_left_collectionSize": 2,
  "Expression_left_operation": "<",
  "Expression_right_ElementType": "GTSIndicators",
  "Expression_right_ElementValue": "EMA",
  "Expression_right_Frame": "1Hour",
  "Expression_right_historyIndex": 1
}

Leg 2 is the same with historyIndex dropped and operation flipped to >. The combiner references both by name:

{
  "ExpressionName": "EMA_50_cross_up_EMA_200",
  "Expression_left_ElementType": "UserExpression",
  "Expression_left_ElementValue": "EMA_50_below_EMA_200_prev",
  "Expression_left_operation": "AND",
  "Expression_right_ElementType": "UserExpression",
  "Expression_right_ElementValue": "EMA_50_above_EMA_200_now"
}

collectionSize is historyIndex + 1. Free — no tokens, whether you write the JSON yourself or have an external model write it.

6 · Community import — already built

Search the Community tab for EMA_CROSS_UP. EMA_CROSS_UP_CORE is exactly this pattern; EMA_CROSS_UP_STRICT adds a separation filter (EMA_DIFF_NOW_ABS > 0.0002) so tiny touches don't count as a cross. Import and edit freely.

7 · Agent / API — programmatic

POST /api/v1/expressions/validate   # optional dry run
POST /api/v1/expressions            # leg 1
POST /api/v1/expressions            # leg 2
POST /api/v1/expressions            # combiner (references both by name)

Same JSON as route 5, one call per expression, legs before the combiner. See §API.

The quickest way is a Quick Template: pick an indicator, fill in the params, and Save — done. Prefer to type it out in plain English? Use the Quick Create box at the top of the Expression Builder:

1. Type the condition the way you'd say it: RSI(14) < 30 5min or MACD cross above signal 15min.
2. Click ⚡ Parse.
3. The builder fills in below. Give it a name and Save.

Don't know where to start? Click one of the example chips under the box — RSI(14) < 30, SMA(50) > SMA(200) Daily, Close > BBANDS(20).Upper 1Hour — to load it instantly.

What the quick parser understands: LEFT OPERATOR RIGHT with an optional timeframe/symbol — e.g. RSI(14) < 30 5min, RSI(14) crossed 30, MACD cross above signal 15min, RSI(14) < 30 and balance > 100 — or a unary signal: a single operand on its own, like bullish engulfing 5min, hammer 15min, KalmanTrendFilter.trend — or a bare indicator as a value getter, e.g. RSI(14) 5min. Do not write a symbol — expressions on this site carry none; the strategy binds the instrument at deploy. Indicator parameters always need parentheses: RSI(14) parses, RSI 14 doesn't. Wordier or calculated conditions need AI Generate, formula blocks, or JSON. For example, a same-bar 5-minute +2% candle body means 5Min Close >= Open * 1.02 — current 5Min close compared to the same bar's open.

The basic shape is LEFT  OPERATOR  RIGHT with an optional timeframe (no symbol — on the trading side a symbol is applied later, at the strategy) — but Quick Create handles more than that:

• Unary (getter) — a single value on its own, no operator, e.g. RSI(14) or Donchian upper. (A comparison like bullish engulfing > 0 is binary — it has two sides.)
• Compound — type the whole condition and it auto-builds the legs plus combiner: RSI(14) < 30 and balance > 100, 3+ terms, mixed AND/OR with parentheses ((a OR b) AND c), and crossings (RSI(14) crossed 30). Intermediate steps are created automatically on Save.
• Saved-expression refs — reuse a saved expression by name as an operand: My_SignalA AND My_SignalB.

Prefer plain English? The Generate with AI box turns a free-form description into a validated expression. Full syntax reference: Quick Create — NLP Reference.

🖼️Quick Create box with example chipsscreenshot: input + Parse + chips row

Use the Generate with AI box. Describe what you want in everyday language and the AI writes, validates, and loads the expression for you.

1. Type a description: "EURUSD when RSI 14 on 1h is below 30" or "gold 5min close crosses above EMA 200".
2. Press Generate with AI (or Ctrl+Enter).
3. Review what it loaded, then Save.

Use JSON Import ADVANCED at the bottom of the Expression Builder.

1. Have a complete expression JSON object? Paste it in the box and hit Import — it loads straight into the builder.
2. Don't want to hand-write JSON? Click Copy AI Schema Link, paste it into ChatGPT / Claude / Gemini, and ask the model to generate the expression JSON for you.
3. Paste the model's result back here and Import.

Below the Quick Create methods is the visual operand builder for full control:

1. Set the left operand (e.g. an indicator, price, or account value).
2. Pick the operator (>, <, cross above, etc.).
3. Set the right operand (another indicator, or a fixed value).
4. Choose the symbol and timeframe, then Save.

🖼️Visual operand builderscreenshot: left panel / operator / right panel / timeframe

There are 74k+ shared Community expressions you can reuse from the GUI library panel, alongside your own Mine expressions. Agents can access the same expression library through the API.

1. In the left library panel, click the Community tab.
2. Search or browse, then click an expression to preview it.
3. Use Import / Copy to mine — it's added to My Expressions so you can edit it freely.

🖼️Community tab in the libraryscreenshot: ALL / MINE / COMMUNITY tabs + count

• All — everything visible to you.
• Mine — only expressions you created or imported.
• Community — shared by other users; import to reuse.
• Old — archived/previous versions (e.g. items moved aside on a plan downgrade).

The filter chips ANY HELPER ALERT narrow the list by role (next question).

• ALERT Alert expression — a complete condition meant to fire on its own (notify you / trigger a handler).
• HELPER Helper expression — a reusable building block you reference inside bigger expressions. Helpers usually don't fire by themselves; they feed the ones that do.

GTS has 35+ operand types — far more than the basics. Each is an ElementType plus that type's required fields, producing a value or a boolean event you compare. Grouped by family:

Yes. Not every expression is a condition. An expression is one of two things:

In the builder, leave the operator unselected and the preview flips to "Unary getter" — "works as a getter without a binary operator". Save it and it's a named, reusable value. In Quick Create, just type the operand alone: RSI(14) 5min, Donchian upper.

What consumes a getter

Once saved, reference it by name as a User Expression. Three things can consume it:

1. A condition — put a threshold on it: UserExpression.My_RSI_1h < 30. Value in, boolean out.
2. Another getter — combine two values arithmetically: UserExpression.EMA_50 - UserExpression.EMA_200. Value in, value out — still a getter, so it chains as deep as you need.
3. A unary operation — wrap it: ABS, NOT, Max/Min over N, History (N bars back), Z-Score, Momentum, Accel, Pct Rank, Dir Strength. Most return a value; NOT returns a boolean.

A real chain, bottom to top

These ship in the Community library — search EMA_DIFF or EMA_CROSS_UP:

Build bottom-up:

1. Define the atomic value getters first as named, reusable helpers (e.g. a named "RSI 1h" or "ATR band").
2. Compose the upper levels on top by referencing those helpers instead of re-typing them.
3. Combine with AND / OR to express multi-condition logic.

Click an expression in the left library to open the Expression Viewer. It shows the full definition — what it reads, the operator, the symbol/timeframe, and any helpers it references.

• Copy JSON — copy the raw expression JSON (useful to share, version, or feed to an AI model).
• Export — save the definition out (see Share / export).
• Site link — get a link back to the expression.

🖼️Expression Viewer with Copy JSONscreenshot: viewer modal — definition + Copy JSON / Export buttons

As you build, the Expression Preview panel evaluates your expression and shows the result so you can sanity-check it before saving.

1. Build or load the expression in the builder.
2. Look at the Expression Preview panel — it reads "Build your expression above to see a preview here" until the expression is valid, then shows the evaluated value/result.
3. If the preview looks wrong, fix the operands and watch it update.

🖼️Expression Preview panelscreenshot: live preview / evaluate result

Each item in the left library has three icons:

• ✏️ Edit — load it back into the builder to change it.
• 📋 Duplicate — make a copy to tweak without touching the original.
• 🗑️ Delete — remove it from your library.

Open the expression in the Expression Viewer and use:

• Copy JSON — paste the definition anywhere (chat, docs, another account) and re-import via JSON Import.
• Export — save the expression's JSON out as a file. There's also Export all expressions to back up your whole library at once.

Everything you do in the Builder you can also do programmatically with your API key (Settings / Account → API). The versioned endpoints:

Full request/response shapes and auth: API Docs.

1. Make sure the expression is marked as an ALERT (not just a helper).
2. Attach it to a strategy/handler whose action is alert / notify rather than open-position.
3. Deploy it. It now evaluates on live data and notifies you when true.

Every live alert fire is captured in the Signal Monitor database-backed feed/table, including expression, strategy, symbol, time, delivery status, and channel results. Additional delivery channels are configured in your account/settings.

🖼️Signal Monitor feedscreenshot: live fires list

Choose a handler action that notifies but never issues an order. In strategy terms this is a report/alert-only handler — it reports the fire and stops there, so no position is opened even on a real account.

Un-deploy / stop the strategy that carries the expression (from My Strategies or Monitor). The expression stays saved in your library; it just stops evaluating.

1. Open Builder → Strategy & Handler.
2. Pick the symbol. The timeframe is derived from the expressions you select — a default is used only if it can’t be derived.
3. Add the handlers you need: open buy, open sell, close buy, close sell, or alert-only/no trade. Any operation can be left empty.
4. Set the strategy-level parameters: units, max open positions, SL/TP, trailing, hedging, limits, and reporting/alert behavior.
5. Name and Save it — it appears under My Strategies.

🖼️Strategy & Handler builderscreenshot: Strategy & Handler sub-tab

Open My Strategies to see your library. Each strategy shows its symbol, timeframe, the expressions it uses, its handlers, and its current status (saved / deployed). Click one to inspect the full definition.

The strategy library has source tabs so you can also browse strategies that aren't hand-built:

• Config — your own saved strategies.
• Community — strategies shared by others.
• Permutation — strategies generated by a Mass / permutation session.

🖼️My Strategies libraryscreenshot: strategy list with Config / Community / Permutation source tabs + status

1. From My Strategies, open the strategy and choose Edit — it loads back into the Strategy & Handler builder.
2. Change the symbol/timeframe, swap the arm expressions, or adjust the strategy parameters (position size, SL/TP, hedging, trailing).
3. Save to update it.

To experiment without touching the original, Duplicate it first and edit the copy.

This is the key idea. A handler watches its inner expression list and the relation between those expressions (for example AND / OR / sequence). When that handler evaluates true, it emits the signal/action configured on the handler.

You map saved expressions into the handler, choose the relation between them, then choose the handler mode. The rule is identical for all modes: when the handler expression relation evaluates true, that handler emits its configured signal/action. Alert-only is a real handler mode, not a trading operation.

1. Open Builder → Strategy & Handler.
2. Add the expressions the handler should watch and choose the relation between them.
3. Choose the handler mode: open buy, open sell, close buy, close sell, or alert-only/no trade.
4. For trading modes, set the strategy trading controls. For alert-only handlers, configure notification/report behavior and Save.

🖼️Handler modesscreenshot: Open Buy / Open Sell / Close Buy / Close Sell / Alert-only handler options

You don't open it by hand — the engine does it for you. That's the whole point of algotrading: the strategy triggers the position automatically when your condition becomes true. There's no manual "buy" step.

1. Put your entry expression in the Open Bid or Open Ask arm (whichever side you want).
2. Deploy the strategy to a trading account.
3. When that arm's expression evaluates true, the engine opens the position automatically — on the GTS paper-trading account (no real order is ever placed).

How big, and with what risk controls, is decided once at the strategy level — position size, SL/TP, hedging, trailing — not on the arm.

Closing works exactly like opening — you just use the Close Bid / Close Ask arms instead. Any expression you set in a close box can trigger the close; there is no special "exit expression" type.

1. Put the condition you want to close on (e.g. RSI(14) > 70 or an account-P&L condition) into the Close Bid or Close Ask box.
2. When that expression evaluates true, that side's position is closed automatically.

Because it's the same mechanism as open, you can close the bid side and the ask side dynamically and independently, each by whatever expression you choose. (Strategy-level SL/TP and trailing also close positions automatically — those are set once on the strategy, separate from the close arms.)

The Mass Strategies tab generates many strategy permutations at once: expression-handler wiring, symbol/range sets, and parameter sweeps such as RSI thresholds, SL/TP, units, or other user-defined variables. It is how you test a whole grid of ideas instead of building each strategy by hand.

🖼️Mass Strategies tabscreenshot: permutation builder

A strategy is not one position. Max Positions lets it hold several at once, and every one of them is governed by the same strategy-level risk settings — you set the rule once, it applies to position 1 through position n.

The strategy-level fields (Builder → Strategy & Handler):

These numbers are in ticks. The engine measures the move as (price − open price) / tip, so Stop Loss, Take Profit and Tick Diff are all tick counts — which is what makes one setting portable across instruments. (The engine also supports a percent mode for the same thresholds, but it is not exposed in the builder or the API today, so what you set here is ticks.)

If you want a percent stop or target instead, express it as a close handler on LastOpenPositionObject.CurrentProfitPercent — that field is already a percent of the position's own open price, and it works on both sides.

Spacing the entries (using the distance between positions)

Tick Diff Open is the built-in version: price must travel N ticks away from the last entry before the next one opens, which stops a ladder from dumping all its positions on one candle. For anything more specific, build the distance yourself as an expression and put it in the Open handler — e.g. the live price against LastOpenPositionObject.OpenPrice, converted to ticks with Symbol.TicksInPoint, so the spacing rule holds on every symbol.

Closing on any expression you can build

SL/TP are the fixed floor and ceiling. Everything else is an expression in a close handler — Close Bid (CloseHandler1) and Close Ask (CloseHandler2). Whatever you can express, you can close on:

• Profit in percent — last_pos_currentprofitpercent < 0.1 closes when the position gives back below 0.10%. Positive always means winning, for BID and ASK alike, so one expression covers both sides.
• Profit in ticks — last_pos_currentprofitticks > 50.
• Age — last_pos_currentdurationminutes > 60 for a time-based exit.
• Anything else — a pattern, a trend flip, a channel break: if it saves as an expression, it can close a position.

Worked example — a percent take-profit and stop, on both sides

Two expressions, each saved once, then dropped into both close boxes with OR. Because the percent field is signed by side, the same pair governs the long and the short:

Close Bid = POS_TP_0_2 OR POS_SL_0_2. Close Ask = the same two. Set Stop Loss and Take Profit to 0 if this pair is the only exit you want, and remember nothing else will take you out.

What to read when deciding

These are ordinary operands, so they combine with AND/OR like any other condition: add a rung only while fewer than 3 are open AND the account's open PnL is above −500.

1. From My Strategies (or the builder), choose Deploy.
2. Confirm. It begins evaluating on live data; opened/closed positions and alerts appear in Monitor.

1. Go to My Strategies or Monitor and find the running strategy.
2. Choose Stop / Undeploy. It stops evaluating live data and stops issuing alerts/orders.

The strategy definition stays saved — you can re-deploy it later. Undeploying is the safe way to pause something that's misbehaving.

Because GTS never places live orders, a strategy running against a real-mode exchange may only use account-monitoring expressions (e.g. account balance, margin, open P&L). There are no buy/sell orders to place on a real account — only metrics to watch and alert on. A safety guard at deploy time enforces this. Common causes of a block:

• The strategy uses trade/entry expressions that aren't valid against a monitor-only real account.
• The provider isn't connected, has no valid credentials, or isn't Set Active.
• The strategy bundle didn't pass validation (missing handler/expression pieces).

Want order-opening behaviour? Run on the default GTS paper-trading account — paper execution has no such restriction. Use real-mode providers for monitoring + alerting on your actual account.

1. If it's deployed, stop/undeploy it first (see above).
2. From My Strategies, choose Delete on the strategy.

Use Export all strategies to save your strategies out as JSON — a portable backup you can re-import or hand to someone else.

Everything in the Strategy builder is available programmatically with your API key:

Full request/response shapes and auth scopes: API Docs.

Two views:

• Signal Monitor — database-backed alert-fire tables/feed for live conditions and strategies, including delivery status and channel results.
• Monitor — the deep operational view: running strategies, open positions, P&L, status.

🖼️Monitor pagescreenshot: running strategies + positions

1. Open History Requests.
2. Select one or many strategies to test, including Mine / Community strategies or generated permutation packs.
3. Set the allowed history range and run options based on your plan/quota.
4. Submit the run. GTS stages the relevant strategy definitions into the history runtime and executes them as a batch. Submit = start, Cancel = stop.
5. Watch status, then open the reports to compare trades, signals, PnL, win rate, profit factor, drawdown, and top permutations.

Open Charts from the nav for price charts, or SEC Edgar for company filings/fundamentals research. These are read-only research tools — they don't change your strategies.

Look at the top-right of the header — it shows live counters, e.g. 8 / 100000 saved and 2.4k / 100k fires. The kinds of quota:

Open the Plans page from the nav to compare tiers and what each unlocks (limits on saved items, fires, AI tokens, history runs, real-account trading, API access). Upgrade/downgrade from there or the Account → Billing tab.

AI tokens — what each plan includes

Every paid plan comes with a free daily AI-token allotment that resets each day (a per-plan staircase — higher tiers get more, up to 1,000,000/day on the max plan). The Free plan includes no AI tokens, so use the always-free Quick Create there. Tokens are spent only by Generate with AI and in-app AI JSON generation — never by Quick Create, hand-building, or pasting your own JSON.

Need more than your daily amount? Upgrade to a higher plan or wait for the daily reset. The live Plans page shows the exact daily amount for each tier.

If you exceed a cap (or drop to a smaller plan), over-cap saved items aren't deleted — they're archived to a "Previous-Config" area and retained (90 days). Your live items keep working up to the new cap.

1. Upgrade your plan from Plans or Account → Billing.
2. Open the Previous-Config tab to review archived items.
3. Restore the ones you want back into your active library (within the 90-day window).

Settings is where you configure the operating environment around your strategies and alerts:

Open Settings → Providers. Supported providers: Bybit, FXCM, Binance, OANDA. Credentials are stored per-user.

1. On the provider you want, click Configure and enter your API credentials. Pick the mode: Demo or Real (Run Mode).
2. You must explicitly turn it on — flip Set Active on that provider's card. (Set Active stays disabled until valid credentials are saved.)
3. Only one provider is active at a time — activating one switches the others off. Turning the active one off returns you to the GTS default stream + paper trading.

🖼️Settings → Providersscreenshot: Bybit / FXCM / Binance / OANDA cards with Configure + Set Active

Click your avatar (top-right) to open Account. Tabs: Overview, Usage, Security (password / sessions), Billing (plan / invoices), and History.

• Expression / strategy — use the 🗑️ delete icon in its library list.
• Deployed strategy — stop/un-deploy it first (Monitor / My Strategies), then delete.
• Your account — Account → Security/Billing, or contact support@gts-trade.com.

For terminal, IDE scripts, AI agents, Postman, CI, or another backend, use your personal API key with the versioned /api/v1/* API. Send it as X-API-Key: gts_... or Authorization: Bearer gts_....

Browser session cookies are only for the logged-in website UI and same-site browser JavaScript. They are not the normal CLI/agent integration path.

Open API Docs from the nav for examples to create expressions/strategies, run history requests, deploy, and pull stats programmatically.

• Check the LEFT OPERATOR RIGHT shape — a missing operand is the usual cause.
• Candle patterns need a trend and compare > 0 (not == 100).
• Decimal indicator params (e.g. SAR(0.02,0.2)) must use function syntax, not dot-notation.
• Still stuck? Try Generate with AI — it validates as it builds — or check the NLP reference.

The shared expression references helper building-blocks that weren't bundled when it was published, so its dependency closure is incomplete. It's a data issue with that shared item, not your account.

Pick a different community item, or rebuild the logic yourself with the four creation methods in §2.

• Not deployed, or deployed to the wrong account (paper vs real).
• The condition simply wasn't true yet on live data — check Signal Monitor.
• Real-account guard blocked the trade — see §4.
• No exit path, so a position opened but never closed (or vice-versa).
• You hit a fires/quota cap — check the header counters.
• The handler is alert/report-only, so it notifies but never trades by design.