Sign inGet started

Serveur MCP

Le serveur MCP de Bird 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 et ChatGPT. Ils peuvent envoyer sur chaque canal opé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 la méthode recommandée.
  2. Local via stdio (bird mcp) : des outils exécutés sur votre machine dans le CLI bird, pour les agents shell ou l'exécution en autonomie.
Le serveur hébergé omet ces outils disponibles uniquement via stdio :
  • auth_signup, auth_verify_email et auth_create_org : ces outils créent vos premiers identifiants, 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 désignerait le système de fichiers du serveur et pourrait téléverser le mauvais fichier.

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

Choisir un point de terminaison

Utilisez https://mcp.bird.com pour la plupart des connexions. C'est le point de terminaison recommandé : la plupart des clients MCP recherchent et sélectionnent déjà les outils en interne dans le catalogue complet. Certains clients ne recherchent pas les outils en interne, ou imposent une limite stricte au nombre d'outils qu'un serveur peut exposer. /dynamic est destiné à ces clients.
Les deux points de terminaison hébergés utilisent Streamable HTTP et la même connexion OAuth Bird :
Point de terminaisonOutils 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 interne d'outils ou avec une limite stricte au nombre d'outils qu'un serveur peut exposer.
Le point de terminaison dynamique donne accès aux mêmes opérations hébergées via execute. Le point de terminaison standard et le serveur stdio local conservent leurs outils individuels ; ils ne listent ni 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, et les deux sont requises :
  1. Ajouter le serveur : donnez au client l'URL du point de terminaison choisi.
  2. S'authentifier : connectez-vous via votre navigateur pour que le client détienne un jeton qui agit en votre nom.
Les deux points de terminaison nécessitent une authentification. Un client qui n'a que l'URL reçoit un 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 placent le serveur en « nécessite une connexion » et attendent que vous cliquiez dessus. Les étapes de votre client identifient son comportement.

Utiliser la découverte dynamique d'outils

Si votre client refuse le serveur parce qu'il propose 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 par mots-clés de leur description. Chaque résultat inclut le nom, la description, le schéma d'entrée et des annotations indiquant si l'outil 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 d'espace de travail 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 décrivant une tâche, comme send email. La recherche renvoie cinq résultats par défaut, accepte une valeur limit de un à 10 et des requêtes de 500 caractères maximum. Si le résultat contient has_more: true, précisez 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ésolution passent aussi par execute. L'exécution utilise vos permissions existantes ; si une opération nécessite davantage de permissions, votre client peut vous demander de les autoriser. Trouver un outil ne vous y donne pas accès.
L'exécution dynamique renvoie des données pour les outils qui affichent normalement des widgets. Utilisez le point de terminaison standard pour les widgets MCP Apps interactifs. Les clients voient un seul outil d'exécution ; les paramètres d'approbation par outil s'appliquent donc à execute dans son ensemble. Vérifiez l'opération sélectionnée avant d'approuver un appel. Ce point de terminaison 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 le point de terminaison 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 Bird ; approuvez-le là-bas.
Le serveur s'affiche alors comme connecté et les outils fonctionnent. Une exécution sans interface (claude -p) n'a pas de panneau /mcp, donc authentifiez-vous d'abord depuis votre shell avec claude mcp login bird. Pour vous reconnecter ultérieurement, /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 requise car un plugin peut livrer un serveur mais ne peut pas émettre une autorisation. 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 Bird dans le navigateur et revenez à Cursor.

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 la première fois qu'il démarre, puis exécute le flux OAuth lui-même : approuvez l'écran de consentement 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-le alors. L'autorisation résultante est listée 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 et 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 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 lance la connexion lui-même et ouvre l'écran de consentement Bird dans un popup la première fois que vous utilisez le connecteur.

Factory Droid

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

Agent Plugins

Le plugin bird-ai déclare ce serveur dans un mcp.json qui suit la spécification 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 donnez-lui l'URL. L'emplacement du champ varie ; utilisez l'URL du point de terminaison hébergé choisi. Trouvez ensuite l'interface de connexion de ce client : un contrôle Connect, Authorize ou Needs login à côté du serveur, une sous-commande login, ou une fenêtre de navigateur que le client ouvre de lui-même. Un client qui liste les outils Bird mais échoue à chaque appel a l'URL mais nécessite encore 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 les 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é, donc l'écran le signale comme not verified by Bird. Confirmez qu'il s'agit bien du client que vous avez réellement lancé avant d'approuver. Après cela, les outils apparaissent dans la liste de l'agent et le jeton se rafraîchit silencieusement, c'est donc une étape unique par client.
Le moyen le plus rapide de vérifier que cela 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 point de terminaison dynamique, appelez-le via execute avec tool: "whoami" et des arguments vides.
L'autorisation est limitée à l'intersection de ce que le client a demandé, ce que vous avez approuvé et 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 du client.

Comment fonctionne la négociation

Vous n'avez pas besoin de ceci pour connecter un client. C'est utile si vous déboguez un client qui refuse de s'authentifier, ou si vous en développez un.
Le niveau hébergé utilise Streamable HTTP et est sans identifiants : il ne stocke aucun secret et ne valide rien lui-même. Chaque requête porte votre propre jeton porteur OAuth, que l'API Bird valide à chaque requête. Le serveur est sans état et le trafic régional est routé automatiquement, donc l'URL unique fonctionne depuis n'importe où.
Le flux de connexion utilise le MCP standard. 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 fait une requête non authentifiée et reçoit un 401 avec un en-tête WWW-Authenticate pointant vers les métadonnées de ressource protégée Bird RFC 9728 (/.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 élimine le besoin d'un identifiant client pré-partagé ou d'une configuration manuelle.
  3. Votre navigateur ouvre l'écran de consentement Bird.
  4. Le client échange le résultat contre un jeton d'accès (PKCE ; rafraîchi automatiquement) et les outils Bird apparaissent.

Local : l'exécuter via stdio avec le CLI

Exécutez le serveur MCP local dans le CLI bird pour les agents capables d'utiliser le shell ou pour accéder aux fichiers de votre machine. Installez le CLI, exécutez bird auth login une fois, puis dirigez 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 sur 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

Comment le serveur local s'authentifie

Le serveur local agit en votre nom 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 limites de permissions que l'autorisation hébergée. Ni les scopes org:owner ni platform-admin ne sont disponibles. bird mcp lit et rafraîchit la connexion stockée depuis le fichier d'identifiants du CLI, dont le mode est 0600. Comme pour le niveau hébergé, votre configuration client ne contient aucun BIRD_API_KEY ni autre secret. Si la connexion est manquante, bird mcp refuse de démarrer et vous indique d'exécuter bird auth login.
Vous n'exposez pas d'écouteur : le serveur s'exécute sur votre machine, dans le bac à sable du client, exactement aussi longtemps que le client en a besoin. L'hôte API suit automatiquement la région de votre connexion ; --base-url (ou BIRD_API_URL) le remplace pour les tests sur un environnement hors production.

Ce que couvrent les outils

L'ensemble d'outils couvre chaque canal opéré par Bird, plus les tâches de compte et de configuration associées. Il est sélectionné plutôt que la surface API complète : chaque outil est limité à une tâche qu'un agent effectue réellement, et les opérations destructives sont annotées pour que les hôtes puissent demander confirmation avant de les exécuter.
L'email a le plus d'outils, car il a la plus grande surface à configurer. Les autres canaux suivent la même structure envoi-et-lecture.

Messagerie

  • Envoyer et inspecter des emails : 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, reflétant la structure email. sms_templates_list et sms_templates_get lisent le catalogue de modèles.
  • Envoyer et inspecter des WhatsApp : whatsapp_send, whatsapp_get, whatsapp_list, whatsapp_list_events et whatsapp_media. Les modèles sont une surface de création complète sous whatsapp_templates_*, incluant le contenu par version et par langue.
  • Inspecter les appels vocaux : voice_get et voice_list lisent les appels, avec des statistiques par pays et par code de réponse sous voice_stats_*. voice_session_credentials_create génère l'identifiant d'espace de travail avec lequel un client SIP ou softphone s'authentifie. Aucun outil MCP ne passe d'appel : c'est bird voice tools test-call sur le CLI.
  • Vérifier un destinataire : verify_verifications_create envoie un code à usage unique, verify_verifications_check valide ce que le destinataire a soumis, et verify_verifications_next_channel bascule vers un autre canal.

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 celui-ci, et sms_senders_registrations_create l'enregistre. Le trafic A2P américain passe par les outils sms_10dlc_* de marque, campagne et soumission.
  • 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_* indiquent les exigences organisationnelles qui conditionnent l'achat d'un numéro ou l'enregistrement d'un expéditeur.

Délivrabilité email

  • Créer des modèles d'email : email_templates_create, email_templates_list, email_templates_get, email_templates_update, email_templates_duplicate et email_templates_preview (rendre un brouillon avec des valeurs d'exemple sans envoyer). 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_* édite le contenu par langue d'un brouillon. Rien de ce qu'un agent écrit n'atteint un destinataire tant qu'il ne le soumet pas.
  • Gérer les suppressions : email_suppressions_list, email_suppressions_check (est-il sûr d'envoyer à cette adresse ?), email_suppressions_add et email_suppressions_remove (annotée destructive, car supprimer une suppression sans raison endommage 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 à travers lesquels vous routez les envois.

Audience et configuration

  • Gérer les contacts et audiences : contacts_* et contact_properties_* pour les personnes à qui vous envoyez, audiences_* pour les listes auxquelles vous envoyez, et preferences_* pour les autorisations de consentement et les désinscriptions.
  • Provisionner Realtime : realtime_apps_* et realtime_apps_keys_* créent les applications et 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.
  • Inspecter la configuration : webhooks_list, workspace_get et whoami (l'utilisateur connecté : id, email, nom).
Votre client affiche la liste des outils en direct avec les noms, descriptions et schémas d'entrée. Considérez cette liste comme l'inventaire faisant autorité. Une bonne première tâche à essayer de bout en bout :
Appelez whoami pour trouver mon email, puis envoyez-moi un email de test depuis onboarding@messagebird.dev et dites-moi quand il est livré.

MCP ou le CLI ?

Même surface, même modèle d'authentification, appelants différents. Pour les agents capables d'utiliser le shell (Claude Code, le terminal de Cursor, CI), le CLI est plus léger : sortie JSON, codes de sortie sémantiques et beaucoup moins de jetons par opération. MCP est pour les hôtes qui appellent des outils au lieu d'exécuter des shells, et le point de terminaison 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é.

Prochaines étapes

  • Intégration IA : la version démarrage rapide de cette page, plus le corpus de documentation lisible par machine.
  • Compétences agent : le plugin marketplace bird-ai, compétences plus ce serveur MCP, installés en une étape.
  • CLI pour les agents : pilotez Bird depuis des agents capables d'utiliser le shell sans MCP : sortie JSON, codes de sortie sémantiques, connexion OAuth.
  • Authentification : clés API, régions et comment les requêtes sont autorisées.