Capital.com Public API MCP Server

Capital.com MCP Server

Serveur Model Context Protocol (MCP) pour l'API ouverte de Capital.com - permettant un accès piloté par LLM à votre compte de trading Capital.com.

⚠️ Avis important

Votre utilisation de l'API publique de Capital.com et de tout outil tiers que vous y connectez, y compris les outils basés sur l'IA ou les LLM, se fait à votre propre discrétion et à vos propres risques. Capital.com fonctionne sur une base d'exécution uniquement et ne contrôle, n'approuve ni n'accepte aucune responsabilité pour tout logiciel tiers, ses résultats ou toute conséquence qui en découle. Rien sur cette page ne constitue un conseil en investissement ou une recommandation de trading. Vous êtes seul responsable de toutes les décisions de trading, configurations et activités automatisées sur votre compte, et devez vous assurer que votre utilisation est conforme aux Conditions Générales de Capital.com, aux Conditions de Trading Électronique et à toutes les lois applicables dans votre juridiction.

Les Crypto Dérivés ne sont pas disponibles pour les clients de détail enregistrés auprès de Capital Com (UK) Ltd.

• Commencez toujours par un compte Démo avant d'envisager le trading réel
• Le trading est désactivé par défaut et nécessite une configuration explicite
• Toutes les opérations de trading nécessitent une exécution en deux phases (aperçu → confirmer → exécuter)
• Contrôles de risque intégrés : listes d'autorisation, limites de taille, plafonds d'ordres quotidiens
• Utilisation à vos propres risques - les auteurs n'assument aucune responsabilité pour les pertes de trading

Pour toute question ou clarification, veuillez consulter la FAQ : https://help.capitalccuk.com/hc/en-us/articles/34503231743506-How-to-set-up-the-Capital-com-MCP-Server

Guide de démarrage rapide

Étape 1 : Obtenir les identifiants API Capital.com

1. Créer un compte : Allez sur capital.com/trading/signup

   • Choisissez un compte Démo pour tester (recommandé)
   • Vérifiez votre email

2. Activer 2FA : Paramètres > Sécurité > Authentification à deux facteurs

   • Requis avant de générer des clés API

3. Générer une clé API : Paramètres > Intégrations API > Générer une nouvelle clé

   • Définissez un libellé (ex. "MCP Server")
   • Définissez un mot de passe personnalisé (ce n'est PAS votre mot de passe de plateforme)
   • Sauvegardez la clé API affichée (affichée une seule fois !)
   • Note : Les clés API sont capables de trading ; Capital.com ne propose pas de clés en lecture seule

Étape 2 : Installer et configurer

Vous avez deux options d'installation :

Option A : Installation en un clic via le bundle MCPB (Recommandée)

Le dépôt fournit un manifest.json conforme à la spécification MCPB (MCP Bundle) — le standard ouvert d'Anthropic pour empaqueter les serveurs MCP locaux. Cela vous permet d'installer le serveur dans Claude Desktop (et d'autres clients compatibles MCPB) sans éditer manuellement les fichiers de configuration.

Prérequis : uv (le serveur utilise uv comme environnement d'exécution — installez avec brew install uv ou consultez la documentation uv).

Étapes :

1. Clonez le dépôt et construisez le bundle .mcpb (nécessite Node.js pour npx) :

   git clone https://github.com/capital-com-sv/capital-mcp.git
   cd capital-mcp
   npx @anthropic-ai/mcpb pack . capital-mcp.mcpb
   

2. Ouvrez capital-mcp.mcpb dans Claude Desktop (double-cliquez, ou faites-le glisser dans l'application).
3. Claude Desktop vous demandera les valeurs de configuration utilisateur (clé API, identifiant, mot de passe, contrôles de trading). Remplissez-les et cliquez sur Installer.
4. Redémarrez Claude Desktop et vérifiez en demandant : "Quels outils Capital.com sont disponibles ?"

Consultez la référence CLI MCPB pour des commandes supplémentaires (validate, info, unpack, sign).

Option B : Installation manuelle via script

Prérequis : Python 3.10+ et Git doivent être installés.

• macOS : brew install python3 git
• Ubuntu/Debian : sudo apt install python3 python3-venv git
• Windows : python.org (cochez "Ajouter au PATH" lors de l'installation) + git-scm.com

Mac/Linux :

cd /path/to/capital-mcp
./install.sh

Windows (PowerShell) :

cd C:\path\to\capital-mcp
pwsh install.ps1

Le script d'installation créera un environnement virtuel, installera les dépendances et affichera la configuration du client MCP pour vous.

Modifiez .env avec vos identifiants :

# Required
CAP_ENV=demo
CAP_API_KEY=your_generated_api_key_here
CAP_IDENTIFIER=your_email@example.com
CAP_API_PASSWORD=your_custom_api_password

# Trading controls (keep trading disabled until ready)
CAP_ALLOW_TRADING=false
CAP_ALLOWED_EPICS=

# Optional: enable later for real trading
# CAP_ALLOW_TRADING=true
# CAP_ALLOWED_EPICS=SILVER,GOLD,BTCUSD

Étape 3 : Tester le serveur localement

Mac/Linux :

source venv/bin/activate
python -m capital_mcp.server

Windows (PowerShell) :

.\venv\Scripts\Activate.ps1
python -m capital_mcp.server

Vous devriez voir :

INFO - Starting Capital.com MCP Server (env: demo)
INFO - Trading enabled: False

Appuyez sur Ctrl+C pour arrêter.

Dépannage : Vérifier les journaux

Si vous rencontrez des problèmes lors de l'utilisation du serveur MCP avec Claude Desktop ou d'autres clients, vérifiez les fichiers journaux :

macOS :

# View MCP server logs
tail -f ~/Library/Logs/Claude/mcp-server-capital-com.log

# Search for errors
grep -i error ~/Library/Logs/Claude/mcp-server-capital-com.log

Linux :

tail -f ~/.config/Claude/logs/mcp-server-capital-com.log

Windows :

Get-Content $env:APPDATA\Claude\logs\mcp-server-capital-com.log -Wait

---

Intégration

Remarque : Remplacez /path/to/capital-mcp/venv/bin/python par le chemin Python réel de votre venv. Le script d'installation l'affiche pour vous. Sur Windows, utilisez C:\path\to\capital-mcp\venv\Scripts\python.exe.

Claude Desktop

💡 Astuce : Si vous avez installé via le bundle MCPB (Option A ci-dessus), ignorez cette section — Claude Desktop écrit la configuration pour vous en fonction de manifest.json. Utilisez cette section uniquement pour les installations manuelles par script.

macOS/Linux

Emplacement de la configuration : ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou ~/.config/Claude/claude_desktop_config.json (Linux)

{
  "mcpServers": {
    "capital-com": {
      "command": "/path/to/capital-mcp/venv/bin/python",
      "args": ["-m", "capital_mcp.server"],
      "env": {
        "CAP_ENV": "demo",
        "CAP_API_KEY": "your_api_key_here",
        "CAP_IDENTIFIER": "your_email@example.com",
        "CAP_API_PASSWORD": "your_custom_password",
        "CAP_ALLOW_TRADING": "false",
        "CAP_ALLOWED_EPICS": ""
      }
    }
  }
}

Redémarrez Claude Desktop. Vérifiez en tapant : "Quels outils Capital.com sont disponibles ?"

Windows

Emplacement de la configuration : %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "capital-com": {
      "command": "C:\\path\\to\\capital-mcp\\venv\\Scripts\\python.exe",
      "args": ["-m", "capital_mcp.server"],
      "env": {
        "CAP_ENV": "demo",
        "CAP_API_KEY": "your_api_key_here",
        "CAP_IDENTIFIER": "your_email@example.com",
        "CAP_API_PASSWORD": "your_custom_password",
        "CAP_ALLOW_TRADING": "false",
        "CAP_ALLOWED_EPICS": ""
      }
    }
  }
}

Redémarrez Claude Desktop.

Claude Code

claude mcp add capital-com -- /path/to/capital-mcp/venv/bin/python -m capital_mcp.server

Cursor IDE

Ouvrez Paramètres (Cmd+, / Ctrl+,) > Extensions > MCP > Configurer. Ajoutez :

{
  "capital-com": {
    "command": "/path/to/capital-mcp/venv/bin/python",
    "args": ["-m", "capital_mcp.server"],
    "env": {
      "CAP_ENV": "demo",
      "CAP_API_KEY": "your_api_key_here",
      "CAP_IDENTIFIER": "your_email@example.com",
      "CAP_API_PASSWORD": "your_custom_password",
      "CAP_ALLOW_TRADING": "false"
    }
  }
}

Redémarrez Cursor.

Codex

Paramètres > Serveurs MCP > Ajouter un serveur. Utilisez la même commande, les mêmes arguments et les mêmes variables d'environnement que ci-dessus.

Windsurf

Créez/modifiez ~/.windsurf/mcp/servers.json :

{
  "mcpServers": {
    "capital-com": {
      "command": "/path/to/capital-mcp/venv/bin/python",
      "args": ["-m", "capital_mcp.server"],
      "env": {
        "CAP_ENV": "demo",
        "CAP_API_KEY": "your_api_key_here",
        "CAP_IDENTIFIER": "your_email@example.com",
        "CAP_API_PASSWORD": "your_custom_password"
      }
    }
  }
}

Redémarrez Windsurf.

Clients MCP personnalisés

Tout client MCP compatible STDIO fonctionne. Exemple avec Node.js :

import { spawn } from 'child_process';

const server = spawn('/path/to/venv/bin/python', ['-m', 'capital_mcp.server'], {
  env: {
    ...process.env,
    CAP_ENV: 'demo',
    CAP_API_KEY: 'your_key',
    CAP_IDENTIFIER: 'your_email',
    CAP_API_PASSWORD: 'your_password',
    CAP_ALLOW_TRADING: 'false'
  }
});

// Communicate via STDIO (JSON-RPC)
// Read from server.stdout, write to server.stdin

Exemples d'utilisation

Exemple de conversation avec Claude Desktop

You: "Check my Capital.com session status"

Claude: I'll check your session status.
[Calls cap_session_status]
Response: {"ok": true, "data": {"env": "demo", "logged_in": false, ...}}

You're not currently logged in to the demo environment.

---

You: "Login to my Capital.com account"

Claude: I'll log you in.
[Calls cap_session_login]
Success! Logged in to account ID: ABC123

---

You: "Search for Bitcoin markets"

Claude: Searching for Bitcoin...
[Calls cap_market_search with search_term="Bitcoin"]
Found 5 markets:
- BTCUSD: Bitcoin vs US Dollar
- BTCEUR: Bitcoin vs Euro
- BTCGBP: Bitcoin vs British Pound
...

---

You: "Show me current positions"

Claude: Let me check your positions.
[Calls cap_trade_positions_list]
You have no open positions.

---

You: "Preview buying 1.0 SILVER"

Claude: I'll preview this trade. Note: Trading is currently DISABLED.
[Calls cap_trade_preview_position]
Preview failed: Trading is disabled (CAP_ALLOW_TRADING=false)

To enable trading, update your .env file:
CAP_ALLOW_TRADING=true
CAP_ALLOWED_EPICS=SILVER

Flux de travail d'exécution de trade (lorsque le trading est activé)

1. Preview the trade (validates everything, no side effects):
   "Preview buying 2.0 SILVER with stop at 24.50"
   → Returns preview_id

2. Review the preview results:
   - Normalized size (rounded to broker increments)
   - Risk checks (allowlist, size limits, daily limits)
   - Estimated entry price

3. Execute ONLY if all checks pass:
   "Execute position with preview_id [id], confirm=true"
   → Creates real position
   → Returns deal_reference
   → Polls for broker confirmation

4. Monitor:
   "Show my positions"
   "Close position [deal_id] with confirm=true"

Référence des variables d'environnement

Requises

• CAP_ENV - Environnement : demo ou live (par défaut : demo)
• CAP_API_KEY - Clé API de Capital.com
• CAP_IDENTIFIER - Email de connexion
• CAP_API_PASSWORD - Mot de passe personnalisé de la clé API

Contrôles de risque (Recommandés)

• CAP_ALLOW_TRADING - Activer le trading (par défaut : false)
• CAP_ALLOWED_EPICS - Liste d'autorisation séparée par des virgules (ex. "SILVER,GOLD,BTCUSD") ou "ALL" pour sans restriction
• CAP_MAX_POSITION_SIZE - Taille de position maximale (par défaut : 1.0)
• CAP_MAX_WORKING_ORDER_SIZE - Taille d'ordre maximale (par défaut : 1.0)
• CAP_MAX_OPEN_POSITIONS - Positions simultanées maximales (par défaut : 3)
• CAP_MAX_ORDERS_PER_DAY - Limite d'ordres quotidiens (par défaut : 20)
• CAP_REQUIRE_EXPLICIT_CONFIRM - Exiger confirm=true (par défaut : true)
• CAP_DRY_RUN - Bloquer toutes les exécutions de trades (par défaut : false)

Optionnelles

• CAP_DEFAULT_ACCOUNT_ID - Compte par défaut après connexion
• CAP_HTTP_TIMEOUT_S - Délai d'attente HTTP (par défaut : 15)
• CAP_LOG_LEVEL - Niveau de journalisation : DEBUG, INFO, WARNING, ERROR (par défaut : INFO)

Outils MCP (36 implémentés)

Session (4)

• cap_session_status - Obtenir les informations de session
• cap_session_login - Créer une session
• cap_session_ping - Maintenir en vie
• cap_session_logout - Terminer la session

Données de marché (6)

• cap_market_search - Rechercher des marchés
• cap_market_get - Obtenir les détails du marché
• cap_market_prices - Prix historiques
• cap_market_sentiment - Sentiment client
• cap_market_navigation_root - Racine des catégories de marché
• cap_market_navigation_node - Nœud des catégories de marché

Compte (6)

• cap_account_list - Lister les comptes
• cap_account_preferences_get - Obtenir les préférences
• cap_account_preferences_set - Définir les préférences
• cap_account_history_activity - Historique d'activité
• cap_account_history_transactions - Historique des transactions
• cap_account_demo_topup - Recharger le compte démo

Trading (11)

• Lecture seule :

  • cap_trade_positions_list - Lister les positions
  • cap_trade_positions_get - Obtenir les détails de la position
  • cap_trade_orders_list - Lister les ordres en cours
  • cap_trade_confirm_get - Obtenir le statut de confirmation
  • cap_trade_confirm_wait - Attendre la confirmation

• Aperçu :

  • cap_trade_preview_position - Aperçu de la position
  • cap_trade_preview_working_order - Aperçu de l'ordre

• Exécuter :

  • cap_trade_execute_position - Exécuter la position
  • cap_trade_execute_working_order - Exécuter l'ordre
  • cap_trade_positions_close - Clôturer la position
  • cap_trade_orders_cancel - Annuler l'ordre

Listes de surveillance (6)

• cap_watchlists_list - Lister les listes de surveillance
• cap_watchlists_create - Créer une liste de surveillance
• cap_watchlists_get - Obtenir une liste de surveillance
• cap_watchlists_add_market - Ajouter un marché
• cap_watchlists_delete - Supprimer une liste de surveillance
• cap_watchlists_remove_market - Retirer un marché

Streaming (3)

• cap_stream_prices - Diffuser les prix en temps réel (WebSocket)
• cap_stream_alerts - Diffuser les alertes de niveau de prix (WebSocket)
• cap_stream_portfolio - Diffuser le P&L du portefeuille en direct (WebSocket)

Invites MCP (Modèles de flux de travail)

Les invites MCP sont des flux de travail structurés qui guident Claude à travers des opérations de trading complexes en plusieurs étapes. Elles fournissent des instructions étape par étape et les meilleures pratiques pour les tâches courantes.

Invites disponibles (7)

1. market_scan - Flux de travail d'analyse de marché

Vous guide dans l'analyse d'une liste de surveillance pour détecter des conditions de trading.

Paramètres :

• watchlist_id - Liste de surveillance à analyser (laissez vide pour lister d'abord les listes de surveillance)
• timeframe - Résolution des prix : MINUTE, MINUTE_5, HOUR, DAY (par défaut : HOUR)
• lookback_periods - Nombre de bougies à récupérer : 1-1000 (par défaut : 24)

Flux de travail :

1. Obtenir les marchés de la liste de surveillance
2. Récupérer les données de prix pour chaque marché
3. Analyse technique (tendances, support/résistance, motifs)
4. Vérification optionnelle du sentiment
5. Générer un résumé des opportunités

Exemple d'utilisation :

• "Utilisez l'invite market_scan pour analyser ma liste de surveillance"
• "Analysez mes marchés pour des configurations de trading"

Trading réel : Changez vos configurations pour : CAP_ENV: 'live', CAP_ALLOW_TRADING: 'true'

2. trade_proposal - Flux de travail de planification de trade

Vous guide dans la création d'une proposition de trade avec des outils de gestion des risques.

Paramètres :

• epic - Marché à trader (requis, ex. SILVER, GOLD)
• direction - BUY ou SELL (par défaut : BUY)
• thesis - Votre raisonnement de trading (optionnel)
• risk_percent - Risque en % du solde (par défaut : 1.0%)

Flux de travail :

1. Récupérer les détails du marché et les règles de négociation
2. Calculer la taille de la position en fonction du % de risque
3. Définir les niveaux de stop loss et de take profit
4. Prévisualiser le trade (validation uniquement - pas d'exécution)
5. Retourner le preview_id pour une exécution potentielle

Exemple d'utilisation :

• "Créer une proposition de trade pour SILVER"
• "Proposer un trade long sur GOLD avec 2% de risque"

Remarque : Cette invite n'exécute PAS de trades - elle crée uniquement des aperçus.

3. execute_trade - Flux de travail d'exécution de trade

Vous guide dans l'exécution d'un trade prévisualisé.

Paramètres :

• preview_id - ID d'aperçu de trade_proposal (requis)

Flux de travail :

1. Vérifier que le preview_id est fourni et valide
2. Re-vérifier tous les contrôles de risque
3. Exécuter la position auprès du courtier
4. Interroger pour confirmation (ACCEPTED/REJECTED)
5. Rapporter le statut final

Exemple d'utilisation :

• "Exécutez le trade que je viens de prévisualiser"
• "Placez le trade avec l'ID d'aperçu abc-123"

Remarque :

• Nécessite CAP_ALLOW_TRADING=true
• Nécessite que l'epic soit dans la liste d'autorisation
• L'aperçu ne doit pas être expiré (TTL de 2 minutes)
• ⚠️ Cela PLACERA un trade réel

4. position_review - Flux de travail d'analyse de portefeuille

Vous guide dans l'analyse de vos positions et ordres ouverts.

Paramètres : Aucun (analyse toutes les positions actuelles)

Flux de travail :

1. Récupérer toutes les positions ouvertes
2. Récupérer tous les ordres en cours
3. Calculer les métriques de P&L, de risque et d'exposition
4. Identifier les risques de concentration et de corrélation
5. Suggérer des ajustements potentiels (sans exécuter)

Exemple d'utilisation :

• "Examinez mes positions actuelles"
• "Analysez l'exposition de mon portefeuille"

Remarque : Il s'agit d'un flux de travail en lecture seule - aucun trade n'est exécuté.

5. live_price_monitor - Suivi des prix en temps réel (WebSocket)

Surveillez les prix du marché en direct avec des alertes instantanées lorsque les prix évoluent au-delà d'un seuil.

Paramètres :

• epics - Liste des EPIC de marché à surveiller (laissez vide pour rechercher/sélectionner, max 40)
• duration_minutes - Durée de surveillance (par défaut : 5 minutes, max : 10 minutes)
• threshold_percent - Alerter lorsque le prix évolue de > ce % (par défaut : 1.0%)

Flux de travail :

1. Sélectionner les marchés à surveiller (ou fournir les EPIC directement)
2. Récupérer les prix initiaux pour établir une référence
3. S'abonner aux mises à jour de prix WebSocket en temps réel
4. Afficher le tableau des prix en direct avec des mises à jour continues
5. Alerter lorsque tout marché évolue de > threshold_percent
6. Arrêt automatique après duration_minutes

Exemple d'utilisation :

• "Surveillez les prix GOLD et SILVER pendant 2 minutes"
• "Surveillez BTC pendant les 5 prochaines minutes, alertez sur des mouvements de 2%" Remarque : Nécessite CAP_WS_ENABLED=true. Les sessions WebSocket Capital.com durent au maximum 10 minutes.

6. real_time_alerts - Alertes de prix conditionnelles (WebSocket)

Définissez des alertes de niveau de prix et recevez des notifications instantanées lorsque les marchés atteignent vos objectifs.

Paramètres :

• alert_config - Niveaux d'alerte par EPIC (ex. : {"GOLD": 2050.0, "SILVER": 28.5})
• duration_minutes - Durée maximale de surveillance (par défaut : 5 minutes)
• auto_stop - Arrêter la surveillance après la première alerte ? (par défaut : true)

Flux de travail :

1. Configurer les conditions d'alerte (niveaux de prix pour chaque marché)
2. S'abonner aux mises à jour de prix WebSocket
3. Surveiller en continu les déclencheurs d'alerte
4. Émettre une alerte instantanée lorsque la condition est remplie
5. Optionnellement, continuer la surveillance ou s'arrêter après la première alerte

Exemples d'utilisation :

• « Alertez-moi lorsque l'OR atteint 2050 »
• « Notifiez-moi lorsque l'ARGENT passe sous 28 »

Remarque : Nécessite CAP_WS_ENABLED=true.

7. live_portfolio_monitor - Suivi des P&L en temps réel (WebSocket)

Observez les P&L de votre portefeuille se mettre à jour en temps réel à mesure que les prix du marché évoluent.

Paramètres :

• duration_minutes - Durée de surveillance (par défaut : 5 minutes, max : 10 minutes)
• alert_pnl_threshold - Alerter lorsque le P&L total dépasse ce montant (par défaut : 100 $)

Flux de travail :

1. Récupérer les positions ouvertes actuelles
2. S'abonner aux mises à jour de prix pour les marchés des positions
3. Calculer les P&L en direct à mesure que les prix changent
4. Afficher le tableau de bord du portefeuille en temps réel
5. Alerter lorsque les P&L franchissent le seuil

Exemples d'utilisation :

• « Surveillez les P&L de mon portefeuille pendant 5 minutes »
• « Surveillez les positions en temps réel, alertez à 500 $ de P&L »

Remarque : Nécessite CAP_WS_ENABLED=true et des positions actives.

Comment utiliser les invites

Dans Claude Desktop ou d'autres clients MCP, les invites apparaissent comme des modèles d'interaction disponibles. Vous pouvez les invoquer naturellement dans la conversation :

User: "I want to scan my watchlist for opportunities"
Claude: [Invokes market_scan prompt, guides through the workflow]

User: "Create a trade plan for SILVER"
Claude: [Invokes trade_proposal prompt, designs trade with risk management]

User: "Execute that trade"
Claude: [Invokes execute_trade prompt, submits to broker]

User: "Show me my open positions"
Claude: [Invokes position_review prompt, analyzes portfolio]

Les invites fournissent des conseils structurés tout en maintenant les contrôles de trading tout au long du flux de travail.

Ressources MCP (Données en lecture seule)

Les ressources MCP fournissent un accès en lecture seule à l'état et à la configuration du serveur via des ressources basées sur des URI. Contrairement aux outils (qui effectuent des actions), les ressources exposent des données que les clients peuvent lire et surveiller.

Ressources disponibles

1. cap://status - Statut du serveur

Informations sur le serveur et la session en temps réel.

Renvoie : JSON avec l'état du serveur, l'état de la session, le statut d'authentification, les limites de débit

Exemple :

{
  "server": {
    "name": "Capital.com MCP Server",
    "version": "0.1.0",
    "trading_enabled": true
  },
  "session": {
    "logged_in": true,
    "account_id": "ABC123",
    "last_used_at": "2026-01-16T10:30:00Z",
    "expires_in_s_estimate": 522
  },
  "risk": {
    "trading_enabled": true,
    "allowed_epics": ["GOLD", "SILVER"],
    "allowlist_mode": "SPECIFIC"
  },
  "rate_limits": {
    "requests_per_second": "10",
    "note": "Capital.com enforces 10 req/s limit"
  }
}

Cas d'utilisation : Surveiller l'état du serveur, vérifier l'état de la session, déboguer les problèmes d'authentification

---

2. cap://risk-policy - Politique de risque

Configuration complète de la gestion des risques et contrôles de trading.

Renvoie : JSON avec toutes les couches de validation, les fonctionnalités de contrôle de trading et les restrictions de trading

Exemple :

{
  "trading_enabled": true,
  "two_phase_execution": true,
  "description": "All trades require preview → explicit execution",
  "allowlist": {
    "mode": "SPECIFIC",
    "epics": ["GOLD", "SILVER"],
    "note": "Only markets on this list can be traded (ALL = wildcard)"
  },
  "validation_layers": [
    "1. Trading enabled check (TRADING_ENABLED env var)",
    "2. Epic allowlist check (must be in ALLOWED_EPICS)",
    "... 10 total layers ..."
  ],
  "execution_controls": {
    "preview_required": true,
    "deal_reference_matching": true,
    "authentication_required": true,
    "rate_limiting": true,
    "input_validation": true
  }
}

Cas d'utilisation : Comprendre les contrôles de trading actifs, auditer la configuration des risques, documentation de conformité

---

3. cap://allowed-epics - Liste autorisée de trading

Configuration actuelle de la liste autorisée de trading indiquant les marchés autorisés.

Renvoie : JSON avec le mode de la liste autorisée, les EPIC autorisés et les instructions de configuration

Exemple :

{
  "mode": "SPECIFIC",
  "allowed_epics": ["GOLD", "SILVER", "BTCUSD"],
  "count": 3,
  "trading_enabled": true,
  "description": "Restricted mode: 3 specific markets allowed",
  "configuration": {
    "env_var": "ALLOWED_EPICS",
    "example": "ALLOWED_EPICS=GOLD,SILVER,BTCUSD",
    "wildcard": "ALLOWED_EPICS=ALL (allows all markets)"
  }
}

Cas d'utilisation : Vérifier quels marchés sont négociables, vérifier la configuration de la liste autorisée

---

4. cap://market-cache/{epic} - Détails du marché (Dynamique)

Détails du marché mis en cache pour un EPIC spécifique (récupération en direct depuis le courtier).

Paramètres :

• epic - Identifiant de marché (ex. : "GOLD", "SILVER", "CS.D.EURUSD.TODAY.IP")

Renvoie : JSON avec des informations complètes sur le marché

Authentification : Requise

Exemple : cap://market-cache/GOLD

{
  "epic": "GOLD",
  "instrument_name": "Spot Gold",
  "instrument_type": "COMMODITIES",
  "currency": "USD",
  "snapshot": {
    "market_status": "TRADEABLE",
    "bid": 2050.50,
    "offer": 2050.75,
    "update_time": "2026-01-16T10:30:00"
  },
  "dealing": {
    "min_size": 0.1,
    "max_size": 100.0,
    "min_step": 0.1,
    "min_stop_distance": 5.0
  },
  "margin": {
    "factor": 5.0,
    "unit": "PERCENTAGE"
  },
  "opening_hours": {...},
  "cached_at": "2026-01-16T10:30:00"
}

Cas d'utilisation : Obtenir les détails du marché, vérifier les règles de trading, analyser les exigences de marge

---

Comment utiliser les ressources

Dans Claude Desktop ou d'autres clients MCP, les ressources sont accessibles par URI :

User: "Show me the server status"
Claude: [Reads cap://status resource, displays server health]

User: "What's the risk policy?"
Claude: [Reads cap://risk-policy resource, explains trading controls]

User: "Which markets can I trade?"
Claude: [Reads cap://allowed-epics resource, lists permitted epics]

User: "Show all my watchlists"
Claude: [Calls cap_watchlists_list tool, displays watchlist data]

User: "Get details for GOLD market"
Claude: [Reads cap://market-cache/GOLD resource, shows market info]

Les ressources offrent un moyen pratique d'inspecter l'état et la configuration du serveur sans exécuter d'outils. Pour les données de liste de surveillance, utilisez les outils cap_watchlists_list et cap_watchlists_get.

Processus d'exécution des transactions

Exécution obligatoire en deux étapes

Toutes les opérations ayant des effets secondaires utilisent un flux strict aperçu → exécution :

1. Aperçu : Valider la transaction par rapport aux règles du courtier + politique de risque locale

   • Renvoie preview_id avec la demande normalisée + contrôles de risque
   • Aucun effet secondaire, validation en lecture seule

2. Exécuter : Soumettre la transaction en utilisant preview_id

   • Réexécute les contrôles critiques
   • Nécessite confirm=true si CAP_REQUIRE_EXPLICIT_CONFIRM=true
   • Interroge la confirmation du courtier
   • Incrémente le compteur de commandes quotidien

Contrôles de risque

• Liste autorisée : Seuls les EPIC dans CAP_ALLOWED_EPICS peuvent être négociés
• Limites de taille : Taille maximale de position/ordre appliquée
• Limites de position : Nombre maximal de positions ouvertes à tout moment
• Limites quotidiennes : Nombre maximal de commandes par jour
• Normalisation de la taille : Arrondit au min/max/incrément du courtier
• Mode Dry-Run : Bloque toutes les exécutions lorsqu'il est activé

Documentation

• Guide d'utilisation : USAGE.md - Guide d'utilisation complet avec exemples
• Référence de l'API Capital.com : https://open-api.capital.com/
• Collection Postman de l'API Capital.com : https://github.com/capital-com-sv/capital-api-postman

Licence

MIT

Avertissement – Utilisation de l'API publique Capital.com avec des outils tiers

Intégration tierce

Cette page décrit comment les clients peuvent connecter l'API publique Capital.com à des logiciels, outils ou intégrations tiers, y compris ceux alimentés par l'intelligence artificielle ou les grands modèles de langage (« LLM »). Tout logiciel, outil ou intégration tiers est indépendant de Capital.com et ne fait pas partie des services de Capital.com. Capital.com ne contrôle pas, ne développe pas, n'approuve pas et n'accepte aucune responsabilité pour tout logiciel tiers, sa fonctionnalité, ses résultats ou tout résultat découlant de son utilisation. Toute utilisation d'outils ou d'intégrations tiers en relation avec l'API publique Capital.com est entièrement à vos propres risques. Vous êtes responsable de l'examen des conditions, des politiques de confidentialité et des pratiques de traitement des données de tout outil tiers que vous choisissez d'utiliser.

Utilisation de l'API publique

Votre utilisation de l'API publique Capital.com est entièrement à votre discrétion et à vos risques. Capital.com met l'API publique à disposition à des fins d'information et de trading, mais ne recommande, n'approuve ni n'encourage aucune utilisation, intégration ou stratégie de trading particulière. Vous êtes seul responsable de la manière dont vous accédez à l'API et l'utilisez, y compris les paramètres de toute commande soumise, la configuration de tout outil ou système connecté et l'interprétation de toute donnée reçue. Capital.com décline toute responsabilité pour les pertes ou les résultats imprévus découlant de votre utilisation de l'API, que ce soit directement ou via des outils tiers. La disponibilité, la fonctionnalité et les spécifications de l'API peuvent être modifiées, limitées en débit, suspendues ou interrompues à tout moment sans préavis. Votre utilisation de l'API publique est soumise aux Conditions générales et aux Conditions de trading électronique de Capital.com, que vous devez lire attentivement avant d'utiliser l'API.

Service d'exécution uniquement et absence de conseil en investissement Capital.com fournit ses services sur une base d'exécution uniquement. Le trading d'instruments financiers implique un risque important de perte. Rien sur cette page, dans l'API publique ou dans tout logiciel ou intégration tiers ne constitue un conseil en investissement, une recommandation personnelle ou une sollicitation d'achat ou de vente d'un instrument financier. Cela inclut toute sortie, signal, suggestion ou analyse générée par l'IA, les outils basés sur LLM ou d'autres outils automatisés. Toutes les décisions de trading, y compris toute activité automatisée ou algorithmique, sont prises à vos propres risques et restent sous votre seule responsabilité. Risques du trading automatisé et algorithmique L'utilisation de l'API publique en relation avec des outils de trading automatisé ou algorithmique comporte des risques supplémentaires, y compris, mais sans s'y limiter : l'exécution rapide de commandes sans examen ou intervention humaine ; les erreurs système, les défaillances logicielles ou les problèmes de connectivité ; l'exécution à des prix sensiblement différents de ceux attendus ; et les commandes involontaires ou erronées résultant d'outils ou de paramètres mal configurés. Capital.com n'est pas responsable des pertes découlant de ces risques ou de l'interaction entre ses systèmes et tout outil tiers. Les performances passées et les résultats générés par des outils automatisés ne sont pas indicatifs des résultats futurs.

Utilisation interdite

L'utilisation de l'API publique et de tout outil connecté ne doit pas être utilisée pour manipuler la plateforme Capital.com, exploiter les prix ou la latence, se livrer à des abus de marché ou obtenir un avantage injuste. Capital.com se réserve le droit de restreindre, suspendre ou résilier l'accès à l'API et/ou à votre compte lorsqu'elle considère raisonnablement qu'une telle utilisation abusive s'est produite ou est susceptible de se produire. Les clients ne doivent permettre à aucun tiers d'exercer un contrôle discrétionnaire sur leur compte.

Vos responsabilités

Vous êtes responsable de vous assurer que votre utilisation de la plateforme Capital.com, de l'API publique et de tout outil ou intégration tiers est conforme aux Conditions générales de Capital.com, aux Conditions de trading électronique et à toutes les lois et réglementations applicables dans votre juridiction. Vous devez examiner attentivement si les outils de trading automatisé sont adaptés à votre situation, votre expérience et votre tolérance au risque avant de les utiliser. Capital.com vous recommande fortement de tester minutieusement tout outil ou intégration automatisé à l'aide d'un compte Démo avant de le connecter à un environnement de trading réel.