Blockscout

npx add-mcp 'https://mcp.blockscout.com/mcp'

Serveur MCP Blockscout

Le Model Context Protocol (MCP) est un protocole ouvert conçu pour permettre aux agents IA, aux IDE et aux outils d'automatisation de consommer, interroger et analyser des données structurées via des API contextuelles.

Ce serveur encapsule les API Blockscout et expose les données de la blockchain—soldes, jetons, NFT, métadonnées de contrats—via MCP afin que les agents IA et les outils (comme Claude, Cursor ou les IDE) puissent y accéder et les analyser de manière contextuelle.

Fonctionnalités clés :

• Accès contextuel aux données de la blockchain pour les outils IA
• Support multi-chaînes via la configuration de l'API PRO Blockscout avec enrichissement des métadonnées Chainscout
• API REST versionnée : Fournit une interface standard et conviviale pour le web à tous les outils MCP. Voir API.md pour la documentation complète.
• Instructions personnalisées pour l'hôte MCP afin d'utiliser le serveur
• Optimisation intelligente du contexte pour économiser les jetons LLM tout en préservant l'accessibilité des données
• Découpage intelligent des réponses avec des tailles de page configurables pour éviter le débordement du contexte
• Pagination par curseur opaque utilisant des chaînes encodées en Base64URL au lieu de paramètres complexes
• Troncature automatique des grands champs de données avec des indicateurs clairs et des conseils d'accès
• Modèle de réponse ToolResponse standardisé avec des réponses JSON structurées et des instructions de suivi
• Observabilité améliorée avec des notifications de progression MCP et des mises à jour périodiques pour les opérations de longue durée

Analyse améliorée avec les compétences d'agent

Pour une analyse de la blockchain plus puissante et plus efficace, installez la compétence Blockscout Analysis depuis le dépôt agent-skills. Cette compétence fournit aux agents IA des conseils structurés pour les stratégies d'exécution, la gestion des réponses, les bonnes pratiques de sécurité et l'orchestration des flux de travail.

En savoir plus : Consultez le README agent-skills pour connaître toutes les capacités et les instructions d'installation.

Configuration des clients MCP

Clé API PRO Blockscout

La configuration du serveur MCP Blockscout avec un agent IA nécessite une clé API PRO Blockscout. La plupart des outils de données acheminent leurs requêtes via la passerelle API PRO Blockscout authentifiée. Sans clé valide, ces outils échouent rapidement avant d'effectuer toute requête en amont.

Pour obtenir une clé, inscrivez-vous sur le Portail développeur Blockscout (le niveau gratuit ne nécessite pas de carte de crédit) et générez une clé API ; les clés sont préfixées par proapi_. Fournissez-la ensuite lors de la configuration de votre client, comme indiqué dans les sections ci-dessous.

Configuration Claude (Web, Desktop, Cowork) - Recommandé

Le moyen le plus simple d'utiliser le serveur MCP Blockscout avec Claude est le serveur hébergé officiel : une expérience d'installation native et gérée avec des mises à jour automatiques, sans rien à exécuter vous-même. Ajoutez-le comme connecteur personnalisé avec votre propre clé API PRO. Claude envoie la clé à chaque requête dans un en-tête x-api-key, que le serveur accepte comme alias de son en-tête Blockscout-MCP-Pro-Api-Key.

1. Ouvrez Claude et allez dans Personnaliser > Connecteurs. Sur les plans Team et Enterprise, un propriétaire d'organisation fait cela sous Paramètres de l'organisation > Connecteurs.
2. Cliquez sur Ajouter un connecteur personnalisé. Définissez le nom sur Blockscout et l'URL sur https://mcp.blockscout.com/mcp, puis continuez.
3. Laissez Authentification sur None (Claude le détecte). Un avertissement indiquant que le connecteur n'a pas d'identifiants est attendu : la clé est fournie à l'étape suivante.
4. Ouvrez En-têtes de requête, sélectionnez x-api-key dans la liste, et collez votre clé API PRO comme valeur. Choisissez exactement ce nom ; le serveur ne lit pas les autres noms similaires dans la liste.
5. Cliquez sur Ajouter.

Remarque : La section En-têtes de requête est en version bêta et n'est pas encore disponible pour toutes les organisations. Si votre boîte de dialogue ne l'affiche pas, utilisez le Répertoire des connecteurs ci-dessous.

Remarque : Sur les plans Team et Enterprise, la clé est saisie une fois par le propriétaire et partagée par toute l'organisation. Les paramètres d'authentification ne peuvent pas être modifiés après l'ajout d'un connecteur : pour changer la clé, supprimez le connecteur et ajoutez-le à nouveau.

Utilisation du répertoire des connecteurs Claude

Si la boîte de dialogue du connecteur personnalisé n'a pas de section En-têtes de requête, installez le connecteur Blockscout depuis le Répertoire officiel des connecteurs Anthropic. Il se connecte au même serveur hébergé mais utilise une clé d'accès partagée.

Installation

Option 1 : Lien direct

Visitez claude.com/connectors/blockscout et cliquez sur les liens dans la section « Utilisé dans » pour installer le connecteur Blockscout.

Option 2 : Via les paramètres

1. Ouvrez Claude (application Web ou Desktop)
2. Allez dans Paramètres > Connecteurs > Parcourir les connecteurs
3. Recherchez « Blockscout »
4. Cliquez sur « Connecter » pour installer

Limitations : En raison de l'utilisation d'une clé d'accès partagée, il peut y avoir des restrictions sur l'accès et les capacités du connecteur.

Configuration Claude Code

Transmettez votre clé API PRO via l'en-tête Blockscout-MCP-Pro-Api-Key lors de l'ajout du serveur :

claude mcp add --transport http blockscout https://mcp.blockscout.com/mcp \
  --header "Blockscout-MCP-Pro-Api-Key: proapi_your_key_here"

Après avoir exécuté cette commande, Blockscout sera disponible comme serveur MCP dans Claude Code, vous permettant d'accéder et d'analyser les données de la blockchain directement depuis votre environnement de codage.

Configuration des applications ChatGPT

Installez l'application Blockscout depuis la place de marché des applications ChatGPT :

1. Ouvrez la page de l'application Blockscout (ou recherchez « Blockscout » dans le répertoire des applications ChatGPT).
2. Cliquez sur « Connecter » pour activer l'application pour votre compte ChatGPT.

Configuration de l'application Codex

1. Ouvrez Codex et allez dans Paramètres > Serveurs MCP > Ajouter un serveur.
2. Définissez Nom sur Blockscout, sélectionnez l'onglet HTTP Streamable, et définissez URL sur https://mcp.blockscout.com/mcp.
3. Sous En-têtes, ajoutez un en-tête avec la clé Blockscout-MCP-Pro-Api-Key et la valeur proapi_your_key_here.
4. Enregistrez et redémarrez l'application Codex.

Configuration Codex CLI

Codex CLI ne peut pas attacher un en-tête personnalisé depuis la ligne de commande, configurez-le donc en deux étapes :

1. Générez l'entrée du serveur :

   codex mcp add Blockscout --url https://mcp.blockscout.com/mcp
   

2. Modifiez ~/.codex/config.toml pour ajouter l'en-tête de clé API PRO et activer le client MCP streamable-HTTP (requis pour que les serveurs MCP distants se connectent). La configuration résultante devrait ressembler à ceci :

   [features]
   experimental_use_rmcp_client = true
   
   [mcp_servers.Blockscout]
   url = "https://mcp.blockscout.com/mcp"
   http_headers = { "Blockscout-MCP-Pro-Api-Key" = "proapi_your_key_here" }
   

Configuration Cursor

Ajoutez le serveur à votre configuration MCP Cursor — soit le .cursor/mcp.json au niveau du projet, soit le ~/.cursor/mcp.json global — en fournissant votre clé API PRO via l'en-tête Blockscout-MCP-Pro-Api-Key :

{
  "mcpServers": {
    "blockscout": {
      "url": "https://mcp.blockscout.com/mcp",
      "timeout": 180000,
      "headers": {
        "Blockscout-MCP-Pro-Api-Key": "proapi_your_key_here"
      }
    }
  }
}

Configuration de développement local (pour les développeurs)

Si vous souhaitez exécuter le serveur localement à des fins de développement :

{
  "mcpServers": {
    "blockscout": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "ghcr.io/blockscout/mcp-server:latest"
      ]
    }
  }
}

Détails techniques

Référez-vous à SPEC.md pour les détails techniques.

Structure du dépôt

Référez-vous à AGENTS.md pour la structure du dépôt.

Tests

Référez-vous à TESTING.md pour des instructions complètes sur l'exécution des tests unitaires et d'intégration.

Descriptions des outils

1. __unlock_blockchain_analysis__() - Initialise une session MCP Blockscout : renvoie les données de référence du serveur, le pointeur de compétence blockscout-analysis et la règle de résolution des URI. Appelez-le une fois par session, avant tout autre outil.
2. get_chains_list(query=None) - Renvoie une liste des chaînes prises en charge, avec filtrage optionnel par nom, identifiant de chaîne, devise native ou écosystème.
3. get_address_by_ens_name(name) - Convertit un nom de domaine ENS en son adresse Ethereum correspondante.
4. lookup_token_by_symbol(chain_id, symbol) - Recherche des adresses de jetons par symbole ou nom, renvoyant plusieurs correspondances potentielles.
5. get_contract_abi(chain_id, address) - Récupère l'ABI (interface binaire d'application) d'un contrat intelligent.
6. inspect_contract_code(chain_id, address, file_name=None) - Permet d'obtenir les fichiers source des contrats vérifiés.
7. get_address_info(chain_id, address) - Obtient des informations complètes sur une adresse, y compris le solde, l'association ENS, le statut du contrat, les détails des jetons et les étiquettes publiques.
8. get_tokens_by_address(chain_id, address, cursor=None) - Renvoie les avoirs détaillés en jetons ERC20 pour une adresse avec des métadonnées enrichies et des données de marché.
9. get_block_number(chain_id, [datetime]) - Récupère le numéro de bloc et l'horodatage pour une date/heure spécifique ou le dernier bloc.
10. get_transactions_by_address(chain_id, address, age_from, age_to, methods, cursor=None) - Obtient les transactions d'une adresse dans une plage de temps spécifique avec filtrage optionnel par méthode.
11. get_token_transfers_by_address(chain_id, address, age_from, age_to, token, cursor=None) - Renvoie les transferts de jetons ERC-20 pour une adresse dans une plage de temps spécifique.
12. nft_tokens_by_address(chain_id, address, cursor=None) - Récupère les jetons NFT possédés par une adresse, groupés par collection.
13. get_block_info(chain_id, number_or_hash, include_transactions=False) - Renvoie les informations du bloc, y compris l'horodatage, le gaz utilisé, les frais brûlés et le nombre de transactions. Peut éventuellement inclure une liste de hachages de transactions.
14. get_transaction_info(chain_id, hash, include_raw_input=False) - Obtient des informations complètes sur une transaction avec des paramètres d'entrée décodés et des transferts de jetons détaillés.
15. read_contract(chain_id, address, abi, function_name, args='[]', block='latest') - Exécute une fonction de contrat intelligent en lecture seule et renvoie son résultat. L'argument abi est un objet JSON décrivant la signature de la fonction spécifique.
16. direct_api_call(chain_id, endpoint_path, query_params=None, cursor=None, method='GET', json_body=None) - Appelle un point de terminaison API Blockscout brut pour des données avancées ou spécifiques à une chaîne. Prend en charge les requêtes GET (par défaut) et POST avec corps JSON.

Exemples de prompts pour les agents IA

Is any approval set for OP token on Optimism chain by `zeaver.eth`?

Calculate the total gas fees paid on Ethereum by address `0xcafe...cafe` in May 2025.

Which 10 most recent logs were emitted by `0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7`
before `Nov 08 2024 04:21:35 AM (-06:00 UTC)`?

Tell me more about the transaction `0xf8a55721f7e2dcf85690aaf81519f7bc820bc58a878fa5f81b12aef5ccda0efb`
on Redstone rollup.

Is there any blacklisting functionality of USDT token on Arbitrum One?

What is the latest block on Gnosis Chain and who is the block minter?
Were any funds moved from this minter recently?

When the most recent reward distribution of Kinto token was made to the wallet
`0x7D467D99028199D99B1c91850C4dea0c82aDDF52` in Kinto chain?

Which methods of `0x1c479675ad559DC151F6Ec7ed3FbF8ceE79582B6` on the Ethereum 
mainnet could emit `SequencerBatchDelivered`?

What is the most recent executed cross-chain message sent from the Arbitrum Sepolia
rollup to the base layer?

Développement et déploiement

Installation locale

Clonez le dépôt et installez les dépendances :

git clone https://github.com/blockscout/mcp-server.git
cd mcp-server
uv pip install -e . # or `pip install -e .`

Pour personnaliser la partie initiale de l'en-tête User-Agent utilisé pour les requêtes RPC, définissez la variable d'environnement BLOCKSCOUT_MCP_USER_AGENT (par défaut « Blockscout MCP »). La version du serveur est ajoutée automatiquement.

Fourniture de la clé API PRO au serveur

Lorsque vous exécutez le serveur vous-même, fournissez la clé API PRO Blockscout via la variable d'environnement BLOCKSCOUT_PRO_API_KEY — exportée dans votre shell ou placée dans un fichier .env ignoré par git à la racine du projet. Cela active tout l'accès aux données, l'enrichissement des étiquettes publiques et les lectures de contrats. Ne commettez jamais la clé et ne l'intégrez pas dans un binaire distribué au client ; lors de l'exécution via Docker, transmettez-la au moment de l'exécution (par exemple -e BLOCKSCOUT_PRO_API_KEY=...) plutôt que de l'intégrer dans l'image.

export BLOCKSCOUT_PRO_API_KEY=proapi_your_key_here

Clés fournies par le client (transports HTTP). Lorsque le serveur fonctionne en mode HTTP, un client peut fournir sa propre clé API PRO dans un en-tête de requête — par défaut Blockscout-MCP-Pro-Api-Key, configurable via BLOCKSCOUT_PRO_API_KEY_HEADER (définissez-le sur une chaîne vide pour désactiver complètement les clés fournies par le client). Le serveur lit également la clé depuis un en-tête x-api-key, pour les clients dont les noms d'en-têtes sont restreints à une liste fixe (par exemple les connecteurs personnalisés Claude). L'en-tête configuré prévaut lorsque les deux sont présents ; x-api-key n'est consulté que lorsque l'en-tête configuré est manquant ou vide, et la désactivation des clés fournies par le client le désactive également. Cela fonctionne de la même manière pour les deux transports HTTP — les appels d'outils MCP-over-HTTP et l'API REST. Une clé fournie par le client a priorité sur BLOCKSCOUT_PRO_API_KEY pour cette requête ; si le client n'envoie pas de clé, le serveur revient à sa propre clé configurée ; si aucune n'est présente, la requête échoue avec l'erreur de non-configuration. Une clé client présente mais malformée fait échouer toute requête nécessitant l'API PRO sans repli (le serveur n'utilise jamais silencieusement sa propre clé à la place d'une mauvaise clé client) ; les outils qui n'utilisent pas l'API PRO ne sont pas affectés. Cela permet d'exécuter un serveur HTTP partagé où chaque client s'authentifie avec sa propre clé.

Avertissement de crédit faible. L'accès à l'API PRO est mesuré en crédits. Lorsque le solde restant rapporté par l'API tombe sous un seuil configurable, chaque outil de données ajoute une note d'avertissement à sa réponse, invitant les opérateurs à recharger pour que l'accès à l'API PRO reste prêt pour une utilisation continue à volume élevé. Le seuil est défini via BLOCKSCOUT_PRO_API_LOW_CREDITS_THRESHOLD (par défaut 5000 crédits ; définissez sur 0 pour désactiver la note). La note se déclenche pour tout solde inférieur au seuil, y compris les soldes nuls et négatifs. Avis d’exigence de clé PRO API. BLOCKSCOUT_PRO_API_KEY_REQUIRED_NOTICE contient un avis configuré par l’opérateur que le serveur ajoute comme dernière entrée du champ notes des réponses d’outils dont les requêtes ne portaient pas la propre clé PRO API (bien formée) du client. Il existe pour annoncer la migration du serveur public officiel vers des clés obligatoires fournies par le client, donc seul le déploiement officiel est censé le définir. Lorsque la variable n’est pas définie ou est vide (par défaut), la fonctionnalité est complètement désactivée. Les opérateurs communautaires et auto-hébergés doivent la laisser vide — en particulier en mode stdio, où vous configurez BLOCKSCOUT_PRO_API_KEY vous-même et où aucun en-tête de requête ne peut porter une clé client, l’avis ne ferait que répéter un message de migration qui ne s’applique pas à votre déploiement.

Exécution du serveur

Le serveur s’exécute en mode stdio par défaut :

python -m blockscout_mcp_server

Mode HTTP (MCP uniquement) :

Pour exécuter le serveur en mode HTTP Streamable (sans état, réponses SSE par défaut) :

python -m blockscout_mcp_server --http

Vous pouvez également spécifier l’hôte et le port du serveur HTTP :

python -m blockscout_mcp_server --http --http-host 0.0.0.0 --http-port 8080

Mode développement (réponses JSON simples) :

Pour le développement et les tests avec des clients HTTP simples (curl, Insomnia), vous pouvez activer des réponses JSON simples au lieu des flux SSE :

export BLOCKSCOUT_DEV_JSON_RESPONSE=true
python -m blockscout_mcp_server --http

Remarque : Cela désactive les événements envoyés par le serveur (SSE) et les notifications de progression. À utiliser uniquement pour les tests locaux et le débogage.

Tunneling avec Ngrok (mode développement) :

Le SDK Python MCP applique une protection contre la reliaison DNS, qui bloque par défaut les requêtes provenant des tunnels ngrok. Pour activer le tunneling pour le développement et les tests :

1. Démarrez un tunnel ngrok vers votre serveur local :

   ngrok http 8000
   

2. Configurez l’hôte et l’origine autorisés à l’aide de votre URL ngrok :

   export BLOCKSCOUT_MCP_ALLOWED_HOSTS="your-tunnel-id.ngrok-free.app"
   export BLOCKSCOUT_MCP_ALLOWED_ORIGINS="https://your-tunnel-id.ngrok-free.app"
   python -m blockscout_mcp_server --http
   

Remarque : Ces paramètres sont principalement destinés au développement. Lorsque ces variables ne sont pas définies, la protection contre la reliaison DNS est automatiquement déterminée par l’hôte de liaison du serveur : activée pour localhost, désactivée pour les hôtes non locaux (par exemple, 0.0.0.0). Si votre en-tête Host inclut un port non standard, utilisez le suffixe générique :* (par exemple, "example.com:*") ou spécifiez la valeur exacte hôte:port.

Pour plus de détails sur le tunneling ngrok avec les serveurs MCP, consultez la https://github.com/openai/openai-apps-sdk-examples/blob/main/README.md#testing-in-chatgpt.

Mode HTTP avec API REST :

Pour activer l’API REST versionnée en plus du point de terminaison MCP, utilisez le drapeau --rest (qui nécessite --http).

python -m blockscout_mcp_server --http --rest

Avec un hôte et un port personnalisés :

python -m blockscout_mcp_server --http --rest --http-host 0.0.0.0 --http-port 8080

Options CLI :

• --http : Active le mode HTTP Streamable.
• --http-host TEXT : Hôte auquel lier le serveur HTTP (par défaut : 127.0.0.1).
• --http-port INTEGER : Port du serveur HTTP (par défaut : 8000).
• --rest : Active l’API REST (nécessite --http).

Construction de l’image Docker localement

Initialisez le sous-module de compétences inclus, intégrez ses métadonnées de commit dans le contexte de construction Docker, puis construisez l’image :

git submodule update --init --recursive agent-skills
python scripts/bake_skill_metadata.py
docker build -t ghcr.io/blockscout/mcp-server:latest .

Extraction depuis le registre de conteneurs GitHub

Extrayez l’image pré-construite :

docker pull ghcr.io/blockscout/mcp-server:latest

Exécution avec Docker

Mode HTTP (MCP uniquement) :

Pour exécuter le conteneur Docker en mode HTTP avec mappage de ports :

docker run --rm -p 8000:8000 ghcr.io/blockscout/mcp-server:latest python -m blockscout_mcp_server --http --http-host 0.0.0.0

Avec un port personnalisé :

docker run --rm -p 8080:8080 ghcr.io/blockscout/mcp-server:latest python -m blockscout_mcp_server --http --http-host 0.0.0.0 --http-port 8080

Mode HTTP avec API REST :

Pour exécuter avec l’API REST activée :

docker run --rm -p 8000:8000 ghcr.io/blockscout/mcp-server:latest python -m blockscout_mcp_server --http --rest --http-host 0.0.0.0

Remarque : Lors de l’exécution en mode HTTP avec Docker, utilisez --http-host 0.0.0.0 pour lier à toutes les interfaces afin que le serveur soit accessible depuis l’extérieur du conteneur.

Avec une clé PRO API Blockscout :

Passez la clé au moment de l’exécution avec -e plutôt que de l’intégrer dans l’image (voir Fourniture de la clé PRO API au serveur) :

docker run --rm -p 8000:8000 -e BLOCKSCOUT_PRO_API_KEY=proapi_your_key_here \
  ghcr.io/blockscout/mcp-server:latest python -m blockscout_mcp_server --http --http-host 0.0.0.0

Avec la mesure de session activée (optionnel) :

La mesure de session limite le nombre d’appels d’outils qu’un appelant sans clé PRO API fournie par le client peut effectuer par identifiant de session émis par __unlock_blockchain_analysis__. Elle est désactivée par défaut. L’activer signifie définir un secret de signature (au moins 32 octets — générez-le, ne l’inventez pas), et cela nécessite le mode HTTP et une clé PRO API côté serveur (les appels mesurés sont servis en amont avec celle-ci), ainsi qu’un volume persistant pour la base de données de session. Générez le secret une seule fois et stockez-le durablement (un gestionnaire de secrets ou une configuration d’environnement persistante) ; chaque redémarrage et redéploiement doit passer la même valeur stockée :

# Once, not per start: generate the secret and keep it.
BLOCKSCOUT_SESSION_SECRET="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"

docker run --rm -p 8000:8000 \
  -v blockscout-mcp-sessions:/data \
  -e BLOCKSCOUT_SESSION_SECRET="$BLOCKSCOUT_SESSION_SECRET" \
  -e BLOCKSCOUT_SESSION_DB_PATH=/data/sessions.db \
  -e BLOCKSCOUT_PRO_API_KEY=proapi_your_key_here \
  ghcr.io/blockscout/mcp-server:latest python -m blockscout_mcp_server --http --http-host 0.0.0.0

La plupart des déploiements n’ont besoin de rien de tout cela : laissez BLOCKSCOUT_SESSION_SECRET non défini (par défaut) et aucun volume n’est requis. La perte du volume ou la rotation du secret invalide les identifiants de session actifs par conception ; l’exposition est limitée par le TTL configuré. Régénérer le secret en ligne à chaque docker run est la forme accidentelle de cette rotation — cela efface tous les identifiants actifs à chaque redémarrage même si le volume de base de données a survécu, donc n’intégrez jamais la commande de génération dans la commande de démarrage. La restauration d’une copie plus ancienne de la base de données ravive les budgets qu’elle a enregistrés — après une restauration historique, faites pivoter le secret sauf si cela est intentionnel. Réglages optionnels : BLOCKSCOUT_SESSION_MCP_MAX_CALLS et BLOCKSCOUT_SESSION_REST_MAX_CALLS (plafonds d’appels par surface sur un compteur partagé par identifiant ; les deux par défaut 5 ; 0 ferme l’accès mesuré sur cette surface tout en laissant l’émission d’identifiants et la navigation get_chains_list ouvertes), BLOCKSCOUT_SESSION_TTL_SECONDS (par défaut 900), et BLOCKSCOUT_SESSION_SWEEP_INTERVAL_SECONDS (fréquence de nettoyage des lignes de session expirées ; par défaut : une fois par TTL).

Mode Stdio : Le mode stdio par défaut est conçu pour être utilisé avec les hôtes/clients MCP (comme Claude Desktop, Cursor) et n’a pas de sens à exécuter directement avec Docker sans un client MCP gérant la communication.

Test avec Claude Desktop

Utilisez le bundle MCP pour tester le serveur avec Claude Desktop.

1. Construisez le bundle selon les instructions dans mcpb/README.md.
2. Ouvrez Claude Desktop.
3. Double-cliquez pour ouvrir le fichier blockscout-mcp-dev.mcpb afin d’installer automatiquement le bundle.
4. Configurez l’URL du serveur MCP Blockscout lorsque vous y êtes invité (par défaut : http://127.0.0.1:8000/mcp)

Confidentialité et télémétrie anonyme

Pour nous aider à améliorer le serveur MCP Blockscout, les instances communautaires du serveur collectent des données d’utilisation anonymes par défaut. Cela nous aide à comprendre quels outils sont les plus populaires et guide nos efforts de développement.

Ce que nous collectons :

• Le nom de l’outil appelé (par exemple, get_block_number).
• Les paramètres fournis à l’outil (le paramètre session_id est masqué par un espace réservé avant la transmission).
• La version du serveur MCP Blockscout utilisée.
• Un hachage unidirectionnel et non réversible (SHA-256) de la clé PRO API disponible pour autoriser la requête, lorsqu’elle est présente. Il s’agit uniquement d’une empreinte dérivée — la clé elle-même n’est jamais transmise et ne peut pas être récupérée à partir du hachage.

Ce que nous NE collectons PAS :

• Nous ne collectons aucune donnée personnelle, aucune adresse IP (le serveur central utilise l’IP de l’expéditeur pour la géolocalisation via Mixpanel puis la supprime), ni les secrets et clés privées eux-mêmes. La clé PRO API en particulier n’est jamais transmise — seule son empreinte unidirectionnelle et non réversible décrite ci-dessus, à partir de laquelle la clé ne peut pas être récupérée.

Comment se désinscrire

Vous pouvez désactiver cette fonctionnalité à tout moment en définissant la variable d’environnement suivante :

export BLOCKSCOUT_DISABLE_COMMUNITY_TELEMETRY=true

Licence

Ce projet est sous licence Blockscout Software Licence. Voir le fichier LICENSE pour les conditions complètes.