Your questions, answered.

TickerAll is a hosted API for MetaTrader 4 and MetaTrader 5 broker accounts. You connect a broker account once, and from then on you read and trade it over a single REST + WebSocket API — from your own code, from a TradingView alert, from a Telegram or Discord chat, or from an AI assistant.

There is nothing for you to run. No VPS, no MetaTrader terminal to keep open, no Expert Advisor bridge, no Windows box. TickerAll holds the connection to your broker on its own servers and exposes it as a normal web API.

One account connected looks like this from your side:

POST https://api.tickerall.com/v1/sessions        → connect, get an accountId
GET  https://api.tickerall.com/v1/accounts/:id     → balance, equity, open positions
POST https://api.tickerall.com/v1/accounts/:id/orders  → place a trade
wss://api.tickerall.com/v1/stream                  → live ticks, position and order events

Everything else — copy trading, bulk orders, webhooks, the chat bots, the MCP server, the Terminal app — is built on that same API.

Five steps, no credit card:

1. Sign up at tickerall.com/sign-up (email + password or Google).
2. Connect a demo account from the dashboard: pick MT5 or MT4, enter your broker's server name, login and password. The dashboard tells you immediately whether the broker accepted it and whether it is a demo.
3. Create an API key at Dashboard → API keys. Keys start with cf_api_. You can make it read-only if you only need data.
4. Make a call. For example, your open positions:

curl https://api.tickerall.com/v1/accounts/ACCOUNT_ID \
  -H "Authorization: Bearer cf_api_..."

5. Try it without writing code in Dashboard → Test, which runs any endpoint against your accounts.

When you want a real-money account, pick a paid plan and connect it the same way. Demo accounts stay free on every plan.

No. That is the whole point of the service.

The usual way to automate MetaTrader is to rent a Windows VPS, keep a terminal logged in 24/7, and run an EA that bridges the terminal to your code. Every part of that chain can break: the VPS reboots, the terminal logs out, the EA stops, the bridge desyncs.

TickerAll replaces the chain. It logs into your broker on your behalf — the same login your MetaTrader app uses — and keeps that session alive on our infrastructure. Your code only ever talks HTTPS and WebSocket to api.tickerall.com. If you already have an EA-based setup, you can keep it; TickerAll simply runs alongside it on the same account.

Any broker that offers MetaTrader 5 or MetaTrader 4 accounts. You connect with the exact same three things you would type into the MetaTrader app: the server name (for example Exness-MT5Trial7 or ICMarketsSC-Demo), your login number, and your password. There is no broker-side setup, no plugin to ask your broker for, and no whitelist to join.

We run the same account-connection code for every broker, and have verified it end-to-end (connect, stream, trade) on, among others: Exness, IC Markets, Pepperstone, FBS, XM, Tickmill, Vantage, FxPro, RoboForex, Fusion, Global Prime, Deriv, MetaQuotes' own demo servers, and prop firms such as FundedElite.

Symbols keep the broker's own names — EURUSDm on Exness, EURUSD on IC Markets, GOLD vs XAUUSD — so what you see in the API matches what you see in your terminal.

Not sure about yours? Connect a demo account on the free plan; it takes under a minute and tells you immediately.

MT5 is fully supported. MT4 is supported for trading and live data, with two gaps.

The gaps return an explicit error rather than an empty result, so your code never mistakes "not available on MT4" for "no trades". If your broker offers both platforms, connect the MT5 account: it gets everything.

A connected account is hot while TickerAll holds a live session with your broker. Reads, trades and tick streams only work on a hot account.

To avoid holding thousands of idle broker sessions open, an account that receives no traffic is cooled after a while:

An account with an open WebSocket subscription is never cooled while you are subscribed.

A cold account answers 409 BROKER_ACCOUNT_NOT_HOT. To warm it again, reconnect:

POST /v1/accounts/ACCOUNT_ID/reconnect
{ "password": "..." }

Warming typically takes 2–5 seconds (some brokers up to ~15 s). The official SDKs do this for you: with keepAlive enabled they re-arm a cooled account transparently and retry the call. If you run a bot or webhook that must fire at any hour, turn on always-hot and the question never comes up.

Always-hot keeps a broker session connected 24/7 instead of cooling it after the idle window above. Use it for anything that has to act without warning: a TradingView alert at 3 a.m., a copy-trading follower, a Telegram bot, a scheduled strategy.

• Pro and Enterprise: included on every account, demo or live.
• Trader: optional, $0.99 per month per connection (demo or live).
• Free: not available.

TradingView / webhook trading requires the bound account to be always-hot, and the Telegram / Discord bots need a connected account, so on Trader those features effectively cost $0.99/mo per account on top of the $3.99.

It is off by default. Switch it on per account, or for all accounts at once, from the dashboard — or via PATCH /v1/accounts/:id/always-hot.

What it does and does not do:

• It removes the idle cool-down. If the broker itself drops the connection (maintenance, network), the session reconnects automatically with backoff — that reconnect logic is on for every account, always-hot or not.
• It does not store your password. If TickerAll's own service restarts, the account comes back as needs re-arm until you (or your SDK client) supply the password again. Pro and Enterprise customers can opt in to remembered credentials so this never happens.

By default, we never store it. When you connect an account, the password is used to log in to your broker and then held only in the memory of the process that keeps the session alive. It is not written to our database, not logged, and not visible to anyone on our side. When the session ends, it is gone. The only time we store a broker password is when you explicitly switch on remembered credentials (the last bullet below) — so "memory only" and "stored securely" are both true, for the default and for that opt-in respectively.

Consequences you should know about:

• After you disconnect an account, or after we restart our service, you supply the password again to reconnect. The SDKs and the dashboard make this a one-liner.
• An investor (read-only) password works for connecting and reading data; the broker itself refuses trades on an investor login, so use the master password if you want to trade.
• The one exception — remembered credentials (Pro and Enterprise). Not storing passwords is the core of how TickerAll works, but some customers genuinely cannot keep their users' broker credentials on their own side (a platform that stores only a hash, for instance) and still need accounts to survive a maintenance restart. For them, and only on opt-in, the password is sealed in an encrypted vault (AES-256-GCM) and used solely to restore the connection. It is off by default, account-wide, consent-audited, and purged the moment you switch it off — the stored secret is rotated to garbage on the spot. If you can supply the password yourself on reconnect, don't turn it on.

You can disconnect an account at any time from the dashboard or with DELETE /v1/sessions/:accountId, and revoke any API key in seconds.

A live account is a real-money broker account; a demo account is a practice account. TickerAll reads the broker's own classification when you connect and returns it as isDemo in the response. Prop-firm challenge accounts (FTMO, FundedElite, …) are treated as live, because the money at stake is real even when the broker labels the server "demo".

Demo accounts are free on every plan and never count toward paid capacity.

On the Free plan you get one live account, usable from the TickerAll Terminal only: you can trade it by hand in the web or mobile Terminal, but connecting a live account through the API, the SDKs or the MCP server returns 403 FREE_TIER_LIVE_REJECTED. Programmatic live trading starts at Trader ($3.99 per live account).

Demo accounts are never billed. On Free and Trader they have their own limit; on Pro every connected account, demo or live, counts toward the plan's 300-account ceiling, and Enterprise ceilings are set per contract. An account only counts while it is connected. Deleting it from the dashboard (or DELETE /v1/accounts/:id) frees the slot immediately, stops any always-hot charge, and never touches the positions at the broker. On Trader and Pro, connecting a live account beyond the capacity you have paid for asks you to confirm the extra charge before it goes through — nothing is billed silently.

Three kinds, all for any symbol your broker offers on that account:

• Live ticks — bid/ask pushed over WebSocket the moment the broker sends them. No polling.
• Candles (OHLC) — over REST, nine timeframes: M1 M5 M15 M30 H1 H4 D1 W1 MN1. Each bar carries timestamp, open, high, low, close, tickVolume, spread.
• Symbol specifications — lot min / max / step, digits, tick size, contract size, tick value, base / profit / margin currency, and the broker's trade mode (full, long-only, close-only, …), so you can size and validate orders before sending them.

Alongside price data, the same WebSocket streams your account events: position opened / updated / closed (with live P&L), the pending-order book on every change, balance and equity updates, and closed trades as they settle.

A subscription looks like this:

{ "type": "subscribe", "channels": [
    { "kind": "ticks",     "accountId": "acc_…", "symbols": ["BTCUSD", "EURUSD"] },
    { "kind": "positions", "accountId": "acc_…" },
    { "kind": "account",   "accountId": "acc_…" }
] }

Reads are not metered on any plan.

Yes. GET /v1/accounts/:id/candles serves history for backtesting and analysis:

GET /v1/accounts/ACCOUNT_ID/candles?symbol=EURUSD&timeframe=H1&from=2024-01-01T00:00:00Z&to=2024-06-30T00:00:00Z

• Use from + to (ISO-8601) for a window, or hours=N for a look-back from now (default 24).
• A single request can cover up to about five years or 100,000 bars; ask for more and you get 400 range_too_large with the maximum it would accept, so you can page.
• Depth depends on the timeframe: daily and coarser reach back years; intraday (M1–H4) covers recent months, as far as the broker's own archive goes.
• The response tells you what it actually served: coverage (complete, floor, or partial), truncated, and a stopReason, so a backtest never mistakes "the broker has nothing older" for "the market did nothing".
• Deep history is fetched over a separate connection, so a large backfill never interrupts the tick stream on the same account.

MT4 accounts return recent M5 bars only. Free accounts get the same candle depth as paid plans.

Because TickerAll timestamps are UTC, and your terminal displays the broker's server time, which for most brokers is UTC+2 or UTC+3 (many run on Eastern European time so the daily bar closes at the New York close).

Candle timestamp values are the bar's open time in Unix seconds, UTC — the format every charting and backtesting library expects. If you line up bars against your terminal by clock time, they appear shifted by the broker's offset; the bars themselves are identical. Convert one side or the other, or compare by "the latest bar" rather than by wall-clock time.

There is a public demo feed used by the tickerall.com homepage and the live page — real ticks and candles for a few dozen popular symbols, served 24/7 from TickerAll's own demo accounts. It is origin-locked to tickerall.com, so it is for looking, not for building on.

For your own applications, connect a demo account on the free plan: you get the full tick stream and candle history for every symbol that broker offers, with no card and no time limit.

A market buy with protective levels:

POST /v1/accounts/ACCOUNT_ID/orders
Idempotency-Key: 3f1c…            ← required on every write
{
  "type": "market", "symbol": "BTCUSD", "side": "BUY",
  "volume": 0.10, "stopLoss": 71000, "takeProfit": 84000,
  "comment": "breakout-v2"
}

Volume is in lots, and comment (up to 31 characters) shows up in your terminal's order comment. Pending orders rest at the broker and fill when price reaches them, whether or not your code is running.

Not supported today: stop-limit orders, order expiry, magic numbers and custom slippage/fill policies. Ask on the issue board if you need one.

You get the broker's reason back, not a generic failure. A rejected order returns 422 BROKER_REJECTED with the broker's message — "not enough money", "invalid stops", "market closed", "trade disabled" — so your code can react correctly rather than retry blindly.

Two things worth knowing:

• Every write requires an Idempotency-Key header. If your request times out and you resend it with the same key within 24 hours, you get the original result instead of a second trade.
• A response with a ticket means the broker accepted the trade; TickerAll waits for the broker's confirmation before answering. If a confirmation never arrives you get TRADE_UNCONFIRMED and can check the position list, instead of a silent maybe.

Every trade on a MetaTrader account is recorded with the kind of client that placed it — the MetaTrader mobile app, the web terminal, or the desktop terminal — and that label is visible in your terminal's history and to your broker or prop firm.

TickerAll lets Pro and Enterprise customers choose which origin an account trades as via terminalType when connecting (MOBILE, WEB, or CLIENT for desktop), and switch later with POST /v1/accounts/:id/migrate. Free and Trader accounts always trade as mobile. This matters mostly for prop-firm accounts whose rules care about how trades were placed.

Yes. A MetaTrader account can have several sessions at once. TickerAll's connection sits next to your terminal, your phone app, or an existing EA; positions opened by any of them show up in all of them. Copy trading's copy from anywhere mode relies on exactly this: a trade you place in the MT5 app on an always-hot master account is mirrored to the followers.

Yes. Every account gets its own webhook URL from Dashboard → TradingView. Paste it into a TradingView alert (or call it from anything that can POST JSON) and send:

{ "action": "buy", "symbol": "EURUSD", "volume": 0.1, "sl": 1.0800, "tp": 1.1000 }

• action is buy, sell, close, close_all, or modify; add "type": "limit" or "stop" with a price for pending orders, ticket to target one position, volume on a close for a partial close.
• Symbol aliases map TradingView names to your broker's (XAUUSD → GOLD), case-insensitively.
• An optional shared secret in the body rejects anyone who only has the URL; a dry-run mode lets you test the alert without trading.
• Ready-made Pine Script templates live at github.com/TickerAll/tradingview-mt5-mt4.

A webhook can only be bound to an account that is always-hot and connected — an alert carries no password, so a cold account could not be revived when one fires. That makes webhooks a Trader, Pro or Enterprise feature: on Trader, the bound account needs the $0.99/mo always-hot add-on; on Pro and Enterprise always-hot is included. Not available on the Free plan, demo or live.

Yes. Link a chat to an account from the dashboard, then message the TickerAll bot on Telegram, or use slash commands like /balance, /buy and /close in Discord. Every link starts read-only — balance, positions, orders — and you enable trading per link from the dashboard when you are ready.

The bots are available on Trader, Pro and Enterprise (not Free), and a link can only be created for an account that is currently connected. Keep always-hot on for that account so the bot can always reach it.

Yes. TickerAll runs a hosted MCP server at https://mcp.tickerall.com (MCP is the open standard AI assistants use to call tools).

1. Generate an MCP key at Dashboard → MCP.
2. In Claude (web or desktop): Settings → Connectors → Add custom connector, paste the URL, then paste the key when Claude asks you to sign in. In Claude Code: claude mcp add --transport http tickerall https://mcp.tickerall.com. Any other client that supports remote MCP servers works the same way.
3. Talk to it: "what's my exposure across all accounts?", "close half of the gold position on the Exness account", "show me last week's closed trades".

The server exposes 25 tools covering everything in the API: connect and remove accounts, balances and positions, symbol info and candles, placing / modifying / closing orders and pending orders, deal and order history, and full copy-trading management. It works on demo and live accounts, with the same plan limits as the API — it is a convenience layer, not a way around them.

Pick one of your accounts as the master; the others become followers and mirror it: opens (market and pending), closes and partial closes in proportion, stop-loss / take-profit changes, and pending-order cancels and edits. Available on Pro and Enterprise; set it up in Dashboard → Copy, over the API (/v1/copy/…), in the SDKs, or from the MCP server.

Each follower is configured on its own:

• Sizing: proportional (scaled by follower ÷ master equity, the default), multiplier, fixed lots, or risk_percent.
• Symbol mapping: automatic across brokers (EURUSDm on the master becomes EURUSD on the follower), with manual overrides when names differ completely.
• Guard-rails: min / max lot, max open trades, max total exposure, symbol allow / block lists, a daily loss stop, a maximum slippage, a minimum master lot to bother copying, an optional delay, and reverse mode.
• Failure policy: retry or skip; every attempt is logged with its latency, and you can point a signed webhook (or a Discord / Telegram channel URL) at the set to be notified of each copy.

Copy from anywhere: if the master is always-hot, trades you place outside TickerAll — in the MT5 app, the desktop terminal, an EA — are mirrored too. Followers must be connected (hot) to receive copies, so followers are usually always-hot as well. Copy trading is between your own accounts; it does not follow other people's accounts.

It runs one operation across many accounts in a single request — place, close, modify, or cancel — and reports the result per account. Available on Pro and Enterprise.

POST /v1/bulk/orders
{ "orders": [
  { "accountId": "acc_A", "type": "market", "symbol": "EURUSD", "side": "BUY", "volume": 0.5 },
  { "accountId": "acc_B", "type": "market", "symbol": "EURUSD", "side": "BUY", "volume": 0.2 }
] }

→ { "results": [ { "accountId": "acc_A", "status": "filled", "ticket": 41827… },
                 { "accountId": "acc_B", "status": "failed", "code": "BROKER_REJECTED", "reason": "not enough money" } ],
    "summary": { "total": 2, "filled": 1, "failed": 1 } }

Up to 50 orders per placement call and 200 items per close / modify call; accounts are worked in parallel. Bulk is not atomic — one account rejecting never rolls back the others — which is what you want when managing a book of accounts. GET /v1/bulk/accounts gives a one-call snapshot of balances, positions and hot / cold state across the pool. Works on demo and live accounts.

Any language that can make HTTPS requests and open a WebSocket. The API is plain JSON over REST, described by an OpenAPI 3 spec at tickerall.com/openapi.json, with Postman and Insomnia collections in the docs.

Official SDKs cover TypeScript / JavaScript (@tickerall/sdk on npm, Node 18+, Bun and Deno) and Python (tickerall on PyPI, Python 3.9+). Both wrap the REST endpoints and the WebSocket, with automatic heartbeats, reconnect and re-subscribe, idempotency keys, and typed errors.

import { Tickerall } from '@tickerall/sdk'

const ta = new Tickerall({ apiKey: process.env.TICKERALL_API_KEY! })
const { accountId } = await ta.sessions.start({
  broker: 'mt5', server: 'Exness-MT5Trial7', account: 12345678, password: process.env.MT5_PASSWORD!,
})
await ta.orders.place(accountId, { type: 'market', symbol: 'EURUSDm', side: 'BUY', volume: 0.1 })

from tickerall import Tickerall

ta = Tickerall(api_key="cf_api_...")
session = ta.sessions.start(broker="mt5", server="Exness-MT5Trial7", account=12345678, password="...")
ta.orders.place(session.account_id, type="market", symbol="EURUSDm", side="BUY", volume=0.1)

Every request carries an API key as a bearer token:

Authorization: Bearer cf_api_xxxxxxxxxxxxxxxxxxxx

The WebSocket accepts the same header on the upgrade request, or ?token=cf_api_… where headers are not possible (browsers).

Keys are created and revoked at Dashboard → API keys. Mark a key read-only when you create it and it can fetch accounts, candles, symbols and history but gets 403 FORBIDDEN on any trade or account change — the right key for dashboards, analytics, or anything you deploy somewhere you do not fully control. Revocation takes effect within a few minutes and drops any session that key was holding.

MCP keys (for AI assistants) and webhook URLs are separate credentials with their own revoke buttons, so you can cut off one integration without rotating the others.

Yes, generous ones, per API key:

Each limit counts in a one-minute window that starts at your first call. A bulk call counts once, however many accounts it covers. Exceeding a limit returns 429 rate_limited; wait for the minute to reset, then retry. For anything that changes faster than you would poll — prices, positions, orders — use the WebSocket instead of polling: one connection carries all your subscriptions.

Reads and demo trading are not metered on any plan.

The stream is at wss://api.tickerall.com/v1/stream. After connecting, send one subscribe message listing the channels you want (ticks, positions, orders, account, history) for one or more accounts; you get a subscribed acknowledgement listing anything rejected and why (for example an account that is not hot).

Your side has to do three things:

1. Answer heartbeats. The server pings every 30 seconds and closes the connection after 35 seconds without a pong. Browser and library WebSocket clients answer pings automatically; if you hand-roll one, reply.
2. Reconnect and re-subscribe if the socket drops (deploys, network). Subscriptions are per-connection.
3. Keep the account hot if you rely on the stream at all hours — subscribing to a cold account is rejected with BROKER_ACCOUNT_NOT_HOT. While you are subscribed the account is never cooled.

The official SDKs handle all three: stream.connect() re-connects with backoff, re-subscribes, and re-arms a cooled account if you gave it the password.

GET /v1/accounts/:id/history returns closed round-trips: ticket, symbol, side, volume, open and close price and time, profit (realised, in the account currency), swap, stop-loss and take-profit, and the closing deal's ticket. Partial closes appear as separate rows. Commission is currently reported as 0, because the data set the broker provides does not carry it — the profit figure is what the broker booked.

Three companion endpoints complete the picture:

• /orders-history — every order including cancelled, expired and rejected pending orders, with its final state.
• /deals-history — the raw deal log.
• /balance-operations — deposits, withdrawals, credits, charges, bonuses and corrections as signed amounts, so you can reconcile equity exactly.

How far back they reach is set by the broker's own login data (typically weeks to months on MT5); trades closed while the account is connected are appended live and pushed on the history WebSocket channel. Results are cached and are not metered. MT4 accounts do not have history yet.

The session reconnects automatically with exponential backoff, on every account and every plan. A watchdog also treats a connection that has gone silent for more than 150 seconds as dead and rebuilds it, so a half-open socket cannot quietly freeze your tick stream.

Pending orders and stop-loss / take-profit levels live at the broker, so they keep working during a reconnect; only your live event stream pauses. Each interruption is recorded with its cause and shown on the status page and in GET /v1/status for your own monitoring.

Yes. tickerall.com/status shows live service health, uptime of the public feed, and the last incidents with their duration and cause. The same data is available from the API (GET /v1/status) if you want to alert on it.

Planned maintenance happens in a weekly window on Sunday, 06:00–10:00 UTC, announced by a banner on the site and in the dashboard from the Friday before. Sessions that were not remembered need their password again after a service restart (see How do you handle my broker password?); the SDKs' keepAlive mode re-arms them for you.

A few defaults are on your side:

• Read-only API keys cannot trade, whatever the code that holds them does.
• Idempotency keys are mandatory on writes, so a retry loop cannot double-open a position.
• Every order goes through the broker's own validation — lot limits, margin, stops distance, market hours — and the broker's rejection reason is returned verbatim.
• Free-plan live accounts cannot be traded programmatically at all, and chat-bot links start read-only until you enable trading.
• Deleting an account from TickerAll never closes or changes positions at the broker.

Beyond that, TickerAll executes what you send. Test on a demo account first: demo orders are never charged, on every plan, and the free plan's five demo accounts exist precisely so you can run your strategy against real prices with no money at stake.

• Live chat on the site and the contact page — a real person, usually within minutes.
• Email: hello@tickerall.com.
• Community: Discord and Telegram.
• Bugs and feature requests: the public issue board — you can see what others have asked for and what is planned.

Pro customers get priority support; Enterprise adds an SLA.

Yes, free forever, no card:

• 5 demo accounts with demo orders never charged, the full candle history and the live tick stream — the complete API, SDKs and MCP server on demo.
• 1 live account you can trade by hand in the TickerAll Terminal (web, Android, or iPhone home-screen app).
• Community support.

What Free does not have: programmatic trading on live accounts, always-hot, TradingView / webhook trading, the Telegram and Discord bots, copy trading and bulk. Those need a connection that is kept alive around the clock, which starts at Trader ($3.99 per live account).

Rules of thumb: testing or trading by hand → Free. Automating one to a handful of real accounts → Trader. Ten or more accounts, or you want copy trading and bulk → Pro (at 10 live accounts Trader costs $39.90, so Pro is already cheaper). More than 300 accounts, an SLA, or dedicated infrastructure → Enterprise.

The $39/mo base includes 30 live accounts. Each additional live account is a flat $2/mo, up to the plan cap of 300 — so 50 accounts is $79, 100 is $179, and 300 is $579. Demo accounts are never billed, but they do count toward the 300-account cap. You set the capacity you want with a slider on the billing page; above 300, or for volume order pricing, talk to us about Enterprise.

Yes, from the billing dashboard, with no notice period.

• Increasing capacity is prorated and charged immediately, and takes effect immediately.
• Decreasing capacity is credited against your next invoice.
• Cancelling stops the subscription at once; any remaining credit is refunded to your card.

When you move to a smaller plan, connected sessions above the new plan's limits are disconnected (live accounts first, most recently connected first); demo accounts are left alone where the new plan allows them. Nothing changes at the broker — positions, pending orders and stops stay exactly as they were — and the accounts remain in your dashboard to reconnect within the new limits. Always-hot switches off on a move to Free or Trader.

No. The free plan needs no card, ever. You add a card only when you move to Trader, Pro or Enterprise to trade live accounts programmatically. Billing is handled by Stripe; we never see your card number.

When one of these is true:

• You need more than 300 live accounts, or per-account pricing below Pro's $2.
• You want a contractual SLA or dedicated infrastructure.
• You are a prop firm, signal provider, or platform putting TickerAll under your own product and need partner keys, volume order pricing, or a custom integration.

Write to us on the contact page; a real person replies, and Enterprise deals are set up per customer rather than from a fixed price list.

A full trading terminal for your connected accounts, built on the same API: live charts on all nine timeframes, one-click and full-ticket orders, open positions with live P&L, pending orders, and history — for every account in your pool, demo or live, MT4 or MT5, from one screen.

• Web: tickerall.com/terminal in any modern browser. Chrome and Edge can install it as a desktop app.
• Android: download the app from tickerall.com/download (Google Play listing coming).
• iPhone / iPad: open the terminal in Safari and Add to Home Screen for the full-screen app (App Store listing coming).

The Terminal is included on every plan, and it is where Free-plan users trade their one live account.