Sign inGet Started

Serveur MCP

Le serveur Bird de MCP expose l'API Bird sous forme d'outils Model Context Protocol. Les clients pris en charge incluent Claude Code, Cursor, VS Code, Codex, Claude Desktop, ChatGPT et Muse. Ils peuvent envoyer sur chaque canal géré par Bird, configurer ces canaux et inspecter votre espace de travail sans copier de commandes cURL. Vous pouvez l'exécuter de deux façons, et la plupart des utilisateurs préfèrent la première :
  1. Hébergé (mcp.bird.com) : une URL et une connexion via le navigateur. Rien à installer, pas de CLI, pas de clé API. C'est le chemin recommandé.
  2. Local en stdio (bird mcp) : des outils exécutés sur votre machine dans le bird CLI, pour les agents shell ou pour l'exécuter vous-même.
Le serveur hébergé omet ces outils réservés au stdio :
  • auth_signup, auth_verify_email et auth_create_org : ces outils créent votre premier identifiant, avant que vous puissiez vous authentifier auprès du serveur hébergé.
  • compliance_attachments_upload : cet outil lit un chemin de fichier local. Sur le serveur hébergé, ce chemin ferait référence au système de fichiers du serveur et pourrait envoyer le mauvais fichier.

Hébergé : se connecter à mcp.bird.com

Choisir un endpoint

Utilisez https://mcp.bird.com pour la plupart des connexions. C'est l'endpoint recommandé : la plupart des clients MCP recherchent et sélectionnent déjà les outils en interne à partir du catalogue complet. Certains clients ne recherchent pas les outils en interne, ou imposent une limite stricte sur le nombre d'outils qu'un serveur peut exposer. /dynamic est destiné à ces clients.
Les deux endpoints hébergés utilisent le Streamable HTTP et la même connexion Bird OAuth :
EndpointOutils visibles par votre clientQuand l'utiliser
https://mcp.bird.comLe catalogue complet des outils hébergésRecommandé pour la plupart des clients, qui recherchent et sélectionnent les outils en interne. Prend aussi en charge les widgets MCP Apps.
https://mcp.bird.com/dynamicUniquement search et executeUniquement pour les clients sans recherche d'outils interne ou avec une limite stricte sur le nombre d'outils qu'un serveur peut exposer.
L'endpoint dynamique vous donne accès aux mêmes opérations hébergées via execute. L'endpoint standard et le serveur stdio local conservent leurs outils individuels ; ils ne listent pas search ni execute.
Vous n'avez pas besoin d'installer un binaire ni de créer un jeton. La connexion se fait en deux étapes, toutes deux obligatoires :
  1. Ajouter le serveur : donnez au client l'URL de l'endpoint choisi.
  2. S'authentifier : connectez-vous via votre navigateur pour que le client détienne un jeton qui agit en votre nom.
Les deux endpoints exigent une authentification. Un client qui ne possède que l'URL reçoit une 401 tant que vous ne vous êtes pas connecté. Certains clients lancent la connexion eux-mêmes la première fois qu'ils atteignent le serveur ; d'autres enregistrent le serveur comme "needs login" et attendent que vous cliquiez dessus. Les étapes propres à votre client précisent son comportement.

Utiliser la découverte dynamique d'outils

Si votre client rejette le serveur parce qu'il offre trop d'outils, connectez-vous à https://mcp.bird.com/dynamic et terminez la connexion OAuth. Votre client liste deux outils :
  • search trouve des outils par nom ou mots-clés de description. Chaque résultat inclut son nom, sa description, son schéma d'entrée et des annotations indiquant s'il lit ou modifie des données.
  • execute appelle un outil sélectionné avec ses arguments. Il peut lire des données, envoyer des messages, modifier des enregistrements ou les supprimer, selon l'outil sélectionné.
Par exemple, votre agent peut trouver l'outil workspace avec cet appel d'outil :
Exemple de code
{
  "name": "search",
  "arguments": { "query": "workspace_get", "limit": 3 }
}
Après avoir lu le schéma d'entrée renvoyé, il appelle cet outil via execute :
Exemple de code
{
  "name": "execute",
  "arguments": { "tool": "workspace_get", "arguments": {} }
}
Le résultat contient votre espace de travail actuel. Vous pouvez aussi rechercher avec des mots-clés de tâche tels que send email. La recherche renvoie cinq résultats par défaut, accepte un limit de un à 10, et accepte des requêtes jusqu'à 500 caractères. Si le résultat contient has_more: true, affinez votre requête pour trouver des résultats plus pertinents.
Les résultats de recherche n'ajoutent pas d'outils au catalogue de votre client. Les noms mentionnés dans les résultats ou les instructions de récupération passent aussi par execute. L'exécution utilise vos permissions existantes ; si une opération nécessite plus de permissions, votre client peut vous demander de les autoriser. Trouver un outil ne donne pas accès à celui-ci.
L'exécution dynamique renvoie des données pour les outils qui affichent autrement des widgets. Utilisez l'endpoint standard pour les widgets interactifs MCP Apps. Les clients voient un seul outil d'exécution, donc les paramètres d'approbation par outil s'appliquent à execute dans son ensemble ; vérifiez l'opération sélectionnée avant d'approuver un appel. Cet endpoint exécute des appels d'outils et n'exécute pas de JavaScript ni d'autre code fourni.

Connecter un client

Les exemples ci-dessous utilisent l'endpoint standard. Pour la découverte dynamique, remplacez l'URL du serveur par https://mcp.bird.com/dynamic et suivez les mêmes étapes de connexion.

Claude Code

Ajoutez le serveur :
Exemple de code
claude mcp add --transport http bird https://mcp.bird.com
claude mcp list indique maintenant bird comme ! Needs authentication. Claude Code n'ouvre pas le navigateur de lui-même, connectez-vous donc depuis une session :
  1. Exécutez /mcp.
  2. Sélectionnez bird et appuyez sur Entrée.
  3. Choisissez Authenticate. Votre navigateur ouvre l'écran de consentement de Bird ; approuvez-le à cet endroit.
Le serveur s'affiche alors comme connecté et les outils fonctionnent. Une exécution headless (claude -p) n'a pas de panneau /mcp, authentifiez-vous donc d'abord depuis votre shell avec claude mcp login bird. Pour vous reconnecter plus tard, /mcp propose Re-authenticate ; Clear authentication supprime le jeton stocké.
L'installation du plugin bird-ai déclare ce serveur pour vous, ce qui remplace la commande claude mcp add. L'authentification reste nécessaire car un plugin peut fournir un serveur mais ne peut pas émettre de grant. Sélectionnez /mcp > bird > Authenticate après l'installation.

Cursor

Dans ~/.cursor/mcp.json :
Exemple de code
{
  "mcpServers": {
    "bird": {
      "url": "https://mcp.bird.com"
    }
  }
}
Ouvrez ensuite Cursor Settings > Tools & Integrations. Sous MCP Tools, bird affiche Needs login : cliquez dessus, approuvez l'écran de consentement de Bird dans le navigateur, et revenez dans Cursor.

OpenCode

Le plugin OpenCode de Bird enregistre le serveur pour vous, avec les agent skills de Bird :
Exemple de code
opencode plugin github:messagebird/bird-ai --global
OpenCode ajoute chaque outil MCP au contexte du modèle, donc le plugin se connecte au endpoint dynamique. Avec le mode code expérimental d'OpenCode activé (OPENCODE_EXPERIMENTAL_CODE_MODE=1, ou OPENCODE_EXPERIMENTAL=1), OpenCode garde les outils MCP derrière sa propre recherche, et le plugin se connecte au catalogue complet sur https://mcp.bird.com à la place.
Pour ajouter le serveur sans le plugin, placez ceci dans opencode.json, dans votre projet ou dans ~/.config/opencode/opencode.json :
Exemple de code
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "bird": {
      "type": "remote",
      "url": "https://mcp.bird.com/dynamic"
    }
  },
  "permission": {
    "bird_execute": "ask"
  }
}
Connectez-vous ensuite, ce qui ouvre votre navigateur sur l'écran de consentement de Bird :
Exemple de code
opencode mcp auth bird
Redémarrez OpenCode pour charger le plugin. opencode mcp list indique bird comme connecté une fois l'approbation faite. Le plugin, comme l'entrée permission ci-dessus, fait en sorte qu'OpenCode demande confirmation avant chaque appel execute, car l'outil exécuté peut modifier votre espace de travail.

VS Code

Dans .vscode/mcp.json dans votre projet :
Exemple de code
{
  "servers": {
    "bird": {
      "type": "http",
      "url": "https://mcp.bird.com"
    }
  }
}
VS Code vous demande de faire confiance au serveur lors du premier démarrage, puis exécute lui-même le flux OAuth : approuvez l'écran de consentement de Bird dans la fenêtre de navigateur qu'il ouvre. Si aucune fenêtre n'apparaît, démarrez ou redémarrez bird depuis la commande MCP: List Servers et approuvez à ce moment-là. L'autorisation obtenue figure sous Accounts > Manage Trusted MCP Servers, qui est aussi l'endroit où vous révoquez l'accès de VS Code.

Codex

Dans ~/.codex/config.toml :
Exemple de code
[mcp_servers.bird]
url = "https://mcp.bird.com"
Connectez-vous ensuite depuis votre shell, ce qui ouvre le navigateur :
Exemple de code
codex mcp login bird

Claude Desktop

Ouvrez Settings > Connectors, cliquez sur Add custom connector, collez https://mcp.bird.com, puis cliquez sur Add. Cliquez ensuite sur Connect sur le connecteur Bird pour lancer la connexion et approuver l'écran de consentement. Sur les plans Team et Enterprise, un propriétaire ajoute le connecteur une seule fois pour l'organisation et chaque membre clique toujours sur Connect pour sa propre autorisation. Activez le connecteur par conversation depuis + > Connectors.

ChatGPT

Les connecteurs MCP personnalisés nécessitent le mode développeur : Settings > Apps > Advanced settings > Developer mode. Allez ensuite dans Settings > Connectors > Create, donnez un nom et une description au connecteur, collez https://mcp.bird.com, et choisissez OAuth comme authentification. ChatGPT exécute la connexion lui-même et ouvre l'écran de consentement de Bird dans un popup la première fois que vous utilisez le connecteur.

Muse

Muse ajoute Bird en tant que connecteur personnalisé. Dans un chat Muse, demandez-lui d'en configurer un :
Exemple de code
Set up a custom connector to the Bird MCP server at https://mcp.bird.com following https://bird.com/docs/ai/mcp-server.md so you can work with my Bird workspace.
Muse répond avec un lien de connexion pour cette session. Ouvrez-le et approuvez l'écran de consentement de Bird dans le navigateur. Le lien ne fonctionne que pour vous et expire avec la session. S'il ne fonctionne plus, demandez-en un nouveau à Muse.

Factory Droid

Exemple de code
droid mcp add bird https://mcp.bird.com --type http
Exécutez ensuite /mcp dans droid et finalisez la connexion via le navigateur depuis le gestionnaire de serveurs.

Agent Plugins

Le bird-ai plugin déclare ce serveur dans un mcp.json conforme à Agent Plugins. Un hôte qui implémente la spécification lit ce fichier lors de l'installation du plugin, il n'y a donc pas de configuration serveur à écrire : installez le plugin et connectez-vous.

Tout autre hôte

Cherchez le paramètre qui ajoute un serveur MCP remote, HTTP ou custom, souvent sous un menu Connectors ou Integrations, et fournissez-lui l'URL. L'emplacement du champ varie ; utilisez l'URL de l'endpoint hébergé que vous avez choisi. Trouvez ensuite le mécanisme de connexion de ce client : un bouton Connect, Authorize ou Needs login à côté du serveur, une sous-commande login, ou une fenêtre de navigateur que le client ouvre lui-même. Un client qui liste les outils de Bird mais échoue à chaque appel possède l'URL mais a encore besoin d'une autorisation.

Ce qui se passe quand vous vous connectez

Votre navigateur s'ouvre sur un écran de consentement Bird. Connectez-vous, choisissez d'accorder des permissions au niveau de l'espace de travail ou de l'organisation, et sélectionnez les permissions à déléguer. Comme les clients MCP s'enregistrent eux-mêmes, le nom du client est auto-déclaré, et l'écran le signale comme not verified by Bird. Confirmez qu'il s'agit bien du client que vous avez lancé avant d'approuver. Après cela, les outils apparaissent dans la liste de l'agent et le jeton se renouvelle silencieusement : c'est une opération unique par client.
Le moyen le plus rapide de vérifier que tout fonctionne est de demander à l'agent d'appeler whoami : il renvoie l'utilisateur connecté, donc une vraie réponse signifie que l'autorisation est en place. Sur le endpoint dynamique, appelez-le via execute avec tool: "whoami" et un arguments vide.
L'autorisation est limitée à l'intersection de ce que le client a demandé, de ce que vous avez approuvé et de ce que vous détenez réellement ; les scopes org:owner et platform-admin ne sont jamais délégables. Elle apparaît dans la liste Connected apps de votre profil, et la révoquer coupe immédiatement l'accès au client.

Fonctionnement de la poignée de main

Vous n'avez pas besoin de ceci pour connecter un client. C'est utile si vous déboguez un client qui ne s'authentifie pas, ou si vous en écrivez un.
Le niveau hébergé utilise Streamable HTTP et ne stocke aucun identifiant : il ne conserve pas de secrets et ne valide rien lui-même. Chaque requête porte votre propre jeton bearer OAuth, que API de Bird valide à chaque requête. Le serveur est sans état et le trafic régional est routé automatiquement : l'URL unique fonctionne depuis n'importe où.
Le flux de connexion utilise le standard MCP. Les clients ne diffèrent que par ce qui le déclenche : le premier appel d'outil ou la sélection de Authenticate. Une fois le flux démarré, les étapes d'authentification ne nécessitent aucune configuration supplémentaire :
  1. Le client envoie une requête non authentifiée et reçoit 401 avec un en-tête WWW-Authenticate pointant vers les métadonnées de ressource protégée RFC 9728 de Bird (/.well-known/oauth-protected-resource).
  2. À partir de là, il découvre le serveur d'autorisation, puis s'enregistre dynamiquement (RFC 7591). L'enregistrement dynamique supprime le besoin d'un identifiant client pré-partagé ou d'une configuration manuelle.
  3. Votre navigateur ouvre l'écran de consentement de Bird.
  4. Le client échange le résultat contre un jeton d'accès (PKCE ; renouvelé automatiquement) et les outils Bird apparaissent.

Local : exécution via stdio avec le CLI

Exécutez le serveur MCP local dans le bird CLI pour les agents capables d'utiliser un shell ou pour accéder aux fichiers sur votre machine. Installez le CLI, exécutez bird auth login une fois, puis pointez votre client vers la commande bird mcp.
Vous n'exécutez pas bird mcp vous-même : votre client le lance et communique avec lui via stdin/stdout. Chaque client a besoin des deux mêmes informations : la commande (bird) et l'argument (mcp). Cette méthode ne nécessite pas de connexion par client car bird auth login détient déjà l'autorisation.

Cursor

Exemple de code
{
  "mcpServers": {
    "bird": {
      "command": "bird",
      "args": ["mcp"]
    }
  }
}

VS Code

Exemple de code
{
  "servers": {
    "bird": {
      "command": "bird",
      "args": ["mcp"]
    }
  }
}

Claude Code

Exemple de code
claude mcp add bird -- bird mcp

Authentification du serveur local

Le serveur local agit en tant que vous et réutilise la connexion stockée du CLI. bird auth login ouvre un flux OAuth dans le navigateur où vous accordez un sous-ensemble de vos permissions d'espace de travail. Le jeton émis a les mêmes plafonds de permissions que l'autorisation hébergée. Les scopes org:owner et platform-admin ne sont pas disponibles. bird mcp lit et renouvelle la connexion stockée depuis le fichier d'identifiants CLI, dont le mode est 0600. Comme pour le niveau hébergé, la configuration de votre client ne contient pas de BIRD_API_KEY ni d'autre secret. Si la connexion est absente, bird mcp refuse de démarrer et vous demande d'exécuter bird auth login.
Vous n'exposez aucun listener : le serveur tourne sur votre machine, dans le bac à sable du client, exactement le temps que le client en a besoin. L'hôte API suit automatiquement la région de votre connexion ; --base-url (ou BIRD_API_URL) la remplace pour tester dans un environnement hors production.

Ce que couvrent les outils

Le jeu d'outils couvre chaque canal sur lequel Bird opère, ainsi que les tâches de compte et de configuration associées. Il est organisé plutôt que calqué sur toute la surface API : chaque outil est limité à une tâche qu'un agent exécute réellement, et les opérations destructrices sont annotées pour que les hôtes puissent demander confirmation avant de les exécuter.
L'e-mail possède le plus d'outils, car c'est le canal avec la plus grande surface à configurer. Les autres canaux suivent la même structure envoyer-et-lire.

Messagerie

  • Envoyer et inspecter des e-mails : email_send, email_send_batch, email_list et email_get, qui renvoie le message avec son statut de livraison agrégé. Les statuts de livraison par destinataire et le journal d'événements sont des appels d'outils séparés.
  • Envoyer et inspecter des SMS : sms_send, sms_send_batch, sms_get, sms_list et sms_list_events, calqués sur la structure e-mail. sms_templates_list et sms_templates_get lisent le catalogue de templates.
  • Envoyer et inspecter des WhatsApp : whatsapp_send, whatsapp_get, whatsapp_list, whatsapp_list_events et whatsapp_media. Les templates sont une surface de rédaction complète sous whatsapp_templates_*, incluant le contenu par version et par langue.
  • Consulter les segments d'appels vocaux : voice_legs_get et voice_legs_list consultent les segments d'appels, avec des statistiques par pays et par code de réponse sous voice_stats_*. voice_session_credentials_create crée les informations d'identification de l'espace de travail qu'un client SIP ou softphone utilise pour s'authentifier.
  • Vérifier un destinataire : verify_verifications_create envoie un code de vérification à usage unique, verify_verifications_check valide ce que le destinataire a soumis, et verify_verifications_next_channel bascule sur un autre canal.
  • Créer un appel vocal (aperçu) : voice_calls_create prépare un appel sortant à l'aide de la publication active d'une séquence activée et non archivée. Une personne examine et exécute la requête dans le navigateur ; sa préparation ne lance pas l'appel. Consultez Créer un appel vocal pour les autorisations et les instructions de nouvelle tentative. Le serveur local bird mcp nécessite une version du CLI qui inclut cet outil.

Préparer un canal pour l'envoi

  • Configurer les domaines d'envoi : email_domains_create ajoute un domaine d'envoi et renvoie les enregistrements DNS à publier ; email_domains_verify les revérifie ; plus email_domains_list et email_domains_get.
  • Revendiquer et enregistrer des expéditeurs SMS : sms_senders_create revendique un expéditeur, sms_senders_requirements indique ce qu'un pays exige de lui, et sms_senders_registrations_create l'enregistre. Le trafic A2P aux États-Unis passe par les outils de marque, campagne et soumission sms_10dlc_*.
  • Provisionner des numéros : numbers_available_list recherche, numbers_orders_create achète et numbers_release restitue. whatsapp_numbers_precheck indique si WhatsApp acceptera un numéro avant que vous ne le commandiez.
  • Vérifier que le compte peut envoyer : les outils trust_* signalent les exigences de l'organisation qui conditionnent l'achat d'un numéro ou l'enregistrement d'un expéditeur.

Délivrabilité e-mail

  • Créer des templates e-mail : email_templates_create, email_templates_list, email_templates_get, email_templates_update, email_templates_duplicate et email_templates_preview (rendu d'un brouillon avec des valeurs d'exemple sans envoi). Les versions se trouvent sous email_templates_versions_*, où email_templates_versions_submit fige un brouillon et en fait la version servie par les envois, et email_templates_versions_languages_* modifie le contenu par langue d'un brouillon. Rien de ce qu'un agent écrit n'atteint un destinataire tant qu'il ne soumet pas.
  • Gérer les suppressions : email_suppressions_list, email_suppressions_check (cette adresse est-elle sûre pour l'envoi ?), email_suppressions_add et email_suppressions_remove (annoté destructif, car supprimer une suppression sans raison nuit à la réputation de l'expéditeur).
  • Gérer les IP dédiées et les pools : email_dedicated_ips_create, email_dedicated_ips_list, email_dedicated_ips_get, email_dedicated_ips_assign (déplacer une IP dans un pool) et email_dedicated_ips_delete ; plus email_ip_pools_create, email_ip_pools_list, email_ip_pools_get, email_ip_pools_update et email_ip_pools_delete pour les pools via lesquels vous routez vos envois.

Audience et configuration

  • Gérer les contacts et les audiences : contacts_* et contact_properties_* pour les personnes à qui vous envoyez, audiences_* pour les listes auxquelles vous envoyez, et preferences_* pour les consentements et les désinscriptions.
  • Provisionner Realtime : realtime_apps_* et realtime_apps_keys_* créent les applications et les clés avec lesquelles les clients Realtime se connectent.
  • Rechercher quelqu'un : lookup_phone_number et lookup_email indiquent ce que Bird sait d'une adresse avant que vous ne lui envoyiez un message.
  • Inspecter la configuration : webhooks_list, workspace_get et whoami (l'utilisateur connecté : id, e-mail, nom).
Votre client affiche la liste des outils disponibles avec leurs noms, descriptions et schémas d'entrée. Considérez cette liste comme l'inventaire de référence. Une bonne première tâche à essayer de bout en bout :
Call whoami to find my email, then send me a test email from onboarding@messagebird.dev and tell me when it's delivered.

MCP ou le CLI ?

Même surface, même modèle d'authentification, appelants différents. Pour les agents capables d'utiliser un shell (Claude Code, terminal de Cursor, CI), le CLI est plus léger : sortie JSON, codes de sortie sémantiques et bien moins de jetons par opération. MCP est destiné aux hôtes qui appellent des outils au lieu d'exécuter des shells, et le endpoint hébergé atteint ceux qui ne peuvent pas du tout exécuter un binaire (Claude Desktop, ChatGPT, mobile). Vous n'avez pas à choisir à l'avance : l'URL hébergée ne nécessite aucune installation, et le bird mcp local est déjà là une fois le CLI installé.

Étapes suivantes

  • AI onboarding : la version quickstart de cette page, plus le corpus de documentation lisible par les machines.
  • Agent skills : le plugin marketplace bird-ai, skills plus ce serveur MCP, installé en une étape.
  • CLI pour agents : pilotez Bird depuis des agents capables d'utiliser un shell sans MCP : sortie JSON, codes de sortie sémantiques, connexion OAuth.
  • Authentication : clés API, régions et mode d'autorisation des requêtes.