Backtest360

The configured API key's permissions, limits, and current usage. Cheap. Call early in a session — before planning work — to learn what this key can do instead of discovering limits through failed calls. Returns: ``scopes``: the permission scopes the key carries. ``limits``: requests per minute and per day, max concurrent requests, and the per-run bar cap (null when uncapped). ``usage``: current consumption against those limits, with reset countdowns in seconds. ``capabilities``: feature flags such as server-side data fetch and the full metric set. A small fixed-shape record, returned as the engine sent it.

{
  "type": "object",
  "properties": {},
  "title": "get_meArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_meDictOutput"
}

Engine version, API contract number, and health. Free (not quota-counted). Call once at the start of a session to confirm the engine is reachable and which contract it serves.

{
  "type": "object",
  "properties": {},
  "title": "engine_infoArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "engine_infoDictOutput"
}

Fetch one engine reference catalog. Catalogs (cheap, cacheable per session): - 'operators' — comparison operators for condition expressions - 'execution-modes' — entry/exit anchors and fill algorithms, with the validity matrix by market type - 'stop-types' — stop-loss types, re-entry modes, and their parameters - 'sizing-methods' — position-sizing methods and their parameters - 'bar-frequencies' — supported bar frequencies and the signal x execution validity matrix (which combinations are allowed) - 'sections' — the full metric catalog: every statistic's stable id, display label, section, and description - 'sampling-modes' — Monte-Carlo resampling modes, each with its status and parameters Fetch the relevant catalog BEFORE building a strategy or config; build only from values it lists — never guess parameter names or frequencies.

{
  "type": "object",
  "properties": {
    "catalog": {
      "enum": [
        "operators",
        "execution-modes",
        "stop-types",
        "sizing-methods",
        "bar-frequencies",
        "sections",
        "sampling-modes"
      ],
      "title": "Catalog",
      "type": "string"
    }
  },
  "required": [
    "catalog"
  ],
  "title": "get_catalogArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_catalogDictOutput"
}

List indicators, or fetch one indicator's full schema. Cheap, cacheable per session. With no arguments: a compact catalog — ``{"indicators": [...], "count": N}`` — where each entry carries id, name, category, kind, and value_dtype (no description, to keep the discovery scan small). Use it to discover what exists. Pass name='rsi' (id or name, case-insensitive) to get that single indicator's complete entry including its description and params_schema — do this before adding an indicator to a strategy so its parameters are exactly right. Pass compact=False for full entries for everything (large; the MCP server may cap it and set ``truncated_by_mcp`` — prefer compact or name=). Wire optimization: the compact discovery path asks the engine to omit per-entry descriptions (``descriptions=false``) since they are stripped locally anyway; the name= and compact=False paths request them. This is a pure saving — if the engine ignores the param it returns full entries and the local compact strip still yields a lean result.

{
  "type": "object",
  "properties": {
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Name"
    },
    "compact": {
      "default": true,
      "title": "Compact",
      "type": "boolean"
    }
  },
  "title": "list_indicatorsArguments"
}

List predesigned strategy templates, or fetch one in full. Cheap, cacheable per session. The engine returns the templates available to the calling key. With no arguments: a compact catalog — ``{"templates": [...], "count": N}`` — where each entry carries id, origin, name, and description. Use it to discover what exists. Pass name='sma-cross' (id or name, case-insensitive) to get that single template's complete entry: its strategy logic (``condition_tree`` + ``indicators``, the same shape validate_strategy and run_backtest accept) plus parameter metadata — ``defaults`` (starting parameter values), ``requires``, and ``locked_params`` (parameters that must keep their template values). Pass compact=False for complete entries for everything (large; the MCP server may cap it and set ``truncated_by_mcp`` — prefer compact or name=).

{
  "type": "object",
  "properties": {
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Name"
    },
    "compact": {
      "default": true,
      "title": "Compact",
      "type": "boolean"
    }
  },
  "title": "list_templatesArguments"
}

JSON Schema for the strategy document (condition_tree + indicators). Fetch this before composing a strategy by hand; the validate_strategy tool checks against the same rules.

{
  "type": "object",
  "properties": {},
  "title": "get_strategy_schemaArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_strategy_schemaDictOutput"
}

Validate a strategy document without running a backtest. A cheap quota separate from backtest runs, so validate freely and ALWAYS before run_backtest. Args: strategy: The strategy document — name, indicators[], and condition_tree (see get_strategy_schema for the exact shape). injected_indicators: Names of custom time-series columns the caller will supply via data_inputs at run time, so conditions referencing them validate. Returns: On success: {"valid": true, "warmup_bars": ..., referenced indicators/columns}. On failure: {"valid": false, "errors": [...]} where each error carries a machine code, the location in the document, a message, and context (e.g. the list of valid column names). A failed validation is a NORMAL result, not an error — read the errors, fix the document, and validate again before running.

{
  "type": "object",
  "properties": {
    "strategy": {
      "additionalProperties": true,
      "title": "Strategy",
      "type": "object"
    },
    "injected_indicators": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Injected Indicators"
    }
  },
  "required": [
    "strategy"
  ],
  "title": "validate_strategyArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "validate_strategyDictOutput"
}

Run a historical backtest against the engine. Quota-counted and compute-bound. Validate the strategy first (validate_strategy is far cheaper). On a 504 compute timeout, do NOT retry the same request — reduce the date range, use a coarser frequency, or simplify the strategy. On 429/503, wait for the advertised Retry-After before retrying. Args: data_source: Either inline OHLCV ({"ohlcv": {dates, open, high, low, close, volume?}} as parallel arrays, ISO-8601 dates) or a server-side fetch ({"symbol", "start", "end", "frequency"} — requires a paid plan). strategy: Strategy document (indicators[] + condition_tree). Mutually exclusive with signals. signals: Precomputed signal series ({"dates": [...], "values": [-1|0|1, ...]}). Mutually exclusive with strategy. execution: Execution/cost/risk/sizing settings. Use values from get_catalog('execution-modes'/'stop-types'/'sizing-methods'); omit for engine defaults. benchmark: Optional benchmark data source (same shape as data_source) — when given, the result also carries benchmark-relative metrics (beta, alpha, information ratio, tracking error, up/down capture) and bar-alignment info. data_inputs: Optional custom time-series the strategy references (name -> {dates, values}). response_detail: 'summary' (default — headline metrics, smallest), 'stats' (every metric), 'full' (plus trades and series downsampled to a fixed, server-controlled number of points). include: Optional add-on blocks at any detail level: 'trades', 'equity_curve', 'monthly_returns', 'yearly_returns', 'signal_diagnostics' (which per-bar entry/exit conditions fired, as capped fire-date lists — {"available": false, ...} if the run has none, e.g. precomputed signals). trades_limit: Max trades returned when trades are included. Returns: The shaped result at the requested detail (including ``benchmark_relative``/``alignment`` when a benchmark was given); an oversized result is thinned and marked ``truncated_by_mcp``. If the engine rejects the request as invalid (400/422), returns {"accepted": false, "error": ...} so you can fix the named field(s) and retry. Capacity, timeout, and permission failures (e.g. 429/503/504/401/403) raise a tool error carrying explicit recovery guidance.

{
  "type": "object",
  "properties": {
    "data_source": {
      "additionalProperties": true,
      "title": "Data Source",
      "type": "object"
    },
    "strategy": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Strategy"
    },
    "signals": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Signals"
    },
    "execution": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Execution"
    },
    "benchmark": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Benchmark"
    },
    "data_inputs": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Data Inputs"
    },
    "response_detail": {
      "default": "summary",
      "enum": [
        "summary",
        "stats",
        "full"
      ],
      "title": "Response Detail",
      "type": "string"
    },
    "include": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Include"
    },
    "trades_limit": {
      "default": 50,
      "title": "Trades Limit",
      "type": "integer"
    }
  },
  "required": [
    "data_source"
  ],
  "title": "run_backtestArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "run_backtestDictOutput"
}

Evaluate the strategy on the most recent bar only — no P&L, no stats. Returns the latest signal (-1/0/1), which condition slots fired, and the bar timestamp. Use for "what would this strategy do right now" questions; use run_backtest for performance.

{
  "type": "object",
  "properties": {
    "data_source": {
      "additionalProperties": true,
      "title": "Data Source",
      "type": "object"
    },
    "strategy": {
      "additionalProperties": true,
      "title": "Strategy",
      "type": "object"
    },
    "execution": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Execution"
    },
    "data_inputs": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Data Inputs"
    }
  },
  "required": [
    "data_source",
    "strategy"
  ],
  "title": "get_latest_signalArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_latest_signalDictOutput"
}

Run several strategies on the same data and compare side by side. One quota-counted call, but compute scales with the number of strategies. If the wall-clock compute budget is exceeded, the call fails with a tool error (504) instead of returning partial results — narrow the request (fewer strategies, shorter date range, coarser frequency) and retry. Args: data_source: Shared data source (same shape as run_backtest). strategies: List of {"label": str, "strategy": {...}, "execution": {...}?} entries. Labels need not be unique or id-safe — they are echoed back verbatim in the result. include_benchmark: Add a buy-and-hold benchmark to the comparison. response_detail: Shaping level applied to each strategy's result. trades_limit: Max trades per strategy when detail is 'full'. Returns: {"strategies": [{"label", "result"}, ...], "equity_curves": {...}, "alignment"?}, each result shaped at the requested detail. When a benchmark is included, non-benchmark entries also carry "relative" (beta, alpha, information ratio, etc.). A 400/422 rejection returns {"accepted": false, "error": ...}; capacity/timeout/permission failures raise a tool error.

{
  "type": "object",
  "properties": {
    "data_source": {
      "additionalProperties": true,
      "title": "Data Source",
      "type": "object"
    },
    "strategies": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Strategies",
      "type": "array"
    },
    "include_benchmark": {
      "default": false,
      "title": "Include Benchmark",
      "type": "boolean"
    },
    "response_detail": {
      "default": "summary",
      "enum": [
        "summary",
        "stats",
        "full"
      ],
      "title": "Response Detail",
      "type": "string"
    },
    "trades_limit": {
      "default": 50,
      "title": "Trades Limit",
      "type": "integer"
    }
  },
  "required": [
    "data_source",
    "strategies"
  ],
  "title": "compare_backtestsArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "compare_backtestsDictOutput"
}

Export a multi-strategy comparison as an Excel workbook. Quota-counted; needs a key whose plan includes full-metrics export (a 403 means the configured key's plan does not — do not retry). Returns the workbook base64-encoded — decode and write it to a ``.xlsx`` file. Args: data_source: Shared data source (same shape as run_backtest). strategies: Same shape as compare_backtests' ``strategies``. include_benchmark: Add a buy-and-hold benchmark to the export. Returns: {"filename", "content_type", "size_bytes", "content_base64"}. A 400/422 rejection returns {"accepted": false, "error": ...}; capacity/timeout/permission failures raise a tool error. If the encoded workbook would exceed the output size limit, raises a tool error — narrow the request (shorter date range, fewer strategies, coarser frequency) and retry.

{
  "type": "object",
  "properties": {
    "data_source": {
      "additionalProperties": true,
      "title": "Data Source",
      "type": "object"
    },
    "strategies": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Strategies",
      "type": "array"
    },
    "include_benchmark": {
      "default": false,
      "title": "Include Benchmark",
      "type": "boolean"
    }
  },
  "required": [
    "data_source",
    "strategies"
  ],
  "title": "export_backtestArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "export_backtestDictOutput"
}

Compute the engine's performance metrics from a returns series. Use when the returns came from somewhere other than run_backtest (an external system, a portfolio) — backtest results already include these statistics. Args: returns: Per-bar log returns as {"dates": [...], "values": [...]} parallel arrays (ISO-8601 dates). trading_days_per_year: Required annualization factor — 252 for a daily equities calendar, 365 for 24/7 crypto. Must match the bar calendar of the returns series; a wrong value silently mis-annualizes Sharpe, volatility, and CAGR. benchmark_returns: Optional benchmark series, same shape — adds alpha/beta/capture metrics. trades: Optional trade records (entry_date, exit_date, direction, return_net, ...) — adds trade-level metrics. risk_free_rate: Annual risk-free rate as a decimal. Returns: {"stats": {...}} — the metric set the API key's plan allows. See get_catalog('sections') for every metric's id and description.

{
  "type": "object",
  "properties": {
    "returns": {
      "additionalProperties": true,
      "title": "Returns",
      "type": "object"
    },
    "trading_days_per_year": {
      "title": "Trading Days Per Year",
      "type": "integer"
    },
    "benchmark_returns": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Benchmark Returns"
    },
    "trades": {
      "anyOf": [
        {
          "items": {
            "additionalProperties": true,
            "type": "object"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Trades"
    },
    "risk_free_rate": {
      "default": 0,
      "title": "Risk Free Rate",
      "type": "number"
    }
  },
  "required": [
    "returns",
    "trading_days_per_year"
  ],
  "title": "compute_statsArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "compute_statsDictOutput"
}

Search available assets by ticker or name (relevance-ranked). Use to resolve a user's asset mention ("bitcoin", "S&P") to the exact ticker before requesting a server-side data fetch. asset_class filters to 'stocks', 'crypto', 'forex', or 'indices'.

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "asset_class": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Asset Class"
    },
    "limit": {
      "default": 20,
      "title": "Limit",
      "type": "integer"
    }
  },
  "required": [
    "query"
  ],
  "title": "search_tickersArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "search_tickersDictOutput"
}

List available tickers, optionally filtered by asset class. The full universe is very large, so the MCP server caps the returned list and marks it ``truncated_by_mcp`` — pass asset_class to narrow it, or use search_tickers to resolve a specific asset by name.

{
  "type": "object",
  "properties": {
    "asset_class": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Asset Class"
    }
  },
  "title": "list_tickersArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "list_tickersDictOutput"
}

Available date range and estimated bar count for a symbol/frequency. Available on paid plans. Call before a server-side fetch so the requested start/end stay inside what the provider can deliver and the bar count stays inside the key's per-run limit.

{
  "type": "object",
  "properties": {
    "symbol": {
      "title": "Symbol",
      "type": "string"
    },
    "frequency": {
      "title": "Frequency",
      "type": "string"
    }
  },
  "required": [
    "symbol",
    "frequency"
  ],
  "title": "get_data_rangeArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_data_rangeDictOutput"
}

Identity and data coverage for one symbol, in a single call. Metadata only — no market data, so no paid plan is needed. Returns the asset's identity (name, asset class, exchange, currency, and whether it is still active) together with a coverage summary for the given frequency: the available date range and an estimated bar count. Use it to confirm a symbol resolves and that the history you need exists before requesting a quote or a price fetch. For the precise per-frequency range use get_data_range.

{
  "type": "object",
  "properties": {
    "symbol": {
      "title": "Symbol",
      "type": "string"
    },
    "frequency": {
      "default": "daily",
      "title": "Frequency",
      "type": "string"
    }
  },
  "required": [
    "symbol"
  ],
  "title": "get_ticker_infoArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_ticker_infoDictOutput"
}

Latest available price for a symbol. Requires a paid plan (managed market data). Returns the most recent *available* bar for the given frequency — the end-of-day close for daily, the last completed bar otherwise — as open/high/low/close/volume plus an ``as_of`` timestamp for that bar. This is a last-known price, not a live tick; read ``as_of`` to judge how stale it is.

{
  "type": "object",
  "properties": {
    "symbol": {
      "title": "Symbol",
      "type": "string"
    },
    "frequency": {
      "default": "daily",
      "title": "Frequency",
      "type": "string"
    }
  },
  "required": [
    "symbol"
  ],
  "title": "get_quoteArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_quoteDictOutput"
}

OHLCV price history for a symbol over a date range. Requires a paid plan (managed market data). ``start`` is required (``YYYY-MM-DD``); ``end`` defaults to today. Returns a summary (symbol, resolved date range, total bar count, price range, gap flags), market-hours detection, and the OHLCV arrays. A long history is downsampled by the MCP server to a bounded number of points — first and last bar always kept, every column thinned on the same dates — with ``downsampled_from_bars`` and ``points_returned`` recorded on the ``ohlcv`` block; the untouched ``summary.total_bars`` still reports the true bar count. The window is bounded by the plan's per-request bar cap — call get_data_range first to size a request.

{
  "type": "object",
  "properties": {
    "symbol": {
      "title": "Symbol",
      "type": "string"
    },
    "start": {
      "title": "Start",
      "type": "string"
    },
    "frequency": {
      "default": "daily",
      "title": "Frequency",
      "type": "string"
    },
    "end": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "End"
    }
  },
  "required": [
    "symbol",
    "start"
  ],
  "title": "get_price_historyArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_price_historyDictOutput"
}

List the available macroeconomic series (the catalog). Free — no special plan. Returns the set of macro series you can fetch with get_macro_series, each with its stable ``id`` (the value get_macro_series takes), title, category, native reporting frequency, and units, plus the list of categories. Optionally filter to one ``category`` (e.g. rates, yield_curve, inflation, employment, recession, growth). Call this first to find the ``id`` for the series you want.

{
  "type": "object",
  "properties": {
    "category": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Category"
    }
  },
  "title": "list_macro_seriesArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "list_macro_seriesDictOutput"
}

Observations for one macroeconomic series over an optional date range. Free — no special plan. ``series`` is an ``id`` from list_macro_series (e.g. treasury_10y, cpi, unemployment_rate); arbitrary external ids are not accepted. ``start``/``end`` are ``YYYY-MM-DD``, inclusive, both optional (full history when omitted). Returns the value series at its native reporting frequency, with the series descriptor and an ``as_of`` date. A long history is downsampled by the MCP server to a bounded number of points (first and last kept), marked with ``downsampled_from_bars`` and ``points_returned`` on the ``observations`` block. Note: values are the latest revised figures stamped by reference period, not point-in-time as-first-reported data — do not treat them as the values that were known at a past date.

{
  "type": "object",
  "properties": {
    "series": {
      "title": "Series",
      "type": "string"
    },
    "start": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Start"
    },
    "end": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "End"
    }
  },
  "required": [
    "series"
  ],
  "title": "get_macro_seriesArguments"
}

{
  "type": "object",
  "additionalProperties": true,
  "title": "get_macro_seriesDictOutput"
}