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:

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.

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), Close > BB Upper — to load it instantly.

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.

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.

There are tens of thousands of shared expressions you can reuse.

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.

• 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:

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.

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.

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.

Fires show up in the Signal Monitor in-app feed. Additional delivery channels are configured in your account/settings.

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 an entry handler: choose your expression as the trigger and the action (open position / alert).
4. Add an exit handler: a condition or TP/SL that closes the position.
5. Name and Save it — it appears under My Strategies.

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.

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 strategy has four handler arms, each with its own expression box:

You map any saved expression into each arm's box. The rule is identical for all four arms: when that arm's expression evaluates true, that arm's operation fires. Open and close work exactly the same way — close is not a special case.

1. Open Builder → Strategy & Handler.
2. For each arm you want active, pick an expression in its box (leave arms you don't need empty).
3. Set that arm's policy and zone, then Save.

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 variations of a strategy at once — e.g. the same logic across many symbols, or sweeping a parameter (RSI 20/25/30…). It's how you test a whole grid of ideas instead of building each by hand.

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 — a clean feed of conditions firing.
• Monitor — the deep operational view: running strategies, open positions, P&L, status.

1. Open History Requests.
2. Select the strategies to test (from Mine / Community / your permutation sessions).
3. Submit the run. Submit = start, Cancel = stop.
4. Watch status, then open the results to see how it would have behaved.

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). 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? Buy a prepaid top-up pack from the Plans / Billing page. Top-up tokens are spent after your daily plan tokens are used up, and they don't expire at the daily reset. The live Plans page shows the exact daily amount and pack sizes 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).

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.

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.

Open API Docs from the nav. The versioned /api/v1/* layer lets you create expressions/strategies, run permutations, deploy, and pull stats programmatically using a personal API key (read / write / control scopes).

• 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.