+190 XP

GPT actions : laisser ChatGPT appeler vos API

Les GPT Actions permettent à un custom GPT d'appeler des API externes que vous décrivez. Au lieu de deviner, ChatGPT récupère des données en temps réel ou déclenche un vrai système pour votre compte. Vous écrivez une petite spec OpenAPI, vous la pointez vers votre endpoint, vous configurez l'authentification, et le modèle décide quand l'appeler au cours d'une conversation.

C'est la même mécanique que le function calling de l'API, empaquetée pour le Custom GPT builder en no-code. Vous définissez les outils. ChatGPT décide quand et comment les appeler.

Ce qu'est réellement une Action

Une Action, c'est un ou plusieurs endpoints HTTP exposés à un GPT au moyen d'une spécification OpenAPI. OpenAPI (anciennement Swagger) est une description standard, lisible par une machine, d'une API REST : ses chemins, ses paramètres, ses corps de requête et ses réponses.

Quand vous ajoutez une Action à un GPT, trois choses se produisent à l'exécution :

  1. Le modèle lit les descriptions de vos opérations et décide qu'un appel est nécessaire.
  2. ChatGPT construit la requête HTTP (en remplissant les paramètres à partir de la conversation), ajoute l'authentification et l'envoie.
  3. Votre API répond en JSON, et le modèle lit ce JSON pour rédiger sa réponse.

Le modèle ne voit jamais votre serveur. Il ne voit que le schéma que vous lui avez fourni et la réponse qui revient. Vos champs `description` sont donc du prompt, et des descriptions vagues produisent des appels erronés.

Où se trouvent les Actions

Les Actions se configurent dans l'éditeur de GPT sur chatgpt.com (GPTs, Create, puis l'onglet Configure). Descendez jusqu'à Actions et cliquez sur Create new action. Vous collez un schéma, choisissez un type d'authentification, et ChatGPT le valide immédiatement.

Actions ou apps (anciennement connectors)

ChatGPT dispose désormais d'un second moyen d'atteindre des systèmes externes. En décembre 2025, OpenAI a renommé les connectors en apps. Le catalogue comprend des intégrations prêtes à l'emploi, gérées par OpenAI, comme Google Drive, SharePoint et GitHub. Depuis octobre 2025, les développeurs peuvent aussi créer leurs propres apps avec l'Apps SDK, construit sur le Model Context Protocol (MCP). Une app tourne sous la forme d'un serveur MCP que vous hébergez. Elle peut exposer des outils et, en option, afficher une interface interactive dans le chat. Elle fonctionne dans toutes les conversations ChatGPT, pas seulement à l'intérieur d'un GPT.

Une règle approximative pour choisir :

  • Utilisez une app existante quand elle couvre déjà la source (rechercher dans votre Drive, par exemple).
  • Créez une Action quand vous voulez qu'un custom GPT appelle votre backend REST et que vous disposez déjà d'une spec OpenAPI, ou pouvez en écrire une.
  • Créez une app basée sur MCP quand l'intégration doit être disponible dans tout ChatGPT, nécessite une interface riche ou doit aussi être réutilisable par d'autres clients MCP.

Les conseils de conception de cette leçon valent pour les deux. Des descriptions d'outils claires, des opérations étroites, des réponses légères et une validation côté serveur comptent autant dans un outil MCP que dans une Action.

Un exemple concret : consulter le statut d'une commande

Supposons que votre équipe support veuille un GPT qui répond à « Où en est la commande 10428 ? » en appelant votre API interne de commandes. Votre endpoint existe déjà :

GET https://api.acme-shop.com/v1/orders/{orderId}

Il renvoie quelque chose comme :

json
{
  "orderId": "10428",
  "status": "shipped",
  "carrier": "DHL",
  "trackingNumber": "JD0149...",
  "estimatedDelivery": "2026-02-14"
}

Il reste à décrire cet endpoint au GPT. Voici un schéma OpenAPI 3.1 propre et minimal, à coller directement dans l'éditeur d'Actions :

yaml
openapi: 3.1.0
info:
  title: Acme Orders API
  version: 1.0.0
servers:
  - url: https://api.acme-shop.com/v1
paths:
  /orders/{orderId}:
    get:
      operationId: getOrderStatus
      summary: Get the current status and tracking info for one order.
      description: >
        Look up a single order by its numeric ID. Use this whenever a
        user asks where their order is, its delivery date, or its
        shipping status. Returns status, carrier, and tracking number.
      parameters:
        - name: orderId
          in: path
          required: true
          description: The order's numeric ID, e.g. 10428.
          schema:
            type: string
      responses:
        "200":
          description: Order found.
          content:
            application/json:
              schema:
                type: object
                properties:
                  orderId: { type: string }
                  status: { type: string }
                  carrier: { type: string }
                  trackingNumber: { type: string }
                  estimatedDelivery: { type: string, format: date }
        "404":
          description: No order with that ID exists.

Quelques éléments rendent ce schéma bon, et pas seulement valide :

  • L'operationId est explicite. getOrderStatus parle davantage au modèle que get1, et il devient le nom de la fonction.
  • La description indique au modèle quand l'utiliser. La phrase « Use this whenever a user asks... » sert au routage d'intention.
  • Le 404 est documenté. Quand le modèle reçoit un 404, il peut dire à l'utilisateur « Je n'ai pas trouvé cette commande » au lieu d'inventer un statut.

Une fois le schéma enregistré, ChatGPT affiche l'opération disponible. Testez-la en posant au GPT une question naturelle. La première fois qu'il appelle un nouveau domaine, ChatGPT demande confirmation à l'utilisateur, puis envoie la requête.

Authentification

Dans le builder, les Actions prennent en charge trois modes d'authentification : None, API Key et OAuth. Le schéma déclare ce qu'il faut appeler. L'authentification détermine comment vous prouvez qui vous êtes.

API Key

C'est l'option sécurisée la plus simple. Vous collez une clé dans l'éditeur de GPT, choisissez comment elle est envoyée (header Bearer, Basic ou header personnalisé), et OpenAI la stocke chiffrée. ChatGPT l'ajoute à chaque appel. Ajoutez un bloc securitySchemes correspondant à votre schéma :

yaml
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
security:
  - bearerAuth: []

Tous les utilisateurs du GPT partagent cette clé. Cela convient pour un endpoint interne en lecture seule, protégé par vos propres contrôles réseau. Cela ne convient pas quand chaque utilisateur ne doit voir que ses propres données, car le modèle agirait sous une identité unique partagée.

OAuth

Quand vous avez besoin d'une identité par utilisateur (chaque agent support, ou chaque client, s'authentifiant en son nom propre), utilisez OAuth. Vous fournissez l'URL d'autorisation, l'URL de token, le client ID, le client secret et les scopes. ChatGPT exécute le flux OAuth standard : l'utilisateur clique sur Sign in, approuve l'accès sur votre serveur d'authentification, et ChatGPT stocke le token de cet utilisateur. Les appels portent alors les permissions de cet utilisateur.

Utilisez OAuth pour tout ce qui écrit des données ou expose des enregistrements privés. La configuration complète se trouve dans la documentation sur l'authentification des Actions. Les apps basées sur MCP utilisent aussi OAuth : le serveur d'authentification que vous configurez ici restera utilisable si vous créez une app plus tard.

Un mot sur les secrets et les rate limits

Ne mettez jamais d'identifiants dans le schéma lui-même ni dans les instructions du GPT. Quiconque peut utiliser un GPT parvient parfois à lui faire révéler sa configuration. Gardez les secrets dans les champs d'authentification dédiés et protégez votre endpoint avec son propre rate limiting. Un GPT populaire peut générer un trafic réel, et le modèle peut relancer un appel en cas d'erreur.

Concevoir l'API pour un modèle, pas pour un humain

Une API REST conçue pour des ingénieurs et une API conçue pour un LLM diffèrent sur des points mineurs. Resserrez ceux-ci :

  • Renvoyez un JSON léger et plat. La réponse entre dans la fenêtre de contexte et coûte des tokens. Une consultation de commande n'a pas besoin de tout le journal d'audit.
  • Utilisez des noms de champs clairs. estimatedDelivery vaut mieux que est_dlv_dt, parce que le modèle raisonne à partir des noms.
  • Rendez les erreurs lisibles avec un message compréhensible en cas d'échec, pour que le modèle puisse le transmettre.
  • Gardez des opérations étroites. Un endpoint qui fait cinq choses brouille le routage. Préférez getOrderStatus, cancelOrder et getInvoice comme opérations distinctes, avec des descriptions distinctes.

Le modèle ne peut faire que ce que votre schéma décrit. Si vous voulez qu'il annule des commandes, il vous faut une opération cancelOrder (un POST ou un DELETE) avec sa propre description et, idéalement, OAuth pour que l'action s'exécute au nom d'un vrai utilisateur autorisé à annuler.

Vérification des acquis

1. Quel est l'objectif principal d'une GPT Action ?

2. Pourquoi la leçon insiste-t-elle sur le fait que vos champs « description » OpenAPI sont « du prompt, pas de la documentation » ?

3. Dans un scénario où vous devez faire entrer des données de Google Drive dans ChatGPT pour la recherche et la récupération, que devez-vous utiliser ?

CHOIX MULTIPLES

4. Sélectionnez TOUTES les affirmations qui décrivent correctement ce qui se passe à l'exécution quand un GPT utilise une Action.

Sélectionnez toutes les réponses correctes.

CHOIX MULTIPLES

5. Sélectionnez TOUTES les affirmations correctes qui distinguent les Actions des Connectors.

Sélectionnez toutes les réponses correctes.

Actions à conséquences et confirmation

Certains appels sont en lecture seule. D'autres changent le monde réel : rembourser un paiement, envoyer un e-mail, supprimer un enregistrement. ChatGPT les traite différemment.

Par défaut, ChatGPT demande confirmation à l'utilisateur avant d'appeler une Action sur un nouveau domaine. Pour les écritures, cette friction est souhaitable. Vous pouvez marquer des opérations pour que l'utilisateur doive confirmer à chaque fois, ce qui est une bonne pratique pour tout ce qui est destructif. Traitez chaque `POST`, `PUT`, `PATCH` et `DELETE` comme à conséquences jusqu'à preuve du contraire. Concevez votre endpoint pour qu'une étape de confirmation coûte peu, par exemple avec un flux en deux appels : un pour prévisualiser, un pour valider.

Le GPT raisonne à partir de vos descriptions et peut appeler la mauvaise opération ou passer le mauvais argument. Votre serveur est la véritable autorité. Validez chaque requête côté serveur : vérifiez que la commande appartient à l'utilisateur authentifié, que le montant reste dans les limites, que l'ID est bien formé. Ne partez jamais du principe que le modèle a vu juste.

Le lien avec l'API et l'Agents SDK

Les Actions sont l'interface Custom GPT pour l'utilisation d'outils. La même idée fait tourner l'API OpenAI, où vous définissez des outils sous forme de schémas JSON et où le modèle renvoie un appel d'outil structuré que votre code exécute. Si le GPT builder ne suffit plus (vous avez besoin de logique personnalisée entre les appels, de votre propre interface ou d'une orchestration entre de nombreux outils), passez à la Responses API ou à l'Agents SDK, où vous contrôlez directement la boucle.

Les descriptions et schémas de paramètres écrits pour une Action se transposent presque tels quels en définitions d'outils dans le code, ou en outils sur un serveur MCP. Voyez les GPT Actions comme la version hébergée, sans orchestration, de ce pattern. Prototypez une intégration sous forme d'Action. Passez ensuite à l'Agents SDK quand vous avez besoin d'un contrôle total, ou à une app Apps SDK quand vous voulez la rendre disponible dans tout ChatGPT.

Déboguer les Actions

Quand un appel se comporte mal, procédez dans cet ordre :

  1. Le modèle l'a-t-il seulement appelé ? S'il a répondu au hasard, votre description est trop faible ou trop générique. Ajoutez une phrase de déclenchement explicite du type « Use this when... ».
  2. Mauvais paramètres ? Vérifiez les champs description et les types des paramètres. L'ambiguïté à ce niveau produit des requêtes mal formées.
  3. Échecs d'authentification ? Testez l'endpoint avec exactement la même clé ou le même token en dehors de ChatGPT (un appel curl) pour déterminer si le problème vient de votre authentification ou de la configuration du GPT.
  4. Schéma rejeté à l'enregistrement ? L'éditeur valide par rapport à OpenAPI 3.1. Collez votre YAML dans un validateur externe pour trouver la ligne fautive.

Faites un rapide contrôle avec curl avant même d'ouvrir le builder :

bash
curl -s https://api.acme-shop.com/v1/orders/10428 \
  -H "Authorization: Bearer $ACME_TOKEN"

Si cela renvoie un JSON propre, côté GPT il ne reste que le schéma et la configuration de l'authentification.

Points clés

  • Rédigez les descriptions comme des prompts. Les champs operationId, summary et description déterminent quand et comment le modèle appelle votre API : incluez une phrase explicite « Use this when... » dans chaque opération.
  • Choisissez la bonne interface. Utilisez une Action pour un custom GPT qui dialogue avec votre API REST. Utilisez une app existante (anciennement connector) quand elle couvre la source. Créez une app basée sur MCP avec l'Apps SDK pour les intégrations qui doivent fonctionner dans tout ChatGPT.
  • Adaptez l'authentification aux besoins d'identité : API Key pour des endpoints internes partagés en lecture seule, OAuth dès que chaque utilisateur doit agir en son nom propre ou que l'action écrit des données.
  • Traitez le modèle comme une entrée non fiable. Validez chaque requête côté serveur et marquez les opérations d'écriture comme à conséquences pour que les utilisateurs confirment avant toute modification.
  • Gardez des réponses légères et plates : elles consomment des tokens de contexte et le modèle raisonne à partir de vos noms de champs.
  • Prototypez sous forme d'Action, puis passez à l'Agents SDK ou à une app. Les mêmes schémas restent valables.

Questions fréquentes

Qu'est-ce qu'une GPT Action dans ChatGPT ?

Une GPT Action, c'est un ou plusieurs endpoints HTTP exposés à un custom GPT au moyen d'une spécification OpenAPI. Vous collez le schéma dans l'éditeur du GPT, vous choisissez un type d'authentification, et ChatGPT décide ensuite, en cours de conversation, quand construire la requête, y joindre l'authentification et l'envoyer. Votre API renvoie du JSON, et le modèle s'appuie sur ce JSON pour rédiger sa réponse.

Quelle différence entre une GPT Action et une app ChatGPT ?

Une Action vit à l'intérieur d'un seul custom GPT et appelle votre API REST à partir d'une spec OpenAPI. Une app (le nom qu'OpenAI a donné aux connecteurs en décembre 2025) tourne sous forme de serveur MCP que vous hébergez, fonctionne dans toutes les conversations ChatGPT et pas dans un seul GPT, et peut afficher une UI interactive dans le chat. Utilisez une app existante quand elle couvre déjà la source, construisez une Action pour un seul GPT qui interroge votre backend, et construisez une app basée sur MCP avec l'Apps SDK quand l'intégration doit être disponible partout dans ChatGPT.

Faut-il utiliser une clé API ou OAuth pour ma GPT Action ?

Réservez la clé API aux endpoints internes partagés et en lecture seule : tous les utilisateurs du GPT appellent avec la même identité, qu'OpenAI stocke chiffrée et joint à chaque requête. Passez à OAuth dès que chaque utilisateur ne doit voir que ses propres données ou que l'Action écrit quoi que ce soit : ChatGPT exécute alors le flux standard et stocke un token par utilisateur qui porte les permissions de cet utilisateur. OAuth reste valable si vous reconstruisez plus tard l'intégration sous forme d'app basée sur MCP.

Pourquoi ChatGPT n'appelle-t-il pas mon Action quand je pose la question ?

Presque toujours parce que la description de l'opération est trop faible ou trop générique : le modèle répond au jugé au lieu de passer par votre endpoint. Ajoutez dans la description une phrase explicite du type « Use this when a user asks... » et donnez à l'opération un operationId lisible comme getOrderStatus plutôt que get1. Ces champs de description sont du prompt, pas de la documentation.

Comment concevoir une API REST pour qu'un modèle l'utilise correctement ?

Renvoyez un JSON court et plat : chaque réponse consomme des tokens de contexte et le modèle raisonne à partir de vos noms de champs. estimatedDelivery vaut mieux que est_dlv_dt. Gardez des opérations étroites, une tâche chacune, avec des descriptions distinctes pour getOrderStatus, cancelOrder et getInvoice plutôt qu'un seul endpoint qui fait tout. Documentez aussi les codes d'erreur, pour qu'un 404 permette au modèle de dire que la commande est introuvable au lieu d'inventer un statut.

Comment empêcher un custom GPT de déclencher par erreur un appel destructeur ?

Considérez chaque POST, PUT, PATCH et DELETE comme lourd de conséquences et marquez ces opérations pour que l'utilisateur confirme à chaque fois ; ChatGPT demande déjà une confirmation la première fois qu'il appelle un nouveau domaine. Ensuite, traitez le modèle comme une entrée non fiable et validez côté serveur : vérifiez que l'enregistrement appartient à l'utilisateur authentifié, que les montants restent dans les limites, que les identifiants sont bien formés. Un flux en deux appels, l'un pour prévisualiser et l'autre pour valider, rend l'étape de confirmation peu coûteuse.

À faire, tiré de cette leçon

Ces actions sont compilées dans le plan d'action du rôle.

  • Rédiger l'operationId, le summary et la description de l'Action comme des indications de « quand l'utiliser »
  • Utilisez OAuth pour les Actions à portée utilisateur ou en écriture ; les clés d'API uniquement pour les accès partagés en lecture seule
Voir le plan d'action complet →

Articles liés

Les articles récents du blog qui s'appuient sur cette leçon.