ChatGPT Apps : guide complet pour développeurs en 2025

Pendant que tu lis ces lignes, OpenAI vient d'ouvrir les portes. Hier – littéralement hier – ils ont lancé l'App Directory pour ChatGPT et ouvert les soumissions pour TOUS les développeurs. Pas seulement pour des partenaires sélectionnés. Pour tout le monde. Toi y compris.

800 millions d'utilisateurs. Pratiquement aucune concurrence. La fenêtre d'opportunité est ouverte en ce moment même. Et elle se fermera dans quelques mois quand tout le monde se précipitera.

Ce n'est pas un énième article sur "regarde ce que tu pourrais faire un jour". C'est un guide pour ceux qui veulent saisir le moment maintenant, pendant que le marché est vide.

Tu te souviens comment l'App Store s'est ouvert en 2008, et tout le monde pensait "qui a besoin d'applis sur un téléphone ?" Puis Angry Birds a fait un milliard de dollars, Instagram s'est vendu à Facebook pour un milliard, Uber a grandi jusqu'à 80 milliards. Les premiers développeurs qui sont entrés à l'époque ont décroché le jackpot simplement parce qu'ils étaient les premiers.

On est en décembre 2025. Et exactement la même chose se passe en ce moment. Sauf que maintenant ça s'appelle ChatGPT Apps.

Le 6 octobre, OpenAI a lancé une nouvelle plateforme – et tu sais combien d'utilisateurs elle a au lancement ? 800 millions. Pas 10 millions comme l'iPhone en 2008. Huit cents millions. L'App Store était 80 fois plus petit au lancement. Tu comprends ?

Et combien de concurrents il y a maintenant ? Au 18 décembre – moins de vingt applis. Spotify, Booking.com, Canva, Zillow, AllTrails, quelques outils d'entreprise. C'est tout. Littéralement tout. Le marché est complètement vide. Et hier OpenAI a ouvert les soumissions pour tous les développeurs – toi y compris.

Je ne plaisante pas. Tu tapes dans ChatGPT : "Spotify, crée une playlist pour courir" – et directement dans le chat, un widget Spotify s'ouvre. Avec des morceaux, des boutons, tout fonctionne. Pas de changement d'onglets, pas de copier-coller. Magique.

Ou : "Booking, trouve un hôtel à Paris en dessous de 100 €" – boum, une carte avec des options, des photos, tu peux réserver immédiatement.

Et tu peux créer le même type d'appli.

Laisse-moi te montrer comment.

Pourquoi ce n'est pas juste une autre "nouvelle fonctionnalité"

Écoute, je comprends. Tout le monde a développé une immunité aux nouvelles du type "wow, une nouvelle techno va changer le monde". Chaque semaine quelque chose de nouveau. Crypto, NFT, métavers, AGI arrive la semaine prochaine. Fatigué du hype ? Moi aussi.

Mais là c'est différent. Regardons les chiffres.

App Store en 2008 :

• 10 millions d'utilisateurs iPhone au lancement
• Pour développer une appli, tu avais besoin d'un Mac (minimum 1000 $) et d'un appareil pour tester
• La concurrence a commencé à zéro, mais après six mois il y avait des milliers d'applis
• Tu devais apprendre Objective-C (ouais, ce cauchemar avec les crochets)

Qu'est-ce qui en est sorti ? Instagram vendu pour un milliard, Angry Birds a eu un milliard de téléchargements, Uber vaut maintenant 80+ milliards.

Les gars qui sont entrés les premiers – ils ont juste réussi à temps. Ils étaient là quand il n'y avait pas de concurrence.

ChatGPT Apps maintenant :

• 800 millions d'utilisateurs actifs chaque semaine
• Développement – ordinateur portable ordinaire, n'importe quel OS, outils gratuits
• Moins de vingt concurrents (le 17 décembre ils ont ouvert les soumissions pour tous !)
• Stack technique – TypeScript ou Python, que tu connais déjà

Les maths sont simples : audience 80 fois plus grande, concurrents des centaines de fois moins nombreux, barrière à l'entrée plusieurs fois plus basse.

Ce n'est pas du hype. C'est une fenêtre d'opportunité qui s'est ouverte HIER (17 décembre) et qui se fermera dans 2-3 mois quand tout le monde affluera. Les premières applis approuvées commenceront à apparaître dans le catalogue en janvier 2026. En ce moment, il n'y a presque personne là-bas.

C'est quoi exactement ces ChatGPT Apps (sans blabla)

D'accord, sautons d'abord le jargon technique. En français simple.

Avant c'était comme ça : tu es dans ChatGPT, tu veux faire quelque chose – disons, réserver un hôtel. ChatGPT te donne des conseils, puis tu copies le nom de l'hôtel, tu ouvres Booking.com dans un nouvel onglet, tu cherches, tu réserves. Des tonnes de changements de fenêtres. Agaçant.

Maintenant c'est comme ça : tu tapes dans ChatGPT "Booking, trouve un hôtel à Madrid pour le week-end en dessous de 80 €" et directement dans le chat – une carte, liste d'options, photos, prix, tu peux cliquer et réserver. Tout là. Pas d'onglets.

Ça semble être un détail ? Ben, Apple semblait être un détail aussi – "pourquoi un écran tactile quand on a des boutons ?" Puis Nokia est mort.

ChatGPT Apps ce N'est PAS :

Clarifions tout de suite, pour qu'il n'y ait pas de confusion (j'étais confus au début aussi).

Ce ne sont PAS des Custom GPTs. Les Custom GPTs sont juste des chatbots avec des instructions. Tu leur dis "réponds comme un pirate" – ils répondent comme un pirate. C'est tout. Pas de widgets, pas d'interactivité.

Ce ne sont PAS des ChatGPT Plugins. OpenAI a fermé les Plugins en avril 2024. Ils étaient lents, maladroits, marchaient mal. Ils les ont enterrés, à juste titre.

Ce n'est PAS travailler avec l'API ChatGPT. L'API c'est quand tu fais ta propre appli et utilises ChatGPT dedans. Histoire complètement différente.

Alors c'est quoi ?

ChatGPT Apps sont des applications à part entière à l'intérieur de ChatGPT. Avec interface, boutons, cartes, maps, vidéo – ce que tu veux. Tu crées le backend (en TypeScript ou Python), tu fais l'UI (HTML/CSS/JS normal), et ChatGPT le rend directement dans le chat.

Exemple de workflow (étape par étape) :

1. Utilisateur : "Zillow, montre-moi des maisons à New York en dessous de 500k $"
2. ChatGPT comprend : besoin d'appeler l'appli Zillow
3. Envoie une requête à ton serveur (ça s'appelle un serveur MCP, mais on y reviendra)
4. Ton serveur : cherche des maisons, forme une réponse + HTML pour le widget
5. ChatGPT reçoit les données et affiche le widget avec carte, photos, descriptions
6. L'utilisateur clique sur une maison → voit les détails
7. Dit : "Enlève tout au-dessus de 400k $" → la liste se met à jour
8. A trouvé ce qu'il faut → clique "Ouvrir dans Zillow" → le site s'ouvre

Toute la magie c'est que ça se passe sans changement de contexte. La conversation avec ChatGPT ne s'interrompt pas. Tu dis juste ce que tu veux, et tout apparaît là.

Pourquoi on a besoin de ça ?

Question légitime. Voici un cas d'usage réel :

Avant : Je veux réserver une table au restaurant après avoir visité un musée.

1. Ouvre le site du musée, vérifie les horaires
2. Google les restaurants à proximité
3. Choisis-en un, ouvre OpenTable
4. Réserve
5. Ajoute un rappel au calendrier

Maintenant : "ChatGPT, réserve un restaurant près du Musée du Prado après sa fermeture."

• ChatGPT trouve l'heure de fermeture
• Trouve des restaurants à proximité
• Propose des options (avec cartes, menus, avis)
• Réserve une table
• Ajoute au calendrier

Une phrase au lieu de cinq étapes.

Voilà pourquoi on a besoin de ça.

Trois raisons pour lesquelles les développeurs se ruent déjà là-bas

1. Accès instantané à l'audience (c'est injuste, mais ça marche)

Le chemin habituel d'une startup :

• Idée → MVP → lancement
• Monte un site, configure les analytics
• SEO (des mois d'attente)
• Pubs payantes (argent, argent, argent)
• Appels à froid, emails
• Après un an : 1000 utilisateurs (si tu as de la chance)

Avec ChatGPT Apps :

Tu fais une appli. Tu la publies dans le Store. L'utilisateur écrit "Trouve-moi une recette de carbonara" – et si tu as une appli de recettes, ChatGPT lui-même suggère ton appli.

Tu ne cherches pas d'utilisateurs. ChatGPT te les amène.

C'est comme avoir le meilleur commercial du monde qui travaille 24/7 gratuitement et connaît personnellement les 800 millions d'utilisateurs.

Maintenant imagine que tu as trois concurrents. Pas trois mille. Trois. Dans certaines niches, il n'y a peut-être personne du tout.

2. Pas besoin de construire l'UI de zéro (mais tu devrais étudier les guidelines)

Tu sais combien de temps prend une UI correcte dans une appli ? Des mois. Responsive, compatibilité navigateurs, thèmes (clair/sombre), accessibilité. Plus version iOS séparée, Android séparée. Du boulot par-dessus la tête.

Avec ChatGPT Apps – ChatGPT rend l'UI pour toi. Tu fournis un template HTML, il l'intègre dans l'interface. Thèmes ? Automatique. Responsive ? Automatique. iOS/Android ? Marche partout, c'est du web.

Mais il y a un hic : OpenAI fournit des guidelines de design claires. Ce n'est pas "fais ce que tu veux". Il y a des recommandations pour les tailles de widgets, schémas de couleurs, typographie, espacements. Tout est clairement documenté.

La bonne nouvelle : suivre ces guidelines est plus facile que créer un design system from scratch. OpenAI a déjà réfléchi à la cohérence, l'accessibilité, les patterns UX. Tu appliques juste leurs standards.

Tu te concentres sur la logique, sur les données, sur ce qui rend ton appli utile. Pas sur faire qu'un bouton ait la même apparence sur différents appareils.

3. Avantage du premier arrivé (la fenêtre est ouverte MAINTENANT)

Écoute attentivement, parce que c'est la partie la plus importante de l'article.

17 décembre 2025 – hier – OpenAI a lancé l'App Directory et ouvert les soumissions pour tous les développeurs. Pas pour les partenaires, pas pour les corporations. Pour tous. Tu peux aller sur platform.openai.com maintenant et soumettre ton appli pour révision.

Ce qu'il y a maintenant :

• Spotify, Booking.com, Expedia (voyages)
• Canva, Figma (design)
• Zillow (immobilier)
• Coursera (éducation)
• AllTrails, Coupler, Daloopa, Coveo, Egnyte, Hex (outils d'entreprise)

Compte-les. Moins de vingt applis pour 800 millions d'utilisateurs. Le catalogue App Directory est pratiquement vide. Les sections Featured sont vides. Les algorithmes de recommandation sont juste en train d'être ajustés.

Les premières applis approuvées commenceront à apparaître en janvier 2026. Ça veut dire que tu as 2-3 semaines pour faire une appli de qualité et la soumettre pour révision. Et une chance d'être dans la première vague.

D'ici l'été 2026 il y aura :

• Des milliers de développeurs
• Des centaines de startups
• Des tonnes de copieurs
• Une concurrence féroce pour les places Featured
• Un algorithme de recommandation déjà entraîné sur des milliers d'applis

Mais ne t'inquiète pas. Ça ne veut pas dire qu'il sera trop tard en été. ChatGPT Apps n'est pas une fonctionnalité hype qui disparaîtra dans un an. C'est une plateforme fondamentale qui est là pour rester.

Analogie : L'App Store a été lancé en 2008, et de nouvelles applis à succès sortent encore aujourd'hui. TikTok a explosé le marché en 2018 – 10 ans après le lancement du store. Clubhouse valait des milliards en 2020.

ChatGPT Apps va croître et évoluer pendant des années. C'est juste que ceux qui entrent dans la première vague – dans les 2-3 prochains mois – obtiendront un maximum d'avantages : moins de concurrents, plus d'attention, premières positions dans les classements, réputation de pionniers, chance d'être Featured.

Tu peux entrer dans six mois aussi. Mais maintenant c'est une fenêtre d'opportunité avec un risque minimal et un rendement maximal. Le catalogue est vide. Les soumissions sont ouvertes. La concurrence est presque inexistante.

Dans un mois il y aura des centaines de soumissions. Dans trois mois – des milliers. Mais maintenant tu peux être l'un des vingt premiers.

Comment ça marche techniquement (sans jargon)

Okay, assez de marketing. Passons au vif du sujet – comment c'est construit sous le capot.

Diagramme simple

Utilisateur 
    ↓ écrit un prompt
ChatGPT UI (ce que tu vois)
    ↓ comprend quel outil est nécessaire
Apps SDK Runtime (moteur)
    ↓ envoie requête
Ton serveur MCP (ton code)
    ↓ traite, appelle des API
Ta base de données / services externes
    ↓ retourne données
Widget (HTML/CSS/JS dans iframe)
    ↓ affiche
L'utilisateur voit le résultat

En réalité, une requête ressemble à ça :

Utilisateur : "Spotify, crée une playlist pour courir le matin"

1. ChatGPT : Ok, c'est à propos de musique, besoin de l'outil create_playlist de Spotify
2. ChatGPT → Ton serveur : Requête POST avec paramètres {theme: "morning_run", duration: 30}
3. Ton serveur :

- Requête reçue

- API Spotify appelée

- Liste de morceaux compilée

- Réponse formée + HTML pour le widget

1. Ton serveur → ChatGPT : Voici tes données + template UI
2. ChatGPT : Rend le widget dans iframe (sandbox protégée)
3. Widget : Reçoit les données via l'API window.openai
4. Utilisateur : Voit la playlist, peut écouter, éditer

Le processus entier prend quelques secondes.

Protocole MCP – c'est quoi et pourquoi

MCP = Model Context Protocol. C'est un standard ouvert pour connecter l'IA à des outils et données externes.

Brève histoire :

• Novembre 2024 → Anthropic (créateurs de Claude) a annoncé MCP
• Mars 2025 → OpenAI a dit "ouais, on fait pareil"
• Décembre 2025 → MCP transféré à la Linux Foundation

Maintenant c'est un standard commun. Construis un serveur MCP une fois – il marche avec ChatGPT, avec Claude, avec VS Code, avec n'importe quel client IA.

Analogie : tu te souviens comment chaque téléphone avait son propre chargeur avant ? Nokia un, Samsung un autre, iPhone un troisième. Vraiment agaçant. Puis ils ont inventé l'USB-C – un port pour tous.

MCP c'est l'USB-C pour les applications IA.

Les trois piliers de MCP

MCP se compose de trois primitifs. Ça sonne effrayant, mais c'est en fait simple :

1. Tools (Outils)

Ce sont des fonctions que l'IA peut appeler. Par exemple :

• search_products — trouver des produits
• book_hotel — réserver un hôtel
• create_playlist — créer une playlist
• get_weather — obtenir la météo

Tu enregistres un outil, décris les paramètres (ce qu'il faut passer), et ChatGPT comprend automatiquement quand l'appeler.

2. Resources

Ce sont des sources de données ou templates UI. Par exemple :

• Fichier HTML avec un widget
• JSON avec données utilisateur
• Images, vidéos

Tu contrôles les Resources, pas l'IA. Tu décides quoi retourner et dans quel format.

3. Prompts

Templates réutilisables pour tâches courantes. Si tu as un scénario standard, tu peux le décrire une fois, et les utilisateurs l'utiliseront plus vite.

Honnêtement ? Les Prompts sont rarement utilisés. Tools et Resources – c'est ce qui compte.

Et la sécurité ?

Les widgets fonctionnent dans une iframe sandbox – un environnement isolé. Ils ne peuvent pas :

• Lire les cookies d'autres sites
• Exécuter du JavaScript arbitraire dans le contexte ChatGPT
• Accéder aux données d'autres utilisateurs

Toutes les requêtes passent par HTTPS. Les données en transit sont chiffrées TLS 1.2+. Stockage – AES-256. OpenAI a passé l'audit SOC 2 Type 2, conforme GDPR/CCPA.

En bref, la sécurité est solide. Pas besoin de réinventer la roue.

Construire ta première appli (maintenant)

Assez de théorie. Faisons une vraie appli. Maintenant. En 20-30 minutes.

Ce qu'on va construire : Todo List. Ouais, je sais, c'est un cliché. Mais c'est simple et clair. Construis un todo – comprends le principe – puis modélise des vaisseaux spatiaux si tu veux.

Ce dont tu as besoin

• Node.js (probablement déjà installé)
• N'importe quel éditeur de code
• Terminal
• ngrok (pour URL publique)

Tout gratuit, tout disponible.

Étape 1 : Créer le projet

mkdir my-first-chatgpt-app
cd my-first-chatgpt-app
npm init -y
npm install @modelcontextprotocol/sdk

package.json devrait ressembler à ça :

{
  "type": "module",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.20.2"
  }
}

> Note : Dans l'exemple, on utilise JSON Schema directement pour la validation des paramètres. Si tu veux une validation plus puissante, tu peux ajouter zod et l'utiliser dans le handler de l'outil.

Étape 2 : Écrire le serveur MCP

Crée un fichier server.js :

import { createServer } from "node:http";
import { readFileSync } from "node:fs";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

// HTML avec widget (on créera à l'étape suivante)
const widgetHtml = readFileSync("widget.html", "utf8");

// Notre "stockage" de tâches (en réalité ce serait une base de données)
let todos = [];
let nextId = 1;

function createTodoServer() {
  const server = new McpServer({ 
    name: "my-todo-app", 
    version: "1.0.0" 
  });

  // Enregistrer le widget UI comme Resource
  server.registerResource(
    "todo-widget",
    "ui://widget/todo.html",
    {},
    async () => ({
      contents: [{
        uri: "ui://widget/todo.html",
        mimeType: "text/html+skybridge",  // Important ! Ne marchera pas sans ça
        text: widgetHtml,
        _meta: { 
          "openai/widgetPrefersBorder": true  // Bordure autour du widget
        },
      }],
    })
  );

  // Enregistrer Tool pour ajouter des tâches
  server.registerTool(
    "add_todo",
    {
      title: "Ajouter une tâche",
      description: "Ajoute une nouvelle tâche à la liste",
      inputSchema: {
        type: "object",
        properties: {
          title: {
            type: "string",
            description: "Titre de la tâche"
          }
        },
        required: ["title"]
      },
      _meta: {
        "openai/outputTemplate": "ui://widget/todo.html",  // Quel widget afficher
        "openai/toolInvocation/invoking": "Ajout de la tâche...",  // Texte pendant le chargement
        "openai/toolInvocation/invoked": "Tâche ajoutée ✓",  // Texte quand c'est fait
      },
    },
    async ({ title }) => {
      // Créer la tâche
      const todo = { 
        id: `todo-${nextId++}`, 
        title, 
        completed: false 
      };
      todos.push(todo);

      // Retourner le résultat
      return {
        // Texte pour ChatGPT (quoi afficher dans le chat)
        content: [{ 
          type: "text", 
          text: `✅ Ajouté : "${title}"` 
        }],
        // Données pour le widget
        structuredContent: { 
          tasks: todos 
        },
      };
    }
  );

  return server;
}

// Serveur HTTP avec CORS (obligatoire !)
const port = 8787;
const httpServer = createServer(async (req, res) => {
  const url = new URL(req.url, `http://${req.headers.host}`);

  // CORS preflight (ChatGPT fait d'abord une requête OPTIONS)
  if (req.method === "OPTIONS" && url.pathname === "/mcp") {
    res.writeHead(204, {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
      "Access-Control-Allow-Headers": "content-type, mcp-session-id",
      "Access-Control-Expose-Headers": "Mcp-Session-Id",
    });
    res.end();
    return;
  }

  // Health check (pour vérifier que le serveur est vivant)
  if (req.method === "GET" && url.pathname === "/") {
    res.writeHead(200).end("✅ Serveur MCP en marche");
    return;
  }

  // Endpoint MCP (ChatGPT va cogner ici)
  if (url.pathname === "/mcp") {
    res.setHeader("Access-Control-Allow-Origin", "*");
    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");

    const server = createTodoServer();
    const transport = new StreamableHTTPServerTransport({
      sessionIdGenerator: undefined,
      enableJsonResponse: true,
    });

    // Quand la connexion se ferme, nettoyer
    res.on("close", () => {
      transport.close();
      server.close();
    });

    await server.connect(transport);
    await transport.handleRequest(req, res);
    return;
  }

  res.writeHead(404).end("Not Found");
});

httpServer.listen(port, () => {
  console.log(`🚀 Serveur en marche : http://localhost:${port}/mcp`);
});

Ça semble compliqué ? En fait il y a trois parties :

1. Enregistrement du widget (UI)
2. Enregistrement de l'outil (ce qu'il peut faire)
3. Serveur HTTP (pour que ChatGPT puisse nous atteindre)

Étape 3 : Faire le widget

Crée widget.html :

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="utf-8" />
  <title>Todo Widget</title>
  <style>
    * { box-sizing: border-box; }
    body { 
      margin: 0; 
      padding: 20px; 
      font-family: -apple-system, BlinkMacSystemFont, sans-serif;
      background: var(--bg, #f8f9fa);
    }
    .task-list { 
      display: flex; 
      flex-direction: column; 
      gap: 10px; 
    }
    .task { 
      padding: 15px; 
      border-radius: 8px; 
      background: white;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      display: flex;
      align-items: center;
      gap: 10px;
    }
    .task:hover { 
      box-shadow: 0 4px 8px rgba(0,0,0,0.15);
    }
    .task.completed { 
      opacity: 0.5; 
      text-decoration: line-through; 
    }
    .empty {
      text-align: center;
      padding: 40px;
      color: #999;
      font-style: italic;
    }
  </style>
</head>
<body>
  <div id="root"></div>
  
  <script type="module">
    // Obtenir les données de ChatGPT
    const toolOutput = window.openai?.toolOutput;
    const theme = window.openai?.theme;
    
    // Si thème sombre, changer le fond
    if (theme === 'dark') {
      document.documentElement.style.setProperty('--bg', '#1a1a1a');
    }
    
    // Rendre la liste de tâches
    function render(tasks) {
      const root = document.getElementById('root');
      
      if (!tasks || tasks.length === 0) {
        root.innerHTML = '<div class="empty">📝 Pas encore de tâches. Ajoute ta première !</div>';
        return;
      }
      
      root.innerHTML = `
        <div class="task-list">
          ${tasks.map(task => `
            <div class="task ${task.completed ? 'completed' : ''}">
              <span>${task.title}</span>
            </div>
          `).join('')}
        </div>
      `;
    }
    
    // Premier rendu
    render(toolOutput?.tasks || []);
    
    // Écouter les mises à jour (quand ChatGPT met à jour les données)
    window.addEventListener("openai:set_globals", (event) => {
      const newTasks = event.detail?.globals?.toolOutput?.tasks;
      if (newTasks) render(newTasks);
    });
  </script>
</body>
</html>

C'est du HTML normal. La magie est dans window.openai – c'est comme ça que ChatGPT nous passe les données.

Étape 4 : Exécuter localement

Ouvre deux terminaux.

Terminal 1 (démarrer le serveur) :

node server.js

Tu verras : 🚀 Serveur en marche : http://localhost:8787/mcp

Terminal 2 (tunnel public) :

ngrok http 8787

ngrok te donnera une URL publique du type https://abc123.ngrok.app. Copie-la.

Étape 5 : Connecter à ChatGPT

1. Ouvre ChatGPT
2. Settings → Apps & Connectors → Advanced settings
3. Active Developer Mode (nécessite Plus ou Pro)
4. Clique Create Connector
5. Entre l'URL : https://ton-url-ngrok.ngrok.app/mcp
6. Enregistre

Étape 6 : Teste !

Ouvre un nouveau chat et tape :

Ajouter une tâche : Acheter du lait

Si tout va bien – tu verras un widget avec la tâche !

Essaie encore :

Ajouter une tâche : Aller à la salle de sport
Ajouter une tâche : Appeler maman

Tu vois la liste de tâches directement dans le chat ? Félicitations, tu viens de créer ta première appli ChatGPT ! 🎉

Et après ?

C'est l'exemple le plus basique. Ensuite tu peux :

• Ajouter la suppression de tâches
• Faire des checkboxes pour marquer comme terminé
• Connecter une vraie base de données (PostgreSQL, MongoDB)
• Ajouter l'autorisation OAuth
• Déployer sur Vercel (gratuit)

Mais tu comprends le principe. Le reste c'est des détails.

Fonctionnalités avancées (quand le basique devient ennuyeux)

Okay, t'as fait une todo list. Maintenant tu veux quelque chose de plus sérieux. Voici ce que tu peux faire d'autre :

Autorisation OAuth

Si ton appli travaille avec les données personnelles des utilisateurs (comme les playlists Spotify ou Google Drive), tu as besoin d'autorisation.

ChatGPT supporte OAuth 2.1 avec PKCE. Ça sonne effrayant, mais ça marche simplement :

1. L'utilisateur appelle ton appli pour la première fois
2. ChatGPT affiche "Connecter le compte"
3. Redirige vers ton serveur d'autorisation
4. L'utilisateur accorde l'accès
5. Ton serveur retourne un token
6. ChatGPT sauvegarde le token et l'envoie avec chaque requête

Dans le code ça ressemble à ça :

server.registerTool(
  "get_user_playlists",
  {
    title: "Obtenir les playlists",
    _meta: {
      "openai/auth": [{ type: "oauth2" }]  // Nécessite autorisation
    }
  },
  async (args, context) => {
    // Vérifier le token
    const token = context.headers?.authorization?.replace('Bearer ', '');
    
    if (!token) {
      return {
        error: "Unauthorized",
        _meta: { 
          "mcp/www_authenticate": { error: "invalid_token" } 
        }
      };
    }
    
    // Obtenir les données
    const playlists = await fetchSpotifyPlaylists(token);
    return { content: [{ type: "text", text: JSON.stringify(playlists) }] };
  }
);

Les détails de configuration d'un serveur auth sont un sujet à part. En bref : tu as besoin d'un endpoint /authorize, endpoint /token, et métadonnées du serveur. Lis la doc, c'est expliqué là.

Widgets en plein écran

Parfois un widget dans le chat est trop petit. Comme pour une carte. Tu as besoin du plein écran.

// Dans le widget
await window.openai.requestDisplayMode({ mode: "fullscreen" });

Il y a trois modes :

• inline — widget normal dans le chat (par défaut)
• fullscreen — plein écran (pour cartes, graphiques)
• pip (picture-in-picture) — fenêtre flottante (pour vidéo, musique)

Change via window.openai.requestDisplayMode().

Agentic Commerce Protocol (ACP) – ventes directement dans ChatGPT

Tu veux vendre des produits via ChatGPT ? OpenAI et Stripe ont créé un standard ouvert pour ça – ACP.

Comment ça marche :

1. Tu as des produits (Product Feed en JSON/CSV/XML)
2. Utilisateur : "ChatGPT, commande-moi des baskets Nike Air Max, taille 42"
3. ChatGPT trouve le produit dans ton feed
4. Affiche la carte produit (photo, prix, description)
5. Utilisateur : "Acheter"
6. Instant Checkout – paiement via ton Payment Provider (Stripe/PayPal)
7. Tu reçois un webhook sur l'achat
8. Tu expédies le produit

Commission : OpenAI prend un petit pourcentage des ventes (chiffres exacts non divulgués).

Qui travaille déjà : Instacart (Instant Checkout complet), 1M+ marchands Shopify.

Ça marche vraiment. Les gens achètent directement dans le chat, sans aller sur le site.

Déploiement : Passage en production

Tout marche localement, mais les utilisateurs ont besoin d'un serveur stable. ngrok mourra dans une heure – pas une option.

Option 1 : Vercel (le plus simple)

Vercel supporte officiellement ChatGPT Apps. Il y a un tier gratuit, suffisant pour commencer.

npm i -g vercel
vercel login
vercel

C'est tout. Vercel va configurer HTTPS, configurer le CDN, te donner une URL stable.

Template prêt de Vercel :

vercel.com/templates/next.js/chatgpt-app-with-next-js

Option 2 : Railway / Fly.io / Render

Si tu as besoin de plus de contrôle (ton propre Docker, tes propres variables env, etc.) :

Railway :

railway login
railway link
railway up

Fly.io :

fly launch
fly deploy

Les trois plateformes sont gratuites pour commencer, puis tu paies pour les ressources. Pas cher.

Checklist production

Avant le lancement, vérifie :

✅ HTTPS — obligatoire, sinon ChatGPT ne se connectera pas

✅ CORS — autorise https://chatgpt.com

✅ Health check — / doit retourner 200

✅ Rate limiting — pour ne pas te faire DDoS

✅ Variables env — pas de secrets dans le code

✅ Logging — pour comprendre ce qui s'est cassé

✅ Monitoring — uptime, latence, erreurs

CORS minimal pour Express :

app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  res.header('Access-Control-Allow-Headers', 'content-type, mcp-session-id');
  next();
});

Ça suffit pour commencer.

ChatGPT App Directory : soumissions ouvertes MAINTENANT

La question la plus fréquente était : "Quand peut-on publier ?"

Réponse : Tu peux déjà. 17 décembre 2025 OpenAI a ouvert les soumissions pour tous les développeurs.

Statut au 18 décembre 2025 :

✅ App Directory lancé — https://chatgpt.com/apps

✅ Soumissions ouvertes — via platform.openai.com

✅ Apps SDK en BETA — tout développeur peut l'utiliser

✅ Premières applis approuvées — commenceront à apparaître en janvier 2026

Qui est déjà là :

• Spotify — playlists, recommandations
• Booking.com, Expedia — voyages
• Canva, Figma — design et présentations
• Zillow — immobilier américain
• Coursera — cours éducatifs
• AllTrails — sentiers et itinéraires
• Coupler, Daloopa, Coveo, Egnyte, Hex — outils d'entreprise

Total moins de 20 applis. C'est TOUT. Le catalogue est presque vide.

Comment soumettre ton appli (étape par étape)

Étape 1 : Prépare ton appli

Avant de soumettre, assure-toi que :

• Appli testée en Developer Mode
• Serveur tourne sur HTTPS (obligatoire !)
• Suit les App Submission Guidelines
• A une Privacy Policy et Terms of Service
• L'UI respecte les guidelines OpenAI

Étape 2 : Va sur OpenAI Developer Platform

Va sur platform.openai.com → section "ChatGPT Apps" → "Submit App".

Étape 3 : Remplis le formulaire de soumission

Tu devras fournir :

Informations sur l'appli :

• Nom de l'appli (unique, clair)
• Description (ce qu'elle fait, pour qui c'est utile)
• Catégorie (productivity, travel, education, entertainment, etc.)
• Icône et bannière pour le catalogue (PNG, tailles spécifiques)

Détails MCP :

• URL de ton serveur MCP (doit être accessible via HTTPS)
• Liste des outils fournis par le serveur
• Paramètres d'authentification (si OAuth nécessaire)
• Endpoints des widgets

Guidelines de test :

• Scénarios de test pour les relecteurs (comment vérifier que tout marche)
• Exemples de prompts qui déclenchent ton appli
• Comportement attendu

Captures d'écran / Aperçus UI :

• Captures d'écran des widgets dans ChatGPT
• Démonstration des fonctions principales
• Montre comment l'appli apparaît en thèmes clair/sombre

Disponibilité par pays :

• Dans quels pays l'appli sera disponible
• Restrictions régionales (s'il y en a)

Privacy Policy :

• Obligatoire pour toutes les applis
• Quelles données tu collectes, comment tu les utilises, comment tu les stockes
• Lien vers le texte complet de la politique

Release Notes :

• Quoi de neuf dans cette version
• Limitations ou bugs connus
• Plans futurs (optionnel)

Étape 4 : Soumets pour révision

Clique "Submit". OpenAI commence à vérifier :

• Révision technique (est-ce que le serveur marche, y a-t-il des bugs)
• Révision sécurité (y a-t-il des vulnérabilités, les données sont-elles correctement traitées)
• Révision politique (conforme aux Usage Policies)
• Révision UX (est-ce pratique à utiliser)

Timeline de révision : de quelques jours à quelques semaines (dépend de la complexité).

Étape 5 : Reçois la réponse

Soit Approuvé — félicitations, l'appli va dans le catalogue !

Soit Changements demandés — besoin de corriger les problèmes et resoumettre.

Après approbation, ton appli apparaît dans l'App Directory, et 800 millions d'utilisateurs peuvent la trouver.

Exigences pour l'approbation

Pour passer la révision, l'appli doit :

✅ Se conformer aux Usage Policies OpenAI

✅ Être appropriée pour tous les publics (pas de contenu adulte, violence, discours haineux)

✅ Ne demander que les données nécessaires (principe du moindre privilège)

✅ Avoir un endpoint HTTPS fonctionnel (HTTP ne marchera pas)

✅ Fournir une Privacy Policy claire

✅ Suivre les UI Guidelines (cohérence du design, accessibilité)

✅ Ne pas violer les Terms of Service de services tiers (si intégration avec eux)

Rejet automatique si :

• Pas de HTTPS
• Pas de Privacy Policy
• Demande de données non nécessaires pour la fonctionnalité (ex. localisation si tu ne l'utilises pas)
• UI non responsive ou cassée
• Appli plante avec des erreurs

Que faire après approbation

Ton appli apparaît dans le catalogue – les utilisateurs peuvent la trouver via la recherche ou la section Featured.

Comment les utilisateurs te trouveront :

1. Recherche dans le catalogue — recherche par mots-clés
2. @mention — tape dans le chat @ton_appli fais quelque chose
3. Recommandations — ChatGPT lui-même suggère ton appli quand il voit une requête pertinente
4. Featured — les meilleures applis entrent dans les recommandées

Liens profonds :

Tu peux partager des liens directs vers ton appli :

https://chatgpt.com/apps/ton-appli

Poste sur les réseaux sociaux, sur ton site, dans la newsletter – les gens cliquent et atterrissent directement dans ton appli dans ChatGPT.

• Contacts support
• Certification sécurité (si tu travailles avec de l'argent)

Monétisation – peut-on vraiment gagner de l'argent ?

La question à un million (littéralement).

Options de revenus :

Instant Checkout marche déjà. Instacart vend des produits alimentaires directement dans ChatGPT, OpenAI prend une commission (taille non divulguée, mais ils disent "raisonnable").

Subscription sera lancé en Q1-Q2 2026. Comme l'App Store – les utilisateurs paient pour l'appli, OpenAI prend ~30% (probablement).

Combien peux-tu gagner ?

Personne ne sait. Le Store n'est pas ouvert, il n'y a pas de statistiques. Mais on peut regarder l'App Store :

• Top 1% des applis : $10K-100K+/mois
• Top 10% : $1K-10K/mois
• Le reste : $0-1K/mois

ChatGPT Apps a un potentiel plus élevé parce que :

1. L'IA elle-même recommande les applis (discovery gratuit)
2. La conversion est plus élevée (tout dans le chat, pas de changements)
3. Instant Checkout réduit la friction

Mais pour l'instant – incertitude. Les premiers vont expérimenter.

Pour qui c'est (discussion honnête)

Tout le monde ne devrait pas se précipiter sur ChatGPT Apps. Soyons honnêtes.

✅ C'est pour toi si :

• Tu sais coder en TypeScript ou Python
• Tu comprends REST API, HTTP, JSON
• Tu as une idée d'appli pour un large public
• Tu es prêt à apprendre et expérimenter
• Tu n'as pas peur des changements (SDK en preview, tout évolue)
• Tu veux entrer dans une nouvelle industrie au début

❌ NE commence PAS si :

• Tu es un débutant complet en programmation (apprends d'abord les bases !)
• Tu t'attends à un profit instantané sans travail
• Tu as besoin d'un revenu stable maintenant (pour l'instant tu ne peux que faire un lien vers ton site pour les achats)
• Tu fais un produit B2B étroit (ChatGPT est pour le marché de masse)
• Tu n'es pas prêt pour que la technologie change

Vrais salaires pour développeurs IA

Si tu ne crées pas ta propre appli mais travailles dans une entreprise :

USA (2025) :

• Junior AI Developer : $95K-$130K/an
• Mid AI Engineer : $161K-$220K/an
• Senior AI Engineer : $301K-$440K/an
• AI Research Scientist : $500K-$893K/an

Travail à distance par région :

• Europe de l'Ouest : €60K-€120K/an
• Europe de l'Est : $35K-$80K/an
• Inde : $15K-$45K/an
• Chine : $25K-$70K/an
• Amérique du Sud : $30K-$65K/an

Freelance (global) : $35-$116/heure (moyenne $65-75)

Sources : levels.fyi, Glassdoor, AngelList (décembre 2025)

La demande pour développeurs IA croît de 10-20% annuellement. Et va continuer à croître.

Les vrais défis de création des ChatGPT Apps

Okay, je t'ai dit tout l'article comme c'est cool et simple. Mais soyons honnêtes – tout ne se passe pas sans accroc.

Il y a de vrais défis auxquels les développeurs font face :

1. Changement de paradigme

C'est la partie la plus difficile. Tu es habitué à écrire des applis normales : l'utilisateur clique sur un bouton → le code s'exécute → le résultat s'affiche. Tout prévisible.

Avec ChatGPT Apps c'est différent :

• L'IA décide quand appeler ton outil
• L'utilisateur parle en langage naturel, ne clique pas sur l'UI
• Ton appli est un outil dans les mains de l'IA, pas une logique directe

Tu dois apprendre à penser comme un ingénieur IA, pas comme un développeur web classique. C'est comme passer de la programmation procédurale à la fonctionnelle – la technique semble familière, mais l'approche est différente.

2. Protocole MCP – nouveau standard

MCP vient d'apparaître, il y a peu de documentation, les best practices se forment encore. Tu ne peux pas googler "comment faire X dans MCP" – Stack Overflow est vide.

Tu dois lire la doc officielle (qui est parfois incomplète), étudier les exemples d'OpenAI, expérimenter.

3. Le debugging est plus dur que dans les applis web normales

Dans une appli normale tu vois la requête → regardes les logs → comprends ce qui s'est cassé.

Dans ChatGPT Apps :

• L'IA peut mal interpréter le prompt
• L'outil peut être appelé quand tu ne t'y attends pas
• Le widget rend dans une iframe sandbox – DevTools n'aide pas toujours
• Les erreurs peuvent être à trois niveaux : IA, transport MCP, ton code

Tu as besoin de nouvelles compétences de debugging.

4. OAuth et sécurité – haute responsabilité

Si ton appli travaille avec des données personnelles, tu as besoin d'OAuth. Mais ce n'est pas juste "installe une bibliothèque et ça marche".

Tu dois :

• Configurer un serveur d'autorisation
• Implémenter le flux PKCE
• Valider les tokens à chaque requête
• Assurer un stockage sécurisé des secrets
• Passer la révision sécurité d'OpenAI

Une erreur – et fuite de données utilisateurs. Sérieusement.

5. Déploiement production – pas juste "uploade sur un hébergement"

HTTPS est obligatoire. CORS nécessaire. SSE/Streaming HTTP doit marcher. Health checks. Rate limiting. Monitoring. Logging sans fuite de données sensibles.

Pour un développeur junior ça peut être écrasant.

6. Concurrence avec les gros joueurs

Quand le Store s'ouvrira, pas que les devs indie vont entrer. Spotify, Booking, Canva – ce sont de grandes entreprises avec de grandes équipes.

Comment concurrencer avec eux ? Tu as besoin d'une stratégie claire, focus sur une niche, compréhension du marché.

7. Écosystème qui change vite

Apps SDK est en preview. Des fonctionnalités sont ajoutées chaque semaine. Ce qui marchait il y a un mois peut casser après une mise à jour.

Tu dois être prêt à t'adapter rapidement.

C'est pourquoi tu as besoin d'un cours fondamental, pas juste un "tutoriel de 30 minutes".

Formation : cours de CodeGym

Nous chez CodeGym comprenons ces défis. Et c'est exactement pourquoi nous créons pas juste "bases ChatGPT Apps en une demi-heure", mais un cours complet de niveau production qui prépare au vrai développement.

Ce que nous faisons différemment

1. Changement graduel de paradigme

Le cours commence par le développement web classique, puis passe doucement à une approche AI-first. Tu ne sautes pas dans l'eau froide – tu y vas étape par étape.

2. Plongée profonde dans MCP

On ne dit pas juste "voilà comment MCP marche". On décortique :

• Architecture interne du protocole
• Comment l'IA décide d'appeler un outil
• Optimisation des descriptions d'outils pour une me