CMP-server Pocket Option 2026

A modern, async, fully-typed bridge between AI assistants and the PocketOption trading platform. Plug it into Claude Code, Claude Desktop, Cursor — or drive it from GPT / Grok — solo or as a coordinated team of analysts and traders. Your model can read balances, pull candles, screen assets, and place trades through clean MCP tools.

📖 Full guide (English + Русский): GETTING_STARTED.md · ⚙️ SETUP.md · 🩺 TROUBLESHOOTING.md

🎯 What it is — and what it isn't

• It is clean, typed, tested infrastructure: a way to wire AI models into PocketOption over MCP, with real async plumbing, safety-first defaults, per-model memory, and multi-agent coordination. A solid base to build and learn on.

• It isn't a profitable strategy or a "money-making bot." Binary options are negative-expectation, and this API is unofficial (reverse-engineered). The tooling makes agents disciplined and safe, not profitable — treat it as a framework and a learning / engineering showcase, and stay on demo.

Related MCP server: :GT Protocol MCP Server

✨ Why this exists

Most PocketOption wrappers hand-roll the socket.io protocol, ship broken imports, disable TLS verification, and leak your session token into logs. This one doesn't.

• 🧠 AI-native — exposes trading as first-class MCP tools, so any MCP host can use it with zero glue code.

• ⚡ Truly async & event-driven — built on python-socketio; prices, fills and candles resolve on real events, no polling loops.

• 🔒 Secure by default — TLS verification on, session tokens redacted from every log and protocol dump, real-money trading gated behind an explicit flag.

• 🧩 Model-agnostic core — the trading logic lives once in client.py; Claude, GPT and Grok are thin facades over it.

• 🧪 Actually tested — 72 offline tests (parsing, routing, safety guards, secret redaction) that need no network and no SSID.

• 🐍 Typed & pinned — full type hints, py.typed, and a pinned Python version so tools never silently "modernize" your project.

🛠️ What your AI can do through it

The model computes its own indicators from get_candles — it never needs to read a chart image.

🤝 One model — or a whole trading desk

Connect a single model, or run several at the same time. Every model gets the exact same PocketOption toolset, and an optional shared opinion board lets them operate as a team — analysts posting reads, a trader acting on the consensus.

Turn them into a desk. Run two or three models side by side and they coordinate through a shared, TTL-expiring opinion board (post_opinion / read_opinions): e.g. GPT and Grok each post an analyst read on EURUSD_otc, and Claude reads the board and only places the trade when they agree. They can also talk directly — send_message / read_messages, broadcast or addressed to one agent by name — to ask questions, agree a plan, or divide work. Each agent's role is just its name + instructions (drop a per-model manual in agent_manuals/) — so you decide who researches and who pulls the trigger.

flowchart TB
    TV["📈 TradingView<br/>(optional data)"] -.-> G
    TV -.-> K
    G["🤖 GPT — analyst"] -->|post_opinion| B[("opinions.json<br/>shared board · TTL 15m")]
    K["🤖 Grok — analyst"] -->|post_opinion| B
    B -->|read_opinions| C["🤖 Claude — trader"]
    C -->|place_trade| PO[("🟢 PocketOption")]

Roles aren't hardcoded — the board just lets agents post and read each other's views. Whether a model acts as an analyst, a risk-checker, or the one that trades is defined by the prompt/instructions you give it and its AGENT_NAME.

🏗️ Architecture

flowchart LR
    AI["🤖 Claude · GPT · Grok"] -->|MCP tools| S["mcp_server.py<br/>(MCP facade)"]
    S --> C["client.py<br/><b>model-agnostic core</b>"]
    C -->|socket.io / WSS| PO[("🟢 PocketOption")]
    C --> M["models.py<br/>typed parsing"]
    C --> MEM["memory.py<br/>strategies + opinions"]
    TV["📈 TradingView MCP<br/>(optional)"] -.real-pair data.-> AI

The core knows nothing about any LLM. New models plug in as thin facades over the same client.py — the trading logic is written once.

🚀 Quick start

# 1. install (registers the `pocketoption-mcp` command)
pip install .

# 2. grab your DEMO SSID from pocketoption.com
#    F12 → Network → websocket → the 42["auth",{...}] frame with "session"/"isDemo"

# 3. point Claude at it — merge the mcpServers block from
#    claude_config_example.json into your Claude / Cursor config, then restart.

Then just ask your assistant: "What PocketOption tools do you have?" → "Show my balance and the top 5 OTC pairs by payout."

# bash / zsh
export PO_SSID='42["auth",{...}]'
pocketoption-mcp        # or: python -m cmp_server_pocket_option_2026.mcp_server

# PowerShell
$env:PO_SSID='42["auth",{...}]'
pocketoption-mcp

It should print Connected to … (demo) and wait. Ctrl+C to stop.

Full step-by-step (installing Python, getting the SSID, config file locations) lives in GETTING_STARTED.md.

📈 Optional: TradingView for real (non-OTC) pairs

OTC pairs are synthetic, so outside data can't help there — the model reads them from candles alone. For real pairs you can run the third-party tradingview-mcp server alongside this one (needs uv, no TradingView account). The tradingview block in claude_config_example.json wires it up. Note: PocketOption's EURUSD maps to TradingView's FX:EURUSD — the two don't share a symbol namespace, so the model bridges them.

🧪 Development

pip install ".[dev]"
pytest                               # 66 offline tests — no network, no SSID
ruff check .                         # lint
mypy cmp_server_pocket_option_2026   # type-check

The suite is deliberately offline: it swaps the transport for a fake and feeds captured-shape events into the client, validating parsing, routing, safety guards and secret-redaction without ever touching PocketOption. CI runs all three on Python 3.10 / 3.11 / 3.12 / 3.13.

Runtime artifacts (sessions/, strategies/, opinions.json, dump.jsonl) are git-ignored. sessions/ holds your account token — never commit or share it.

🧰 Tech stack

 python-socketio  ·  pydantic v2  ·  mcp  ·  pytest  ·  ruff  ·  mypy

⭐ Support the project

If this saved you time or you find it interesting, give it a ⭐ — it's the single biggest thing that helps the project reach other traders and developers. Fork it, build on it, share it (it's MIT).

🐛 Found a bug? 💡 Have an idea?

Contributions of every size are welcome — the project is actively developed and open to collaborators.

• 🐞 Bug → open an issue with the Bug report template. Redact your SSID before pasting logs.

• 💡 Feature or improvement → open an issue with the Feature request template.

• 💬 Questions / open discussion → the Discussions tab.

• 🔧 Want to code? → PRs welcome — read CONTRIBUTING.md first (it's short). Good first areas: new indicators, more model adapters, better desk coordination.

💚 Support development

Building and maintaining this is unpaid open-source work. If it's useful to you, a donation keeps it moving — completely optional, and thank you 🙏

Bybit UID: 497849886

How to send: in the Bybit app, use Send / transfer by UID (Bybit Pay), enter UID 497849886, then pick the coin and amount. Bybit-to-Bybit transfers are instant and fee-free. (The QR just encodes the UID for quick copying — it doesn't auto-open a payment.)

📈 Star history

📜 License

MIT © 2026 Rufus011 — build on it freely, trade at your own risk.