How to connect TextToQuant MCP with VS Code

Parse a plain English trading strategy into TextToQuant's structured format. Returns the parsed query (asset, timeframe, entry/exit conditions, risk settings) which can be passed to run_backtest. Costs one LLM parse on the account.

Execute a backtest from a parsed strategy (the object returned by parse_strategy). BILLS ONE BACKTEST CREDIT on the account. Runs can take up to a few minutes; the result is saved server side even if this call times out; use list_backtests to find it afterwards. A completed run returns the FULL REPORT: `_digest` is the report as prose (headline metrics, what ran, grade pillars, edge by regime, holdout split, walk forward, Monte Carlo, entry trigger base rate, honesty flags, next steps) and `report` carries the same numbers as fields. Present the digest to the user in full; do not reduce it to the grade line. Every run is saved with its strategy in words: keep originalQuery from parse_strategy, and pass query when you changed the parsed object yourself. Entry legs sharing a recipeIndex are ANDed into one setup, distinct indexes are alternative setups, no index is a gate on every setup (describe_capabilities conditions.grouping).

List the account's saved backtests: id, asset, timeframe, return, win rate, trades, dates. Filter and sort server side ("my best BTC run" → asset:"BTCUSDT", sort:"sharpe_ratio") instead of paging everything. Pass a row's id to show_backtest to display it, or to get_backtest for the full numeric record.

Fetch one saved backtest by id: summary metrics, grade, the strategy parameters it ran with, and the FULL REPORT (`_digest` as prose, present it in full; `report` as fields). ALSO carries the PROBABILITY SCAN at `metrics.probabilityScan`: the entry trigger's base rate across EVERY time it fired, including triggers this run could not trade because a position was open. Its rules: `successRate` divides by `resolvedSignals` (pending signals are unknown, never losses); NEVER quote the rate without `edge.breakevenRatePct` (27% is excellent at 3:1 and fatal at 1:1), `edge.edgePts` is the claim; honour `edge.verdict`, decided by the confidence interval and "inconclusive" below `edge.minSampleForVerdict`; `execution.skippedEdgePts` is a finding only when the traded and skipped intervals separate; `unmodelledExits` names exit types the scan did not simulate. All gross of fees and position independent: a diagnostic of the entry trigger, never account P&L. Numbers only; show_backtest renders the run visually.

List the user's SAVED custom indicators (created in the app's Pine editor, via CSV upload, or with save_pine_indicator). Returns each indicator's name, source, date range, and its plotNames: the output series/variable names it exposes. Reference an indicator by NAME in parse_strategy customIndicatorHints and run_backtest savedIndicatorMapping, and a specific output by its plot name. Paginated: an account with hundreds of indicators is never dumped in one frame, use search/limit to find the one you want rather than paging everything.

Fetch ONE saved custom indicator by name in FULL detail, including its Pine Script source code (pineCode), its plotNames (output series), the compiled indicator schema, and its compile context (symbol/timeframe/bars/date range). Use this to READ, explain, review or modify a custom indicator's Pine code. list_indicators returns summaries only, without the source. Read only.

Compute an indicator over a symbol, timeframe and date range and return its plotted values: either a SAVED custom indicator by name (JavaScript, Python, Pine or CSV, from list_indicators) or a BUILT IN study by type (rsi, ema, sma, macd, bollinger_bands, atr, stochastic, williams_r, cci, mfi, obv and the rest of the chart study registry). JavaScript and Python indicators are recomputed for the symbol asked for, Pine is rerun by the Oracle, CSV is the file's own numbers. Returns one series per plot with the pane it belongs in (price overlay or its own pane) and its reference levels. This is what the report widget plots when the viewer adds an indicator; use it yourself to read an indicator's values over a run. Read only, no credit.

Compile a TradingView Pine Script against real market data and save it as a reusable custom indicator on the account (same pipeline as the app's Pine editor Save). After saving, the indicator can be used in strategies via parse_strategy customIndicatorHints. Plan gated.

Check a JAVASCRIPT indicator without running it: syntax, the module shape (INPUTS / PLOTS / calc), and that every `@name` import resolves to one of your saved indicators. Loads NO market data and never calls calc(), so it answers in milliseconds and costs nothing, use it to iterate, then preview_js_indicator to see real numbers, then save_js_indicator to persist. A green result means "this is a valid indicator", NOT "this works": anything that only happens while computing (a throw, a timeout, a series of the wrong length) needs real bars to find. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Compile AND run a JAVASCRIPT indicator against real bars WITHOUT saving it, and get the plotted series back. Unlike preview_indicator (Pine), this returns the result directly, there is no job to poll, because the sandbox runs locally in milliseconds rather than crossing a network. Use it to confirm an indicator actually computes what you intended before save_js_indicator. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Author a JAVASCRIPT indicator and save it on the account. Compiled and RUN on real bars in a sandbox before storing: a save yields a working indicator or a diagnostic with the line number; failing code is not persisted. Prefer it to save_pine_indicator for new logic: no TradingView round trip, not pinned to a symbol/timeframe. ES module, three exports: INPUTS (numbers/booleans, or { default, min, max, step, label }), PLOTS ([{ name, kind: line|signal|state }]), calc(candles, opts) returning one array per plot; `candles` has time/open/high/low/close/volume/hl2/hlc3/ohlc4 oldest first, `ta.*`: ~65 helpers (sma, ema, rsi, atr, crossover, pivothigh...). TWO TRAPS: warm up bars are NaN, not null, guard with Number.isFinite; runs must reproduce: NO require/fetch/process, NO npm packages, Math.random throws, Date.now() is pinned. COMPOSITION: import a saved indicator by name (@my_baseline): build a baseline once, reuse it. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Check a PYTHON indicator without running it: syntax and the module shape (INPUTS / PLOTS / calc). Loads NO market data and never calls calc(), so it answers in milliseconds and costs nothing, use it to iterate, then preview_py_indicator to see real numbers, then save_py_indicator to persist. A green result means "this is a valid indicator", NOT "this works": anything that only happens while computing (a raise, a timeout, a series of the wrong length) needs real bars to find. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Compile AND run a PYTHON indicator against real bars WITHOUT saving it, and get the plotted series back. Like preview_js_indicator and unlike preview_indicator (Pine), this returns the result directly: there is no job to poll, because the sandbox runs locally in milliseconds rather than crossing a network. Use it to confirm an indicator actually computes what you intended before save_py_indicator. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Author a PYTHON indicator and save it on the account: the capability and `ta.*` helpers of save_js_indicator, numerically identical. Compiled and RUN on real bars before storing: a save works or returns a diagnostic with the line number. Not pinned to one symbol/timeframe. Define INPUTS = { "length": 14 }, PLOTS = [{ "name": "signal", "kind": "line" }] and def calc(candles, opts) returning { plotName: list }. `candles` is a dict of lists (time/open/high/low/close/volume/hl2/hlc3/ohlc4), oldest first. Traps: warm up bars are NaN and `v is not None` is TRUE for NaN, use `ta.na(v)`; MicroPython dialect (no pip/pandas/scipy; `ta.*`, `ulab.numpy`, stdlib subset); random/time/datetime are refused so reruns match. Iterate: validate_py_indicator -> preview_py_indicator -> save. `from ttq import my_baseline` imports a saved one. Full contract, styling, SERIES: describe_capabilities { section: "indicators" }. Plan gated. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Save an indicator from PRECOMPUTED VALUES supplied as CSV text: a series this platform cannot compute, a vendor feed, a model output, outside research. The other save_* tools take CODE that is run for you; this takes numbers as data, nothing is compiled or recomputed: the values you upload ARE the indicator, and a run can only use the dates the file covers. Format: a header row, then one row per bar, oldest first. First column is the timestamp (ISO date or datetime); every other column becomes a plot referenced by name. time,value 2025-01-01,1.5 Prefer save_js_indicator or save_py_indicator whenever the series CAN be computed from bars: a computed indicator works on any symbol, timeframe and range; a CSV is pinned to its rows and silently limits every backtest to that window. Size: the CSV travels as JSON, so under 1.5MB; the app's upload form takes up to 5MB. Saving under an existing name REPLACES it. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Delete one of the user's saved custom indicators by name (CSV, Pine, JavaScript or Python). This cannot be undone.

The account's plan tier and backtest budget: the included allowance (backtestLimit, backtestsUsed, quotaRemaining; monthly on paid plans, but on Free it is 5 backtests ONCE for the life of the account, never renewing, and only for accounts that never had a paid plan), prepaid credits that carry over (creditBalance), and the total spendable now (backtestsRemaining), and the parse allowance (parses: a lifetime grant on Free, a daily cap on paid plans). Runs past the budget are REFUSED, never billed after the fact. Check this before running many backtests. For an account that has not run a backtest yet (hasRunBacktest false), `firstRun` carries three starter prompts with the real result each produced and a link to its report, and `firstRun.menu` the six lettered ways to start.

Shows the six ways to start on TextToQuant (get market data, build an indicator, run a backtest, screen the market, develop a strategy, or type your own) as a lettered menu, and as clickable cards on an app that renders them. Each choice comes with the first message for that path. Free; reads only the plan, to word the free limits, and whether the account has run a backtest, to word the menu.

The subscription tiers (free/pro/power/quant/enterprise) with their current monthly/annual price, headline feature + limit deltas (backtest credits, Monte Carlo, overfitting detection, context analysis, robustness, Pine, API access, history years). Call this when a run is blocked by quota_exceeded / plan_required so you can tell the user exactly what the next tier includes. Plans are managed by the user in their TextToQuant account (Account → Plan & Billing); nothing is purchased through this connector. Read only, no credit.

Round trip a parsed strategy back into plain English, the EXACT settings that will run: asset, window, every entry/exit condition, sizing, and costs. Read it back to the user to confirm intent BEFORE spending a credit on run_backtest; it also flags fatal gaps (no entries, no exits). Free, no network.

Why did this run get its grade? Returns the stored hurdle anchored breakdown: the four pillars (profitability, risk, consistency, edge) with their scores, weights and sub metrics, plus warnings, so you can tell the user exactly what to improve to raise it. Sub metric KEYS are internal identifiers; read each by the label the digest prints: edge.expectancyR is "Expectancy / avg loss" (percent expectancy ÷ the mean losing trade) and edge.rrRatio is the "Payoff ratio" (mean win % ÷ mean loss %): neither is an R-multiple; `basis: "avg_loss"` says so. The run's real R expectancy (realised profit ÷ dollars risked at fill) is rawInputs.ledgerExpectancyR, null when the strategy declared no stop; informational, not a grade input. Read only, no credit.

A one call "where was I" briefing: plan credits left, the most recent runs with grades and labels, saved custom indicators, and live scan alerts. Useful at the start of a session to orient on the account before reading individual runs. Read only, no credit.

The platform's strategy vocabulary, so you can write ideas that actually parse and run: supported asset classes and how to name their symbols, timeframes, built in indicators, condition operators, exit types, position sizing, and advanced controls (market sessions, time filters, risk guards, pyramiding, multi timeframe, cross asset), plus the PORTFOLIO section: every book level knob a shared capital run understands, the phrasing that reaches it, and what each skipped signal reason means, and `tools`: every tool on this server by family, the full inventory when your host loads tools by search. Static and free, call it BEFORE authoring a strategy or a portfolio. Your own custom indicators: list_indicators. Your plan credits/limits: get_usage. This lists what the ENGINE runs; which timeframes, asset classes and cross market conditions YOUR plan may use depends on the plan: get_plans. `startHere`: three starter prompts, each with its real result and report link.

Robustness job on a SAVED backtest (id from run_backtest): "sweep" (one parameter, 5 runs), "grid" (5x5, 2 parameters), "walk_forward" (anchored), "joint_sweep" (3 parameters), "multi_asset" (curated peers, or params.assets), "variants" (long/short only, half/double risk), "screen" (ONE job, every dimension, one GATED verdict: worst dimension decides, nothing averaged; FAIL is conclusive, PASS is a screen not proof, confirm with full tests). grid/walk_forward/joint_sweep/multi_asset/screen are power tier features, each billed a FLAT 5 credits at start (0 on Enterprise); variants (power) bills 1 per generated variant, at most 5; sweeps (power too) bill 1 per numeric dial, 5 per Pine dial. Failed cells still bill; only an all fail run refunds. Cancel: queued refunds, running bills computed cells. Returns jobId; poll get_analysis. Parameter ids ("entry.0.threshold", "risk.stopLoss"): get_analysis kind "sweep_options". Requires the Power plan; this account is on Free. Call get_plans to compare.

Poll a robustness analysis started with start_analysis (progress while running, full result when done). Also: kind "sweep_options" (no jobId) lists the sweepable parameter ids of a backtest, and kind "context" (no jobId) returns the context performance insights (why trades won/lost by market regime).

Fetch the raw data behind a saved backtest: equity curve, trade list, candles, buy and hold curve, chart markers, Monte Carlo results, the entry/exit CONDITION LOGS (why each signal fired or never did, read these to diagnose a run with few trades), or MONTHLY_RETURNS: the returns calendar, giving best and worst period, per row totals, the green rate over the periods that HELD A POSITION, and a SEASONALITY verdict, already reduced from the full curve and bucketed by month or, on a short run, by day or hour. Never page `equity` to work out a calendar answer. Needs the run_id field from get_backtest. The raw series come back under `rows`, paginated to a manageable page; pass offset/limit for more. monthly_returns is bounded and returns complete in one call.

Render a saved backtest as its full visual report: price candlesticks with trade markers, equity + drawdown, Monte Carlo distributions and the metrics board, returned as a chart image in the chat (and as an interactive widget on hosts that render MCP Apps). Use it to present a run to the user, whether they asked to see it or you are reporting a result; get_backtest is the numbers only companion for reasoning. Read only, no credit; falls back to a text summary if imaging is unavailable.

Render a COMPLETED robustness analysis as a chart image: sweep bars, parameter grid heatmap, walk forward window strip, or multi asset table. Use after start_analysis finishes (poll get_analysis). Read only.

CONTEXT ANALYSIS, the INDICATOR READING dashboard: which indicator buckets (RSI 14 + Williams %R 14 by default) the strategy wins and bleeds in, with the best/worst bucket and the full ranking by win rate, average return and risk adjusted edge. Pass `dimensions` to bucket by trend / volatility / structure / a saved custom indicator instead. Read only, no credit. ROUTING, two DIFFERENT analyses answer to the phrase "edge by regime": • indicator buckets (RSI, Williams %R, a custom indicator) → THIS tool. • price action blocks (the Robustness panel: Trend Up / Trend Down / Quiet Range / Volatile Chop) → get_regime_edge. If the user said "robustness", "price action", or named one of those four blocks, either call get_regime_edge or call THIS tool with basis:"price_action": both return the identical block breakdown, so a mis route corrects itself instead of showing the wrong analysis. Requires the Power plan; this account is on Free. Call get_plans to compare.

Render a COMPLETED portfolio run as a branded report image: a metrics strip (return, Sharpe, max drawdown, win rate, trades, grade), the book equity curve with drawdown vs an equal weight basket, and per asset attribution bars (which assets made vs bled the money). Present this to the user after a portfolio finishes, then call share_portfolio for the full interactive report. Read only, no credits. Takes the durable run id (result.id from a completed get_portfolio), NOT the jobId.

Compare 2 to 4 saved backtests side by side as a chart image: overlaid equity curves plus a metric table with the best value per row highlighted. Use whenever the user wants to compare runs, judge whether a change improved a strategy, or pick between variants. Strategy comparison is a Power tier feature; a lower plan gets plan_required naming the tier. Requires the Power plan; this account is on Free. Call get_plans to compare.

Create (or revoke) the public share link for a saved backtest. Returns two links to the same run: `url`, the shareable report page (/s/), a sanitized read only summary anyone with the link can view; and `terminalUrl`, the same run opened in the TextToQuant terminal (the report page's "View in terminal" button): the full interactive workspace with the price chart, indicator overlays, trade markers, trade list and condition logs. Signed out it shows the sanitized run; signed in it loads the full run as if the viewer had executed it, and they can edit and rerun it from there. Give the user both, labelled: the report to read or forward, the terminal to inspect trades on the chart or iterate.

Create a public chart link for a saved backtest: the price chart with its trades and indicators as the owner last arranged it, at a short /c/ URL anyone can open. Strategy rules are hidden unless rules is true. revoke takes a chart link id and turns it off.

Cancel a backtest that is still QUEUED (not yet computing) and refund the credit it was billed at enqueue. A run that already started computing continues server side and is NOT refunded. Use to stop a run the user changed their mind about, or to reclaim a credit before compute starts. The response `status` is one of: cancelled (refunded when `refunded` is true), running (already computing, no refund), completed, failed, or not_found.

Split ONE plain English multi asset prompt (e.g. "buy BTC and ETH when RSI crosses above 30 on 1d, 8% TP 4% SL, keep 20% in cash, max 3 positions") into per asset parsed strategies for a shared capital PORTFOLIO backtest. No backtest credit (no run); costs one LLM parse on the account, like parse_strategy. Returns { assets:[{ symbol, assetId, parsedQuery }], strategies, settings }. `settings` carries the BOOK LEVEL controls the prompt stated (risk limits, cash reserve, rebalancing, throttles, initialCapital…), pass BOTH the assets AND settings to run_portfolio, or the book runs without the controls the user asked for. Requires the Enterprise plan; this account is on Free. Call get_plans to compare.

Run a SHARED CAPITAL multi asset portfolio backtest: all assets draw from ONE capital pool and a contention rule resolves same bar entries. BILLS ONE BACKTEST CREDIT PER ASSET. Async: returns a jobId immediately; poll get_portfolio until status is completed. Build the assets from parse_portfolio (or supply your own parsedQuery per asset from parse_strategy). Retries are safe: pass idempotencyKey and a replay returns the original jobId with no second charge. Requires the Enterprise plan; this account is on Free. Call get_plans to compare.

List the user's SAVED portfolio (book) runs, newest first, the durable history of everything run with run_portfolio. Use this to find a book run earlier (get_portfolio needs a jobId that expires; every row here carries the durable run id for show_portfolio / get_portfolio_analysis / share_portfolio). Each row: id, created_at, assets[], asset_count, return, sharpe, max drawdown, win rate, trades, grade, blown_up. Read only, no credit.

Poll a portfolio run started with run_portfolio. Returns status running | completed (with the full portfolio result: combined metrics, per asset attribution, and basket vs benchmark) | failed. Poll every few seconds; a portfolio of N assets typically takes 30s to a few minutes. A completed result carries a persisted run id (result.id) you can pass to share_portfolio for a public report link.

The full analysis of a completed portfolio (book) run: combined metrics and grade, per asset attribution (which asset made or lost the money), the basket benchmark, Monte Carlo risk, and walk forward / out of sample robustness, all already computed for the run. Pass the run's result.id (from a completed get_portfolio). Heavy equity/trade arrays are omitted for a compact read. Read only, no credit.

Poll a run_portfolio_sweep job: per value book metrics as they complete, and the best value (by Sharpe) once done. A flat plateau across values means robust; a single spike means curve fit. Read only.

The edit/version history of a strategy session: every iteration (run) it produced, in order, with labels and ids. Pass the strategy_session_id from a backtest row. Compare any two with compare_backtests. Read only.

Compare TWO backtests and report exactly WHAT CHANGED: the parsed strategy fields that differ (asset, timeframe, dates, each entry/exit condition, sizing, risk) AND the metric deltas (return, Sharpe, max drawdown, win rate, trades, grade). Use it to answer "what did I change and did it help?" between two iterations. Pass the two backtest ids (from get_iterations / list_backtests). Read only, no credit.

Keep the run history tidy: action "tag" replaces a backtest's tags (filter later with list_backtests), "rename_iteration" relabels one run in an edit session, "rename_session" relabels the whole session.

Push instead of poll: manage HTTPS receivers that get a signed POST when a backtest completes or fails. action "list" (default), "create" {url} (max 3 active; returns the HMAC secret ONCE), "test" {id} fires a signed test event, "delete" {id} removes one.

Create (or revoke) the public share link for a COMPLETED portfolio run. Pass the run id from a completed get_portfolio result (the result.id, NOT the jobId). Returns the shareable /sp/ URL, anyone with the link sees a sanitized read only portfolio report. Lead with it as a prominent clickable markdown link.

Rewrite a vague or ambiguous strategy idea into clearer, parser friendly language WITHOUT inventing parameters, then feed the result to parse_strategy for a cleaner parse. Use this when a parse looks wrong or the idea is underspecified. Returns rephrasedQuery plus notes on what changed. Metered per plan. Requires the Pro plan; this account is on Free. Call get_plans to compare.

Iterate on an existing backtest: rerun a MODIFIED strategy and save it into the SAME iteration session as the base run, so History groups them and you can compare like for like. Pass the base run id and the new parsedQuery (reparse the tweaked idea with parse_strategy first). Bills one backtest credit. Entry legs sharing a recipeIndex are ANDed into one setup, distinct indexes are alternative setups, no index is a gate on every setup (describe_capabilities conditions.grouping).

Forward outcome probability for a SINGLE entry condition: when it fires on the given asset, what happens in the following bars (hit rate + return distribution). A fast filter probe, NOT a backtest (no exits, sizing, or fees) and it does not bill a backtest credit. Use it to vet an entry trigger before a full run. Requires the Power plan; this account is on Free. Call get_plans to compare.

The platform's public showcase strategies: real, best performing shared backtests with their plain English query, asset, and headline metrics. Study them as worked examples before authoring a new idea, so your phrasing and structure match strategies that actually run well. Each carries `url` (its report page) and `terminalUrl` (the same run opened in the terminal). Read only, no cost. `source` picks the gallery (default), the categorised `templates` library (trend, mean_reversion, breakout, momentum, risk_managed, macro; Free runnable rows by default), or `all`; `category` filters the templates.

List (or unlist) one of the user's backtests in the PUBLIC showcase gallery that list_examples reads from. The run must already have a public share link (call share_backtest first), publishing without one returns a clear "share it first" error. Pass public:false to remove it from the gallery. Owner scoped.

Convert a strategy into a TradingView Pine Script v6 strategy() script the user can paste into the Pine editor. Pass either parsedQuery (from parse_strategy) OR id (an existing backtest UUID, its stored strategy is exported). Anything with no faithful Pine equivalent is listed explicitly (the unsupported array + a "NOT EXPORTED" header): never silently approximated. Read only, no credit. Requires the Power plan; this account is on Free. Call get_plans to compare.

Overfitting assessment for a backtest: its Deflated Sharpe Ratio (the run's Probabilistic Sharpe deflated by how many strategy configs were tried), PBO if a grid sweep ran, and a verdict, holds_up / likely_overfit / insufficient_evidence. A single backtest with no parameter search returns insufficient_evidence (run a sweep/grid first). Read only, no credit. Requires the Power plan; this account is on Free. Call get_plans to compare.

ROBUSTNESS PANEL: "Edge by regime" across the four PRICE ACTION blocks: Trend Up, Trend Down, Quiet Range, Volatile Chop. Classifies every bar into a block and attributes each trade to the block live at its entry bar: net P&L, win rate, trades, average trade, exposure and P&L share per block, plus a dependence verdict (robust / concentrated / no_edge). Renders the same Net-P&L-by-block bar chart as the site's Robustness → Edge by regime section. Already computed at run time: read only, no credit. ROUTING, two DIFFERENT analyses answer to the phrase "edge by regime": • price action blocks (robustness; the four block names above) → THIS tool. • indicator buckets (RSI, Williams %R, a custom indicator) → show_context. If the user meant indicator buckets, either call show_context or call THIS tool with basis:"indicator"both return the identical context dashboard, so a mis route corrects itself.

The dimension ids refine_context / show_context / get_context_trades accept. Every built in indicator that can bucket a run's trades, with its default period, output lines and a paste ready example id. Call this BEFORE guessing an id: the reanalyse validator accepts any well formed builtin_<name>_<period>, so an id that is merely well formed still comes back analysing nothing. Static list, read only, no cost.

Reanalyze a backtest's trades along DIFFERENT market regime dimensions (trend, volatility, structure, entry_position, or a saved custom indicator) WITHOUT rerunning, quota free. Use it to hunt for the regime split that best separates winners from losers, then prove it with filter_by_context. Read only. For a straight "edge by regime" read with the app default (RSI + Williams %R) use show_context; get_regime_edge is only for the Robustness panel's price action blocks. Requires the Power plan; this account is on Free. Call get_plans to compare.

Rerun a backtest taking entries ONLY inside a chosen market regime (e.g. only in an uptrend / low volatility), the actionable payoff of regime analysis: prove a filter is a real edge, not curve fit, by comparing it to the base run. Bills one backtest credit. Requires the Power plan; this account is on Free. Call get_plans to compare.

The trades behind a regime analysis: the paginated per trade context view for the whole run, or (with contextKey + dimensions) the trades in ONE regime bucket. The evidence for a best or worst regime claim. Read only. Each row carries `price_action_block` (the Robustness block at the ENTRY bar: Trend Up, Trend Down, Quiet Range, Volatile Chop) and `exit_price_action_block` (at exit): the detail behind get_regime_edge's per block totals. Either is null where the classifier declined to label the bar (ATR warm up, an unconfirmed pivot near the end): report null as unclassified, never substitute a neighbour. The blocks are POST HOC: bounded by fractal pivots that confirm bars later, so the label depends on later price. Sound for explaining results, never usable as an entry filter or a live signal. Runs saved since 2026-09-14 carry the label on the trade row; older runs get it from the stored block timeline at read time. Requires the Power plan; this account is on Free. Call get_plans to compare.

Compile check a Pine Script indicator: syntax/compile validation only, no run, no save. Use it while authoring a custom indicator to catch errors before save_pine_indicator. Returns compile status and any error diagnostics. Read only.

Offline diagnostics for a Pine Script indicator (quota free): style and correctness warnings without compiling or running. Complements validate_indicator when authoring a custom indicator. Read only.

Compile AND run a Pine Script indicator against real market data (no persist) to see its plotted series: the real data check before save_pine_indicator. Starts an async job; poll get_indicator_preview with the returned jobId. Nothing is saved to the account.

Poll a preview_indicator job: returns progress while running and the compiled plot series + any runtime warnings when done. Read only.

Scan the crypto market (RSPS engine): the current tradable universe with per token momentum/strength scores, price, 24h move and volume, to answer "what is setting up / moving right now?". Returns the top movers as a digest plus rows. Crypto only; cache fresh (~5 min), not live ticks. Read only, no credit. `emaCross { fast, slow, direction, within, timeframe }` keeps symbols whose fast EMA crossed the slow EMA within the last N closed bars.

The crypto market's current regime verdict per timeframe (RSPS): RUN (broad risk on momentum), REVIEW (mixed), or SKIP (weak / risk off). Use it to judge whether the backdrop favors long strategies before running one. Crypto universe, cache fresh. Read only, no credit.

Per token forward outcome base rates from the screener: average return and win rate over the 1/3/7/30 bars AFTER a signal, for a timeframe + signal condition. Base rates across the crypto universe, not a backtest. Read only, no credit.

List your crypto scan alerts (the saved "notify me when tokens match X" rules), with their conditions, interval, active state, and last match. Read only.

Create a recurring crypto scan alert: get notified (Telegram/email) when tokens match a set of screener thresholds. Conditions keys: tf (e.g. "1d"), sectors (string array), and numeric thresholds minVolume (24h USD), minPriceChange/maxPriceChange (24h %), minPercentile (RSPS 0-100), rsiAbove/rsiBelow (RSI14), minMomentum (20-bar), minMarketCap; open interest: minOiChange/maxOiChange (% change in coin terms over oiWindow: 1h, 4h, 24h or 7d, default 24h), minOpenInterest (USD), oiRegime (new_longs, short_covering, new_shorts, long_liquidation, flat). At least one threshold or a nonempty sectors list is required. Every plan may hold some; the number of ACTIVE alerts is capped per plan (get_plans reports scanAlertLimit).

Pause/resume, rename, recondition or retime an existing scan alert WITHOUT deleting it (delete loses the config). Pass the alert id (from list_scan_alerts) and only the fields to change: active:false pauses it, active:true resumes; name renames; conditions replaces the threshold set; intervalMinutes retimes; notes updates the note. Reactivating / reconditioning / retiming counts against the active alert cap on your plan; pausing + renaming do not.

Delete one of your crypto scan alerts by id (from list_scan_alerts). Cannot be undone.

Crypto sector performance snapshot from the screener, which sectors are leading or lagging. Pass a date (YYYY-MM-DD) for a specific day, else the most recent rows. Read only, no credit. Crypto universe.

Advanced: the pairwise RSPS dominance matrix for the top-k crypto tokens (who beats who) on a timeframe. Most tasks want scan_market or market_regime instead. Read only, no credit. Crypto universe.

Manage your saved screener filters. action:"list" (default) returns them; action:"create" persists one (name + filterJson, the screener filter state, upsert by name); action:"delete" removes one by id. filterJson is free form (the screener UI filter object).

Correlation and beta of the crypto universe against a benchmark symbol you choose (e.g. SUIUSDT) over a window, which tokens amplify it (high beta) and which diversify (low/negative correlation). Read only, no credit.

One crypto token's recent OHLCV bars plus its multi timeframe screener rows (beta, percentile, forward returns) on a chosen timeframe. Raw series capped to recent bars, for a backtest use run_backtest instead. Read only, no credit.

Start the Perfect Token Profiler: it fingerprints what the top movers looked like BEFORE they ran (the indicator/return profile of winners over an H-bar horizon). Async, poll get_profiler with the jobId. Crypto universe. Saves nothing to the account, no credit.

Poll a run_profiler job: progress while running, and the full winner profile result once status is "done". Read only.

Fetch raw OHLCV candles for ANY symbol/timeframe/date range, crypto (BTCUSDT) or stock (NASDAQ:AAPL). Use it to inspect price data directly or sanity check a symbol before parse_strategy/run_backtest. Read only, no credit. Returns candles as [openTime, open, high, low, close, volume] tuples. Requires the marketData plan feature. Stock and forex history comes from a small data budget shared by every user: fetch one symbol at a time, prefer daily or a shorter range, and on rate_limited wait the seconds the message gives before retrying. Crypto is not limited this way.

List the tradable crypto market universe (by market cap) so you can enumerate or VALIDATE a symbol before parse_strategy/run_backtest: reducing SYMBOL_NOT_FOUND failures. Paginated. Read only, no credit. Requires the marketData plan feature.

Show which notification channels (Telegram, email) are actually configured to deliver the user's scan alerts / backtest webhooks, so you can tell them where alerts will land before create_scan_alert or manage_webhooks. Read only.

Export a whole window of OHLCV candles as ONE CSV or JSONL file behind a short lived signed link: the bulk path when research needs every bar; get_candles shows at most 1,000 rows. It runs as a background job. This call waits about 25s, then returns either status done (the link, its expiry, rows, the file sha256 and candles_sha256, which equals window_sha256 in a server lab run on the same market and dates) or status queued or running with an exportId. Then call export_candles again with that exportId, or repeat the same arguments: an identical request returns the same export, never a second one. A closed window exported before returns done at once. The end date is included. Files are kept about a day (closed windows a week). Needs the marketData plan feature; no credit. symbol_not_found means the ticker is wrong: check list_markets, do not retry. For a Discover or Shape baseline, use playbook_run_job_on_server instead.