Skip to main content
Glama
trading212-mcp

trading212-mcp

trading212-mcp

MCP server for the Trading 212 public API — equities and ETF investing on Invest and Stocks ISA accounts. It exposes the account, portfolio, order, pie, and history endpoints as MCP tools, defaults to the demo (paper trading) environment, and keeps trading tools hidden unless explicitly enabled.

Features

  • Read coverage of the whole public API: account summary, instrument universe, exchange schedules, open positions, pending orders, pies, historical orders, dividends, cash transactions, and CSV exports.

  • Trading tools (order placement/cancellation, pie management, export requests) are opt-in via an environment flag and stay invisible to the MCP client otherwise.

  • Demo environment by default; live is an explicit choice.

  • Responses are trimmed to the fields a trader acts on, and list tools accept a limit parameter to keep payloads small.

  • One automatic retry on HTTP 429, honouring the Retry-After header capped at 30 seconds (Trading 212 rate limits are strict and per-endpoint).

  • stdio transport by default, HTTP (/mcp) on request.

Related MCP server: tastytrade-mcp

Tools

Read tools (always registered):

Tool

Description

get_account_summary

Account summary: cash breakdown, investments, and overall result

list_exchanges

Exchanges with working schedules trimmed to session open/close events

list_instruments

Search the tradable instrument universe by ticker/name substring and type

get_portfolio

List all open positions with quantity, prices, and unrealized P/L

get_position

Fetch a single open position by its Trading 212 ticker

list_orders

List all pending equity orders

get_order

Fetch one pending equity order by its id

list_pies

List all pies with money-in, progress, and performance

get_pie

Fetch one pie's full definition and per-instrument breakdown

list_historical_orders

List executed equity orders, newest first (cursor-paginated)

list_dividends

List paid-out dividends (cursor-paginated)

list_transactions

List cash transactions: deposits, withdrawals, fees, transfers (cursor-paginated)

list_exports

List requested CSV export reports and their processing status

Write tools (registered only when T212_MCP_ENABLE_TRADING is truthy):

Tool

Description

place_market_order

Place a market order (positive quantity = BUY, negative = SELL)

place_limit_order

Place a limit order with a limit price and DAY/GTC validity

place_stop_order

Place a stop order that triggers a market order at the stop price

place_stop_limit_order

Place a stop-limit order (limit order placed once the stop triggers)

cancel_order

Cancel a pending equity order by its id

create_pie

Create a new pie from a ticker-to-weight allocation map

update_pie

Replace an existing pie's definition (name and full allocation)

delete_pie

Delete a pie by ID (irreversible)

duplicate_pie

Duplicate an existing pie under a new name

request_export

Request an asynchronous CSV export report of account history

Configuration

All configuration is via environment variables — never commit credentials.

Variable

Default

Purpose

T212_API_KEY

— (required)

API key (Basic auth username), generated in the Trading 212 app

T212_API_SECRET

— (required)

API secret (Basic auth password)

T212_ENV

demo

Target environment: demo (paper trading) or live (real money)

T212_MCP_ENABLE_TRADING

off

Set to true/1/yes/on to register the write tools

Getting started

Run straight from the repository with uv:

uvx --from git+https://github.com/florinel-chis/trading212-mcp trading212-mcp

The server speaks stdio by default; add --transport http --port 8000 to serve MCP over HTTP at /mcp instead. HTTP binds 127.0.0.1 by default, and a non-loopback --host is refused unless --allow-remote is also passed — read the Safety section before using that flag.

MCP client configuration

Add the server to your MCP client's configuration (stdio, via uvx):

{
  "mcpServers": {
    "trading212": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/florinel-chis/trading212-mcp", "trading212-mcp"],
      "env": {
        "T212_API_KEY": "your-api-key",
        "T212_API_SECRET": "your-api-secret"
      }
    }
  }
}

Or run the Docker image (build it first, see below):

{
  "mcpServers": {
    "trading212": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "T212_API_KEY",
        "-e", "T212_API_SECRET",
        "trading212-mcp"
      ],
      "env": {
        "T212_API_KEY": "your-api-key",
        "T212_API_SECRET": "your-api-secret"
      }
    }
  }
}

Docker

docker build -t trading212-mcp .

# stdio (what MCP clients spawn)
docker run -i --rm -e T212_API_KEY -e T212_API_SECRET trading212-mcp

# HTTP at http://127.0.0.1:8000/mcp — publish the port on loopback only:
# the MCP endpoint is unauthenticated (see Safety)
docker run --rm -p 127.0.0.1:8000:8000 -e T212_API_KEY -e T212_API_SECRET \
  trading212-mcp --transport http --host 0.0.0.0 --port 8000 --allow-remote

(--host 0.0.0.0 binds inside the container so the port mapping works — which is why --allow-remote is needed; the 127.0.0.1: prefix on -p keeps the endpoint reachable from this machine only.)

Safety

  • The HTTP transport has no authentication: anyone who can reach the /mcp endpoint can call every registered tool — read the account, and place/cancel orders or delete pies if T212_MCP_ENABLE_TRADING is set — all signed with your API key. Keep it bound to 127.0.0.1 (the CLI default; with Docker, publish as -p 127.0.0.1:8000:8000) or put it behind an authenticating reverse proxy. Never expose it directly on a public or shared network.

  • The server defaults to the demo (paper trading) environment; set T212_ENV=live deliberately.

  • Trading tools are not registered — invisible to the MCP client — unless T212_MCP_ENABLE_TRADING is truthy.

  • The Trading 212 API is v0 beta: order endpoints are not idempotent (resending a request may create duplicate orders), and rate limits are strict and per-endpoint (each tool documents its limit).

  • Use at your own risk. Nothing here is investment advice.

Development

uv sync
uv run pytest -q
uv run ruff check .

License

MIT

Available Tools

13 tools
get_account_summaryA
Read-only

Get the account summary: cash breakdown, investments, and overall result.

Returns a dict with:

  • id: primary trading account number.

  • currency: ISO 4217 primary account currency; every monetary value below is denominated in it.

  • totalValue: total account value (cash plus investments).

  • cash: availableToTrade (free funds), reservedForOrders (held for pending orders), inPies (uninvested cash inside pies).

  • investments: currentValue, totalCost (cost basis of the current holdings), realizedProfitLoss (all-time realized P/L), unrealizedProfitLoss.

Rate limit: 1 request per 5 seconds.

Inputs: no named parameters. Returns: object

get_orderA
Read-only

Fetch one pending equity order by its id.

Returns the order's id, ticker, type (LIMIT|STOP|MARKET|STOP_LIMIT), side (BUY|SELL), status, quantity, filledQuantity, limitPrice / stopPrice (when applicable), timeInForce, currency, extendedHours and createdAt. Responds HTTP 404 if no pending order has that id. Rate limit: 1 request per 1 second.

Inputs: order_id (required). Returns: object

get_pieA
Read-only

Fetch one pie's full definition and per-instrument breakdown.

Returns the pie settings (id, name, icon, goal in account currency, creationDate, endDate, dividendCashAction, initialInvestment, instrumentShares as a ticker-to-weight map, publicUrl) plus an instruments list with each holding's ticker, ownedQuantity, currentShare vs expectedShare (weights, 0..1), result, and any issues (e.g. DELISTED, SUSPENDED) with severity. Raises HTTP 404 if the pie does not exist. Rate limit: 1 request per 5 seconds.

Inputs: pie_id (required). Returns: object

get_portfolioA
Read-only

List all open positions in the account.

Returns up to limit positions, each with: ticker (Trading 212 identifier, e.g. "AAPL_US_EQ"), quantity (shares held, fractional allowed), averagePrice and currentPrice (per share, instrument currency), ppl (unrealized profit/loss, account currency), fxImpact (currency-conversion component of ppl, account currency; null when the instrument trades in the account currency), and initialFillDate (ISO 8601 timestamp the position was opened).

Rate limit: 1 request per 1 second.

Inputs: limit. Returns: Generic wrapper for non-object return types.

get_positionA
Read-only

Fetch a single open position by its Trading 212 ticker.

Returns the same trimmed fields as get_portfolio: ticker, quantity (shares, fractional allowed), averagePrice and currentPrice (per share, instrument currency), ppl (unrealized profit/loss, account currency), fxImpact (nullable, account currency), initialFillDate (ISO 8601). Errors if there is no open position for the ticker.

Rate limit: 1 request per 1 second.

Inputs: ticker (required). Returns: object

list_dividendsA
Read-only

List paid-out dividends.

Returns {"items": [...], "next_cursor": str | None}. Each item: ticker, paidOn (ISO 8601), amount (net, in the account currency), grossAmountPerShare (in the instrument currency), quantity (shares held), type (e.g. ORDINARY, INTEREST, CAPITAL_GAINS), reference. Pass next_cursor back as cursor for the next page; it is null on the last page. Rate limit: 6 requests per 1 minute.

Inputs: limit, cursor, ticker. Returns: object

list_exchangesA
Read-only

List exchanges with working schedules trimmed to session open/close events.

Returns one entry per exchange: id, name (e.g. "NYSE"), and workingSchedules. Each schedule carries its id (instruments reference it via workingScheduleId) and events — the time events filtered down to OPEN and CLOSE (pre-market, after-hours, overnight, and break events are dropped). Event date values are ISO 8601 timestamps.

Rate limit: 1 request per 30 seconds (data refreshes server-side every 10 minutes).

Inputs: limit. Returns: Generic wrapper for non-object return types.

list_exportsA
Read-only

List requested CSV export reports and their processing status.

Returns {"items": [...]} where each report has: reportId, timeFrom, timeTo, dataIncluded (the four include* flags), status, downloadLink (populated once the report is finished). Status values are Mixed-Case, not upper-case: "Queued", "Processing", "Running", "Canceled", "Failed", "Finished". Poll this after request_export until the report's status is "Finished", then fetch the CSV from downloadLink. Rate limit: 1 request per 1 minute.

Inputs: limit. Returns: object

list_historical_ordersA
Read-only

List executed (historical) equity orders, newest first.

Returns {"items": [...], "next_cursor": str | None}. Each item has an "order" part (id, ticker, type LIMIT|STOP|MARKET|STOP_LIMIT, side BUY|SELL, status, quantity, filledQuantity, limitPrice, stopPrice, timeInForce DAY|GOOD_TILL_CANCEL, currency, createdAt) and a "fill" part (filledAt, price, quantity, type e.g. TRADE, tradingMethod TOTV|OTC) plus a "walletImpact" with netValue and realisedProfitLoss in the account currency. Pass next_cursor back as cursor to fetch the next page; next_cursor is null on the last page. Rate limit: 6 requests per 1 minute.

Inputs: limit, cursor, ticker. Returns: object

list_instrumentsA
Read-only

Search the tradable instrument universe.

The API returns the full universe (roughly 17,000 instruments) in one response with no server-side filtering, so search, instrument_type, and limit are applied client-side here.

Rate limit: 1 request per 50 seconds — strict. Every call fetches the whole universe, so batch your lookups into one broad search rather than issuing several calls in quick succession.

Returns per instrument: ticker (unique T212 identifier such as "AAPL_US_EQ"; may contain "/" like "BRK/A_US_EQ"), type, name, shortName (exchange symbol, may contain dots), isin, currencyCode (ISO 4217, except "GBX" — pence — for some LSE lines), maxOpenQuantity (fractional allowed), and extendedHours (whether it trades outside the regular session).

Inputs: limit, search, instrument_type. Returns: Generic wrapper for non-object return types.

list_ordersA
Read-only

List all pending (not yet filled/cancelled/expired) equity orders.

Returns a list of order objects with: id, ticker (e.g. 'AAPL_US_EQ'), type (LIMIT|STOP|MARKET|STOP_LIMIT), side (BUY|SELL), status, quantity, filledQuantity, limitPrice/stopPrice (when applicable), timeInForce (DAY|GOOD_TILL_CANCEL), currency, extendedHours, createdAt. The API returns every pending order; limit truncates the list locally. Rate limit: 1 request per 5 seconds.

Inputs: limit. Returns: Generic wrapper for non-object return types.

list_piesA
Read-only

List all pies in the account with money-in, progress, and performance.

Returns a list of pie summaries: id (use with get_pie), cash (money put into the pie, in the account currency), progress (fraction of the goal reached, 0..1), status ("AHEAD" | "ON_TRACK" | "BEHIND"), dividendDetails (gained/inCash/reinvested), and result (invested value, absolute result, result coefficient, current value). The API returns all pies; the limit is applied after fetching. Rate limit: 1 request per 30 seconds.

Inputs: limit. Returns: Generic wrapper for non-object return types.

list_transactionsA
Read-only

List cash transactions (deposits, withdrawals, fees, transfers).

Returns {"items": [...], "next_cursor": str | None}. Each item: type (WITHDRAW | DEPOSIT | FEE | TRANSFER), amount (in the transaction currency), currency, dateTime (ISO 8601), reference (transaction ID). Unlike the other history endpoints the cursor here is a string, not a number. Pass next_cursor back as cursor for the next page; it is null on the last page. Rate limit: 6 requests per 1 minute.

Inputs: time, limit, cursor. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 13 tools

    Disambiguation5/5

    Each tool targets a distinct resource or action (e.g., orders vs. positions vs. pies), and similar operations are differentiated by scope (list vs. single item) or state (pending vs. historical). No overlapping purposes exist.

    Naming Consistency5/5

    All tools follow a consistent `verb_noun` pattern with snake_case: `get_*` for single items and `list_*` for collections. No mixed conventions or vague verbs.

    Tool Count5/5

    13 tools cover the major facets of a trading account (overview, orders, positions, pies, dividends, exchanges, exports, instruments, transactions) without being excessive. Each tool earns its place.

    Completeness2/5

    The server is entirely read-only; it lacks tools for creating, modifying, or canceling orders, managing pies (create/update), or initiating trading actions. For a trading platform, these are critical gaps that will limit agent functionality.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      MCP server for the Trading 212 API. Provides 28 tools for portfolio management, trading, pies, dividends, market data, and analytics.
      28
      125 PyPI
      10
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      MCP server for the tastytrade brokerage API, providing tools for account management, market data, and order execution.
      18
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that wraps the Trading 212 Public API, enabling AI agents to interact with your Trading 212 brokerage account through natural language.
      16
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Exposes Trading 212 trading account, instruments, orders, history, and pies as MCP tools. Allows placing and canceling real orders (defaults to demo/paper environment).
      Apache 2.0