DEV Community: Antoine Laurent

Facturation GitHub Copilot : Ce que les équipes API doivent savoir

Antoine Laurent — Wed, 29 Apr 2026 07:13:10 +0000

Le modèle de facturation de GitHub Copilot a changé plusieurs fois récemment. Depuis ce mois-ci, la révision de code Copilot sur les pull requests consomme des minutes GitHub Actions du compte de facturation propriétaire du dépôt. Avec le quota de requêtes premium introduit le trimestre dernier, les équipes API doivent suivre trois métriques en parallèle : licences Copilot, requêtes premium et minutes Actions. Voici comment les mesurer, estimer leur impact et ajuster vos workflows CI avant de découvrir la facture.

Essayez Apidog aujourd’hui

Nous terminerons par un workflow avec Apidog pour regrouper spécification API, tests de contrat et révision IA dans un flux cohérent, au lieu de les disperser entre plusieurs tableaux de bord de facturation.

Si vous estimez aussi le coût des API de modèles utilisées directement par votre équipe, consultez les guides sur la tarification de GPT-5.5 et la tarification de DeepSeek V4.

En bref

Copilot repose désormais sur trois indicateurs : licence par siège, requêtes premium et minutes GitHub Actions pour la révision de code.
La révision de code Copilot sur les PR s’exécute comme une action GitHub en arrière-plan.
Les dépôts API consomment souvent plus que la moyenne : spécification, clients générés, handlers et tests augmentent la taille des diffs.
Les requêtes premium concernent surtout les usages agentiques : Workspace, mode agent, Espaces Copilot et certains choix de modèles.
Avant le prochain cycle de facturation, définissez des limites de dépenses et suivez les minutes Actions par dépôt API actif.

Les trois indicateurs à suivre

Copilot n’est plus une seule ligne de coût. Pour prévoir la facture, séparez les trois métriques suivantes.

1. Licence par siège

C’est le coût fixe.

Copilot Business : 10 $ par utilisateur et par mois
Copilot Enterprise : 19 $ par utilisateur et par mois

Ce forfait couvre notamment :

le chat ;
les complétions en ligne ;
les suggestions multi-lignes ;
les intégrations IDE ;
l’accès au pool de modèles standard.

Action recommandée : auditez les sièges une fois par trimestre et retirez ceux des utilisateurs inactifs.

coût_sièges_business = utilisateurs_actifs × 10
coût_sièges_enterprise = utilisateurs_actifs × 19

2. Requêtes premium

Les requêtes premium s’appliquent aux fonctionnalités plus coûteuses : mode agent, Workspace, Espaces Copilot ou sélection de modèles au-delà du modèle par défaut.

Tarifs indicatifs actuels :

Fonctionnalité	Coût en requêtes premium
Chat avec modèle par défaut	Gratuit pour les niveaux payants
Complétions en ligne	Gratuit pour les niveaux payants
Mode agent, modèle par défaut	1 par requête
Workspace, modèle par défaut	1 par requête
Sélection de Claude Sonnet 4.5	Multiplicateur 1,5x
Sélection de GPT-5.5	Multiplicateur 2x
Sélection de GPT-5.5 Pro	Multiplicateur 6x
Requête Espaces Copilot	1 par requête

Chaque siège inclut un quota mensuel :

Business : 300 requêtes premium par siège
Enterprise : 1 000 requêtes premium par siège

Les dépassements sont facturés 0,04 $ par requête, jusqu’à la limite de dépenses définie pour l’organisation.

Pour une équipe API, les requêtes qui montent vite sont les tâches comme :

Régénère le client OpenAPI.
Écris un test de contrat pour ce nouvel endpoint.
Refactorise ce handler et adapte les tests.

Une seule instruction peut entraîner plusieurs étapes internes et donc plusieurs requêtes premium.

3. Minutes GitHub Actions pour la révision de code

La nouveauté importante : lorsqu’une pull request déclenche une révision Copilot, celle-ci s’exécute comme une action GitHub. Les minutes consommées sont déduites du quota GitHub Actions habituel de l’organisation.

À retenir :

Ces minutes utilisent le même quota que votre CI.
Ce n’est pas un quota séparé.
Les dépôts privés consomment des minutes Actions.
Les dépôts publics bénéficient d’un traitement différent, car les Actions y sont gratuites.

Une révision Copilot typique sur une PR API consomme environ 2 à 6 minutes Actions. Une grosse PR avec beaucoup de fichiers et de contexte peut atteindre environ 15 minutes.

minutes_révision = nombre_pr_mensuelles × minutes_moyennes_par_révision

Pourquoi les dépôts API coûtent souvent plus cher

Les dépôts API ont plusieurs caractéristiques qui augmentent le coût des révisions IA.

1. Les pull requests touchent plus de fichiers

Une modification API typique peut inclure :

openapi.yaml ou une autre spécification ;
des clients générés ;
un handler serveur ;
des tests unitaires ;
des tests de contrat ;
de la documentation.

Plus la diff est large, plus la révision prend du temps.

2. Le code généré augmente le volume à analyser

Même si les clients générés ne changent pas la logique métier, Copilot peut les lire si vous les incluez dans la PR.

Exemples de dossiers à filtrer si possible :

generated/
sdk/
clients/
dist/

3. Plusieurs outils se déclenchent sur la même PR

Une PR API peut déclencher :

Copilot Review ;
CodeQL ;
Snyk ;
un scanner interne ;
une suite de tests de contrat ;
une génération de documentation.

Chaque outil a son propre coût ou sa propre consommation de minutes.

Exemple d’impact :

50 PR/mois × 4 minutes de révision = 200 minutes Actions/mois

Sur un plan GitHub Team avec 3 000 minutes Linux incluses, un seul dépôt API peut consommer environ 7 % du quota mensuel uniquement pour la révision Copilot.

Estimer votre facture mensuelle

Construisez l’estimation en trois blocs : sièges, requêtes premium, minutes Actions.

Étape 1 : calculer les sièges

sièges = utilisateurs_actifs × prix_du_siège

Exemple :

10 développeurs × 19 $ = 190 $/mois

Étape 2 : calculer les requêtes premium

Estimez l’usage par développeur :

utilisateur léger, chat principalement : environ 150 requêtes/mois ;
utilisateur intensif de Workspace ou mode agent : environ 600 à 800 requêtes/mois.

Pour Copilot Business :

dépassement_premium = max(0, requêtes_utilisées - 300_par_siège) × 0,04 $

Pour Copilot Enterprise :

dépassement_premium = max(0, requêtes_utilisées - 1000_par_siège) × 0,04 $

Action recommandée : définissez une limite de dépenses au niveau de l’organisation. Ne laissez pas le dépassement illimité si vous n’avez pas encore de métriques de référence.

Étape 3 : calculer les minutes Actions de révision

Utilisez votre volume mensuel de PR et une moyenne prudente de 4 minutes par révision API.

minutes_révision = prs_par_mois × 4

Puis estimez le dépassement si le quota Actions restant est insuffisant :

dépassement_révision = max(0, minutes_révision - quota_actions_restant) × coût_par_minute

Pour les dépôts privés Linux, le coût dépend du barème GitHub Actions applicable à votre organisation.

Exemple

Équipe de 10 développeurs Copilot Enterprise, 200 PR/mois :

Sièges : 10 × 19 $ = 190 $
Révisions : 200 × 4 min = 800 minutes Actions
Dépassement premium estimé : 40 $

Si les 800 minutes restent dans le quota Actions Enterprise, le surcoût Actions est nul. Le coût principal reste donc les sièges et les éventuels dépassements premium.

Adapter votre pipeline CI

Voici trois changements concrets pour réduire la consommation sans désactiver totalement la révision IA.

1. Ignorer les PR de bots

Les mises à jour Dependabot ou Renovate n’ont pas toujours besoin d’une révision IA.

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  copilot-review:
    if: github.actor != 'dependabot[bot]' && github.actor != 'renovate[bot]'
    runs-on: ubuntu-latest
    steps:
      - uses: github/copilot-review@v1

2. Restreindre la révision aux chemins utiles

Pour un dépôt API, ciblez les fichiers à forte valeur :

on:
  pull_request:
    paths:
      - 'apis/**/*.yaml'
      - 'cmd/**'
      - 'internal/**'
      - 'tests/**'

Évitez d’inclure les clients générés si la révision n’y apporte pas de valeur.

Exemples de chemins à exclure ou à ne pas déclencher :

clients/**
generated/**
sdk/**
dist/**

3. Échouer rapidement avant la révision Copilot

Placez les validations rapides avant la révision IA :

lint de la spécification ;
validation OpenAPI ;
tests de contrat ;
révision Copilot uniquement si les étapes précédentes passent.

Exemple de structure :

jobs:
  contract-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run contract tests
        run: apidog-cli test

  copilot-review:
    needs: contract-tests
    runs-on: ubuntu-latest
    steps:
      - uses: github/copilot-review@v1

L’objectif : éviter de consommer des minutes de révision sur une PR qui échoue déjà sur un contrat API.

Gouvernance : quatre contrôles à mettre en place

1. Définir une limite de dépenses

Configurez-la au niveau de l’organisation. Choisissez un plafond acceptable et réduisez-le légèrement pour garder une marge de sécurité.

2. Activer les alertes de requêtes premium

Surveillez les seuils :

50 % ;
75 % ;
90 %.

Redirigez les alertes vers Slack, Teams ou votre outil d’incident pour éviter qu’elles restent dans une boîte mail.

3. Utiliser une politique de déclenchement

Deux modèles fonctionnent bien :

Révision sur toutes les PR importantes :

on:
  pull_request:
    paths:
      - 'apis/**'
      - 'internal/**'
      - 'tests/**'

Révision uniquement sur label :

on:
  pull_request:
    types: [labeled, synchronize]

jobs:
  copilot-review:
    if: contains(github.event.pull_request.labels.*.name, 'review-please')
    runs-on: ubuntu-latest
    steps:
      - uses: github/copilot-review@v1

Le modèle par label réduit généralement le nombre de révisions inutiles.

4. Activer les fonctionnalités par équipe

N’activez pas toutes les fonctionnalités Copilot Enterprise à l’échelle de l’organisation sans suivi. Déployez-les équipe par équipe, puis comparez l’usage avant/après.

Où placer Apidog dans le workflow

Apidog ne remplace pas Copilot. Il sert à centraliser les spécifications, exemples, mocks et tests de contrat afin que la révision IA intervienne plus tard, sur des PR déjà validées.

Workflow recommandé :

La spécification API et les exemples de requêtes sont maintenus dans Apidog.
Les tests de contrat s’exécutent contre le serveur de mock Apidog plutôt que contre l’API live.
La CI lance apidog-cli pour valider les contrats.
La révision Copilot ne s’exécute que si les validations rapides réussissent.
Copilot se concentre sur la logique serveur, la couverture de tests et les changements de comportement.

Exemple :

jobs:
  api-contract:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Validate API contract
        run: apidog-cli test

  copilot-review:
    needs: api-contract
    if: success()
    runs-on: ubuntu-latest
    steps:
      - uses: github/copilot-review@v1

Cette séquence est importante : la révision Copilot est plus coûteuse qu’une validation de contrat rapide. Faites échouer tôt les PR invalides.

Pour approfondir le workflow de mock et de test, consultez le guide de test API sans Postman. Le guide API DeepSeek V4 montre une application similaire sur une API de modèle.

Que surveiller au prochain cycle de facturation

Jours 1 à 7

L’utilisation premium semble souvent normale. La plupart des utilisateurs restent sous le quota inclus.

Jours 14 à 21

Les utilisateurs intensifs dépassent le quota. Si une limite de dépenses existe, certaines requêtes peuvent échouer. Sans limite, la facture augmente.

Jours 28 à 30

Les minutes Actions liées à la révision Copilot deviennent visibles. Comparez avec le mois précédent pour identifier l’impact réel.

Actions à effectuer en fin de mois :

supprimer les sièges inactifs ;
déplacer les gros utilisateurs vers le niveau adapté ;
resserrer les filtres de chemins ;
exclure les PR de bots ;
exporter les données de facturation GitHub en CSV.

Erreurs courantes

1. Aucun plafond de dépenses

Une boucle agentique ou un usage intensif non surveillé peut générer des dépassements. Définissez toujours une limite.

2. Révision activée sur tous les dépôts

Activez Copilot Review uniquement là où la valeur est claire : services critiques, dépôts API actifs, zones à fort risque.

3. Clients générés inclus dans la révision

Filtrez les dossiers générés. Ils augmentent la diff sans améliorer proportionnellement la qualité de la révision.

4. PR de bots révisées

Excluez au minimum :

dependabot[bot]
renovate[bot]

Ajoutez aussi vos bots internes de génération ou de mise à jour.

5. Pas de métriques de référence

Avant de modifier le workflow, exportez les données actuelles :

nombre de PR/mois ;
minutes Actions/mois ;
minutes Actions par dépôt ;
requêtes premium par utilisateur ;
coût mensuel total.

Sans baseline, vous ne pourrez pas mesurer les économies.

FAQ

Le prix du siège est-il toujours de 10 $ par utilisateur ?

Copilot Business est à 10 $ par utilisateur et par mois. Copilot Enterprise est à 19 $ par utilisateur et par mois. Copilot Pro pour les particuliers est à 10 $ par mois. Le niveau choisi détermine aussi le quota de requêtes premium inclus.

Les complétions en ligne sont-elles désormais mesurées ?

Non. Le chat avec modèle par défaut et les complétions en ligne ne sont pas mesurés pour les niveaux payants. Les requêtes premium concernent les fonctionnalités plus coûteuses et certains choix de modèles.

Que se passe-t-il quand le quota premium est épuisé ?

Par défaut, les requêtes peuvent échouer avec une erreur de quota. Vous pouvez autoriser des dépassements à 0,04 $ par requête jusqu’à la limite de dépenses définie.

Les minutes Actions de révision sont-elles facturées séparément ?

Non. Elles consomment le même pool de minutes Actions que le reste de votre CI.

Peut-on désactiver complètement Copilot Review ?

Oui. Un administrateur d’organisation peut désactiver la fonctionnalité via les politiques applicables aux dépôts ou aux équipes.

Copilot Review fonctionne-t-il sur des spécifications API privées ?

Oui. Dans ce cas, les dépôts privés consomment des minutes Actions. Le réviseur peut lire les fichiers de spécification et les handlers comme les autres sources du dépôt.

Copilot Review consomme-t-il aussi des requêtes premium ?

Actuellement, la révision consomme des minutes Actions. Le modèle utilisé par le réviseur fait partie de la plateforme Copilot et n’est pas facturé séparément comme une requête premium. Ce point peut évoluer : vérifiez régulièrement le changelog GitHub.

Pour les équipes qui combinent Copilot Review et appels directs à des API de modèles dans la CI, le guide Codex gratuit GPT-5.5 couvre la partie coût par jeton. Apidog permet de garder la couche mock et contrats en amont, afin de réserver la révision IA aux PR qui passent d’abord les vérifications rapides.

Comment utiliser l'API Zuplo ?

Antoine Laurent — Mon, 27 Apr 2026 08:57:29 +0000

Si vous avez lu des informations sur Zuplo et souhaitez passer à la pratique, ce guide est pour vous. La plateforme Zuplo est rapide à prendre en main, mais sa documentation est éparpillée entre le portail, la CLI et le centre d'apprentissage. Ce tutoriel rassemble tout pour vous permettre de créer un projet, exposer une route, ajouter une authentification par clé API, limiter le débit, écrire une politique TypeScript personnalisée, déployer en périphérie et tout tester avec Apidog.

Essayez Apidog dès aujourd'hui

À la fin, vous disposerez d'une passerelle API opérationnelle devant votre backend, avec authentification, limitation de débit, portail développeur auto-généré et workflow Git compatible CI. Comptez environ trente minutes pour tout mettre en place.

Si vous hésitez sur le choix de Zuplo, commencez par notre article complémentaire : Qu'est-ce que la passerelle API Zuplo. Pour les cas particuliers non couverts ici, la documentation Zuplo est complète.

En bref

Inscrivez-vous sur portal.zuplo.com ou créez un projet local avec npm create zuplo.
Définissez vos routes dans config/routes.oas.json et proxifiez-les vers votre backend avec le handler URL Forward.
Ajoutez des politiques entrantes (authentification par clé API, limitation de débit, validation de schéma) dans le fichier de route ou via le Route Designer.
Écrivez des politiques personnalisées en TypeScript dans modules/ avec accès typé aux requêtes et au contexte.
Déployez via Git : chaque branche génère un environnement de prévisualisation ; fusionnez pour passer en production sur plus de 300 edge locations.
Testez chaque route avec Apidog avant la promotion en prod.
Tarification : gratuit jusqu’à 100 000 requêtes/mois, plan Builder à 25 $/mois.

Prérequis

Avant de commencer, préparez :

Un compte Zuplo.
Une API d’origine à protéger. Si vous n’en avez pas, utilisez https://echo.zuplo.io (retourne tout ce que vous lui envoyez).
Node.js 18+ pour la CLI.

Pour le développement local, utilisez un éditeur comme VS Code (avec l’extension TypeScript). Associez-le à l’extension Apidog VS Code pour envoyer des requêtes directement depuis l’éditeur.

Étape 1 : Créez votre projet Zuplo

Option A : Portail

Connectez-vous sur portal.zuplo.com.
Cliquez sur « Nouveau Projet » et nommez-le (ex : acme-gateway).
Choisissez « Projet vide ».
L’onglet Code présente l’arborescence de départ.

Le projet est lié par défaut à un dépôt Git géré, mais vous pouvez connecter votre propre dépôt GitHub, GitLab, Bitbucket ou Azure DevOps dans les paramètres.

Option B : CLI

Générez la structure localement et commencez immédiatement en mode git.

npm create zuplo@latest -- --name acme-gateway
cd acme-gateway
npm install
npm run dev

Le serveur local écoute sur le port 9000 et le Route Designer local sur http://localhost:9100. Les modifications sont rechargées à chaud.

Pour lier votre projet local à Zuplo :

npx zuplo link

Sélectionnez le compte et l’environnement. Ensuite, npx zuplo deploy déploie la branche git courante.

Étape 2 : Définissez votre première route

Ouvrez config/routes.oas.json (OpenAPI 3 avec extensions Zuplo). Exemple pour transférer GET /v1/products vers votre backend :

{
  "openapi": "3.1.0",
  "info": { "title": "Passerelle Acme", "version": "1.0.0" },
  "paths": {
    "/v1/products": {
      "get": {
        "summary": "Lister les produits",
        "operationId": "list-products",
        "x-zuplo-route": {
          "corsPolicy": "anything-goes",
          "handler": {
            "export": "urlForwardHandler",
            "module": "$import(@zuplo/runtime)",
            "options": {
              "baseUrl": "${env.ORIGIN_URL}"
            }
          },
          "policies": { "inbound": [] }
        },
        "responses": {
          "200": { "description": "Succès" }
        }
      }
    }
  }
}

L’extension x-zuplo-route configure le handler (ici urlForwardHandler) et les politiques. La variable ${env.ORIGIN_URL} permet de cibler différents backends selon l’environnement.

Définissez ORIGIN_URL dans les paramètres du portail ou dans config/.env localement. Utilisez https://echo.zuplo.io pour commencer.

Testez sur http://localhost:9000/v1/products : vous recevez un echo du backend.

Étape 3 : Ajoutez l’authentification par clé API

Activez la politique dans votre route :

"policies": {
  "inbound": ["api-key-auth"]
}

Ajoutez la définition dans config/policies.json :

{
  "name": "api-key-auth",
  "policyType": "api-key-inbound",
  "handler": {
    "export": "ApiKeyInboundPolicy",
    "module": "$import(@zuplo/runtime)",
    "options": {
      "allowUnauthenticatedRequests": false
    }
  }
}

Créez un consommateur via Services > Service de clés API :

Cliquez sur « Créer un consommateur ».
Définissez un identifiant (ex : acme-customer-1).
Ajoutez l’e-mail du gestionnaire.
Copiez la clé API générée.

Testez :

curl -i https://YOUR-PROJECT.zuplo.app/v1/products
# HTTP/2 401

curl -i https://YOUR-PROJECT.zuplo.app/v1/products \
  -H "Authorization: Bearer YOUR_API_KEY"
# HTTP/2 200

Pour des tests plus avancés, importez la spec OpenAPI dans Apidog, ajoutez un header global Authorization: Bearer {{api_key}} et reliez api_key à une variable d’environnement.

Étape 4 : Limitez le débit de la route

Ajoutez la limitation de débit après l’authentification :

"policies": {
  "inbound": ["api-key-auth", "rate-limit-by-key"]
}

Dans config/policies.json :

{
  "name": "rate-limit-by-key",
  "policyType": "rate-limit-inbound",
  "handler": {
    "export": "RateLimitInboundPolicy",
    "module": "$import(@zuplo/runtime)",
    "options": {
      "rateLimitBy": "sub",
      "requestsAllowed": 60,
      "timeWindowMinutes": 1
    }
  }
}

rateLimitBy: "sub" applique la limite par client authentifié (60 requêtes/min). Pour une régulation par IP, utilisez "ip".

Testez :

for i in {1..70}; do
  curl -s -o /dev/null -w "%{http_code}\n" \
    https://YOUR-PROJECT.zuplo.app/v1/products \
    -H "Authorization: Bearer YOUR_API_KEY"
done | sort | uniq -c

Vous verrez 60 réponses 200 et 10 réponses 429.

Étape 5 : Validez les charges utiles des requêtes

Pour un endpoint POST, la validation est automatique si le schéma OpenAPI est renseigné.

Exemple de route avec schéma :

"/v1/products": {
  "post": {
    "summary": "Créer un produit",
    "operationId": "create-product",
    "requestBody": {
      "required": true,
      "content": {
        "application/json": {
          "schema": {
            "type": "object",
            "required": ["name", "priceCents"],
            "properties": {
              "name": { "type": "string", "minLength": 1 },
              "priceCents": { "type": "integer", "minimum": 1 },
              "category": { "type": "string", "enum": ["food", "drink"] }
            }
          }
        }
      }
    },
    "x-zuplo-route": {
      "handler": { /* même handler qu'au-dessus */ },
      "policies": {
        "inbound": [
          "api-key-auth",
          "rate-limit-by-key",
          "validate-request"
        ]
      }
    }
  }
}

Définissez la politique :

{
  "name": "validate-request",
  "policyType": "open-api-request-validation-inbound",
  "handler": {
    "export": "OpenApiRequestValidationInboundPolicy",
    "module": "$import(@zuplo/runtime)",
    "options": {
      "validateBody": "reject"
    }
  }
}

Un POST mal formé reçoit un 400 avant même d’atteindre votre backend.

Testez différents scénarios dans Apidog : succès, champ obligatoire manquant, valeur d’énum incorrecte.

Étape 6 : Écrivez une politique TypeScript personnalisée

Pour aller au-delà du prêt-à-l’emploi, ajoutez vos propres politiques.

Exemple : ajouter un header Cache-Control différent selon le plan client.

Créez modules/tiered-cache.ts :

import { ZuploRequest, ZuploContext, HttpProblems } from "@zuplo/runtime";

interface PolicyOptions {
  paidPlanHeader: string;
  paidMaxAge: number;
}

export default async function (
  response: Response,
  request: ZuploRequest,
  context: ZuploContext,
  options: PolicyOptions,
): Promise<Response> {
  const plan = request.user?.data?.plan ?? "free";

  if (plan === "free") {
    response.headers.set("Cache-Control", "no-store");
  } else {
    response.headers.set(
      "Cache-Control",
      `public, max-age=${options.paidMaxAge}`,
    );
  }

  context.log.info(`Cache header set for plan=${plan}`);
  return response;
}

Ajoutez-la à config/policies.json :

{
  "name": "tiered-cache",
  "policyType": "custom-code-outbound",
  "handler": {
    "export": "default",
    "module": "$import(./modules/tiered-cache)",
    "options": {
      "paidPlanHeader": "x-plan",
      "paidMaxAge": 300
    }
  }
}

Référencez-la dans la route :

"policies": {
  "inbound": ["api-key-auth", "rate-limit-by-key"],
  "outbound": ["tiered-cache"]
}

Testez votre politique comme une fonction unitaire avec Vitest ou Jest : passez-lui un objet Response synthétique et vérifiez les headers.

Étape 7 : Déployez en périphérie

Déployez via git :

git add .
git commit -m "Ajoute la passerelle de produits avec authent, rate limiting et cache"
git push origin feature/products-gateway

Chaque branche crée un environnement de prévisualisation avec URL dédiée (par ex. : https://acme-gateway-feature-products-gateway-abc123.zuplo.app), incluant toutes vos politiques.

Testez l’URL de preview dans Apidog en l’ajoutant comme environnement. Vérifiez toute votre suite de tests, puis fusionnez :

git checkout main
git merge feature/products-gateway
git push origin main

La production est déployée automatiquement en ~60 secondes, sans downtime.

Étape 8 : Générez le portail développeur

Le portail développeur est accessible à https://YOUR-PROJECT.developers.zuplo.com, reconstruit à chaque déploiement :

Une page par route, avec schémas et console d’essai.
Exemples de code (cURL, JS, Python, Go…).
Self-service API key pour tout visiteur inscrit.
Branding personnalisable dans le portail.

Si votre spec OpenAPI est bien documentée, le portail est prêt sans effort supplémentaire.

Pour personnaliser davantage, forkez la source Next.js sur le dépôt GitHub du portail développeur Zuplo.

Étape 9 : Testez tout avec Apidog

Après déploiement, testez chaque route, politique et cas d’erreur. Apidog rend ce process rapide.

Workflow recommandé :

Importez la spec OpenAPI via https://YOUR-PROJECT.zuplo.app/openapi dans Apidog.
Créez des environnements (local, preview, prod) avec leur propre base_url et api_key.
Enregistrez trois requêtes/test par route : succès, échec authent, dépassement de limite.
Utilisez les tests automatisés pour enchaîner des appels (création, liste, suppression de produit) et vérifier les réponses.
Générez des snippets code pour vos runbooks.

Pour migrer depuis Postman, suivez le guide API testing without Postman. Téléchargez Apidog si ce n’est pas déjà fait.

Questions fréquentes sur l’utilisation de Zuplo

Comment basculer une route entre les environnements sans modifier la spec ?

Utilisez des variables d’environnement : définissez ORIGIN_URL par environnement et référencez-la dans vos handlers. Modifiez la variable, pas la route.

Puis-je exécuter Zuplo hors ligne ?

Oui. npm run dev démarre la passerelle locale (port 9000) et le Route Designer (9100). Toutes les politiques fonctionnent localement, sauf le service de clé API géré (utilisez npx zuplo link pour le cloud).

Comment annuler un mauvais déploiement ?

Un simple git revert du commit fautif suivi d’un push suffit : Zuplo redéploie la version précédente (pas de bouton « annuler », git fait foi).

Que se passe-t-il pour les requêtes en cours durant un déploiement ?

Déploiements atomiques : les requêtes en cours terminent sur l’ancienne version ; les nouvelles passent sur la nouvelle. Zéro downtime.

Puis-je utiliser Zuplo avec gRPC ou WebSockets ?

Oui. urlForwardHandler proxy les upgrades WebSocket, et gRPC est pris en charge. REST/GraphQL restent les cas les plus courants.

Comment exposer mon API Zuplo aux agents IA ?

Ajoutez le handler MCP Server à une route, pointez-le vers votre spec OpenAPI et sélectionnez les opérations à exposer. Les politiques existantes s’appliquent. Voir la doc MCP Server Zuplo.

Combien coûte la passerelle en production ?

Gratuit jusqu’à 100 000 requêtes/mois. Plan Builder : 1 million de requêtes pour 25 $/mois (+100 $ par 100 000 requêtes sup). Offre Enterprise à partir de 1 000 $/mois/an. Détails sur la tarification.

Conclusion

Vous avez maintenant une passerelle Zuplo complète : authentification par clé API, limitation de débit, validation des requêtes, politique TypeScript personnalisée et portail développeur, le tout déployé via Git sur le edge mondial. Prévisualisation, production et accès IA via MCP inclus dans le même repo.

Pour fiabiliser, testez chaque preview avec Apidog avant fusion : vous repérerez les en-têtes d’auth cassés, les schémas incomplets ou les quotas trop larges avant qu’ils n’atteignent la prod. Téléchargez Apidog et connectez-le à votre passerelle dès aujourd’hui.

Qu'est-ce que la passerelle API Zuplo?

Antoine Laurent — Mon, 27 Apr 2026 06:34:21 +0000

La plupart des passerelles API semblent encore conçues pour une équipe d’opérations de 2014 : configuration en YAML, gestion fastidieuse d’un plan de contrôle, et nécessité d’attendre qu’un administrateur pousse les changements sur le cluster. Zuplo casse ce paradigme. Cette passerelle API programmable et native edge gère vos routes dans un dépôt Git, vos politiques en TypeScript, et déploie chaque commit sur plus de 300 points de présence mondiaux en quelques secondes.

Essayez Apidog dès aujourd’hui

Ce guide vous montre comment utiliser Zuplo : ce que fait la passerelle, ses différences avec Kong et AWS API Gateway, son coût, et les étapes pour déployer votre première passerelle en moins de 30 minutes. Vous trouverez des exemples de code pour le routage, l’authentification, la limitation de débit, et une méthode de test de chaque endpoint avec Apidog avant la mise en production.

Zuplo s’inscrit dans la même catégorie que Kong, Apigee, et AWS API Gateway, mais avec une approche différente : les développeurs utilisent du vrai code, les opérations bénéficient d’un service managé, et la monétisation est intégrée. Voici un focus sur les points clés et le workflow technique.

En bref

Passerelle API managée native edge : routes exécutées sur plus de 300 data centers Cloudflare avec une latence < 50 ms, pas de cold start.
GitOps natif : tout est versionné dans Git et déployé via CI/CD.
Politiques en TypeScript : IDE complet, pas de YAML/Lua.
Gratuit pour 100 000 requêtes/mois : environnements, clés API et portails développeur illimités.
Fonctionnalités intégrées : Auth API Key, JWT, OAuth2, rate-limiting, validation, portail dev auto-généré, monétisation Stripe.
Support MCP Server : exposez une route à Claude, Codex, Cursor, etc.
Testez chaque route avec Apidog avant la prod.

Qu’est-ce que Zuplo ?

Zuplo est une plateforme de gestion d’API basée sur trois principes : code (TypeScript) plutôt que configuration, edge plutôt que région, Git plutôt qu’interface graphique. Le service est managé et déployé sur le réseau edge Cloudflare (300+ datacenters, rien à provisionner).

Contrairement aux passerelles qui stockent leur config en YAML dans une base centrale, Zuplo traite votre passerelle comme un projet TypeScript. Structure type :

routes.oas.json : définition des endpoints
dossier modules/ : logique custom TypeScript
fichier de config pour les politiques

Un push sur GitHub déclenche la build, la validation et le déploiement.

Support natif de REST, GraphQL, gRPC, WebSockets, SOAP. Certifié SOC 2 Type II. Backends AWS, Azure, GCP, option Kubernetes auto-hébergée. Tarification basée sur les requêtes (pas de coût par siège).

Pourquoi choisir Zuplo plutôt que Kong, Apigee ou AWS API Gateway ?

Chaque passerelle a son ADN :

Kong : open source, contrôle total, nécessite Lua.
Apigee : entreprise, analytics avancé, learning curve raide.
AWS API Gateway : bon choix pour AWS, mais pas de portail dev et cold start sur Lambda.

Zuplo vise les petites équipes qui veulent des fonctions “enterprise” sans équipe plateforme dédiée.

Différences notables :

Code, pas YAML : ex, une policy de rate-limit en Zuplo = 3 lignes TypeScript, en Kong = 15 lignes YAML.
Portail développeur inclus : généré automatiquement à partir de l’OpenAPI, même sur le plan gratuit.
GitOps par défaut : tout changement = pull request. Audit, rollback, pas de clics UI à retrouver de nuit.
Native edge, pas de cold start : Cloudflare Workers, latence minimale, vs 100-800 ms de cold start pour AWS API Gateway + Lambda.

Si vous débutez, ou que votre passerelle actuelle pose problème, Zuplo propose un workflow plus moderne et productif.

Fonctionnalités principales de Zuplo

Programmabilité TypeScript-first

Vous codez vos politiques dans des fichiers TypeScript, versionnés avec vos routes. Ex :

import { ZuploRequest, ZuploContext } from "@zuplo/runtime";

export default async function (
  response: Response,
  request: ZuploRequest,
  context: ZuploContext,
) {
  response.headers.delete("x-internal-trace-id");
  return response;
}

Placez ce fichier dans modules/strip-internal-header.ts, référencez-le dans une route, push Git, déploiement immédiat.

60+ politiques pré-construites

La plupart des besoins standards (auth, JWT, OAuth2, rate-limit, validation OpenAPI, CORS, whitelisting IP, transformations, intégrations amont) sont couverts par des policies prêtes à l’emploi. Il suffit de les déclarer dans la config de route (JSON), pas besoin de coder.

Portail développeur auto-généré

Pointez vers votre OpenAPI, et obtenez automatiquement :

Documentation hébergée
Consoles interactives (try it)
Exemples cURL, JS, Python, Go…
Génération de clés API en self-service

Idéal pour les APIs SaaS orientées développeur.

Monétisation API intégrée

Connectez Stripe, définissez les plans (free/pro/entreprise), et le portail gère paiement, souscription, facturation. Unique parmi les passerelles API.

Gestionnaire de serveur MCP (agents IA)

Exposez vos endpoints à Claude, Codex, Cursor, etc. Pointage sur votre OpenAPI, sélection des opérations exposées, policies appliquées aussi aux agents IA. Guide complet.

Déploiement edge, latence <50 ms

Déploiement automatique sur le réseau Cloudflare (300+ localisations). L’utilisateur accède toujours au PoP le plus proche. Aucun paramétrage à faire.

Comment fonctionne Zuplo sous le capot ?

Pipeline d’une requête :

Matching de route : URL/méthode vs routes.oas.json
Politiques entrantes : auth, rate-limit, validation, etc.
Handler : proxy, réponse statique, exécution TypeScript, ou gestionnaire MCP
Politiques sortantes : transformations de réponse, suppression d’en-têtes, etc.
Réponse : retour client, logs & métriques envoyés

Tout s’exécute dans un Cloudflare Worker, d’où la faible latence et l’absence de capacité inactive à payer.

Déployer rapidement votre première passerelle Zuplo

En 30 minutes, passez de zéro à une passerelle API en prod :

Inscrivez-vous sur zuplo.com et créez un projet. Intégrez GitHub pour la synchro auto.
Importez votre OpenAPI. Si vous n’en avez pas, créez les routes à la main.
Ajoutez la policy d’auth API Key dans l’éditeur de routes (api-key-inbound). Zuplo génère la base de consommateurs & UI clés.
Ajoutez la limitation de débit (rate-limit-inbound). Ex : 100 requêtes/minute/clé API (bloc JSON dans la config de route).
Déployez : push Git → build & preview URL. Merge pour passer en prod.
Testez de bout en bout : utilisez Apidog pour simuler des requêtes OK/KO, dépassements de quotas, payloads invalides, et vérifier le déclenchement de chaque policy.

Premier déploiement en quelques minutes. L’essentiel du travail : nommage des routes et placement logique des policies, comme sur toute plateforme.

Écrire des policies custom TypeScript

Pour aller au-delà des policies standard, écrivez simplement une fonction TypeScript. Exemple : enrichir les requêtes avec des infos utilisateur internes.

import { ZuploRequest, ZuploContext } from "@zuplo/runtime";

interface UserContext {
  userId: string;
  plan: "free" | "pro" | "enterprise";
}

export default async function (
  request: ZuploRequest,
  context: ZuploContext,
): Promise<ZuploRequest | Response> {
  const apiKey = request.user?.sub;
  if (!apiKey) {
    return new Response("Unauthorized", { status: 401 });
  }

  const lookupUrl = `https://internal.example.com/users/${apiKey}`;
  const userResponse = await fetch(lookupUrl, {
    headers: { authorization: `Bearer ${context.environment.INTERNAL_TOKEN}` },
  });

  if (!userResponse.ok) {
    return new Response("User lookup failed", { status: 502 });
  }

  const user = (await userResponse.json()) as UserContext;
  request.headers.set("x-user-id", user.userId);
  request.headers.set("x-user-plan", user.plan);
  return request;
}

À retenir :

Une policy = fonction async standard, testable en unitaire
Variables d’environnement via context.environment
Retourner une Response stoppe le pipeline (pour les erreurs/unauthorized)

Tarification Zuplo en 2026

Trois plans simples :

Gratuit : 100 000 requêtes/mois, envs/clés/portails illimités, 1 Go d’egress, 2 devs. Vrai trafic, pas un sandbox.
Builder ($25/mois) : jusqu’à 1M req/mois, 2 domaines custom, egress supplémentaire, support communautaire.
Entreprise (dès $1,000/mois) : requêtes/domaines illimités, SLA jusqu’à 99.999%, SSO, RBAC, support 24/7 optionnel, Github Enterprise, etc.

Portail dev open source dispo gratuitement. Consultez les prix à jour.

Comparatif : AWS API Gateway facture $3.50/M req REST + egress + Lambda ; Kong Entreprise coûte souvent bien plus que $1,000. Le niveau gratuit Zuplo est imbattable pour démarrer.

Quand adopter Zuplo (ou pas)

Zuplo est idéal si :

Vous voulez une passerelle managée (pas d’admin Kubernetes)
Votre équipe maîtrise TypeScript/JavaScript
Besoin d’un portail dev sans outil tiers
Monétisation API via Stripe requise
Exposition d’API à des agents IA (support MCP intégré)
Trafic mondial/latence edge importante

À éviter si :

Besoin absolu d’open source complet (privilégiez Kong)
Stack totalement on-prem sans sortie Internet
Exigences internes NGINX très spécifiques
Forte dépendance existante à Apigee/MuleSoft (coût migration > gain)

Tester votre passerelle Zuplo avec Apidog

Après déploiement sur un environnement de prévisualisation, testez chaque route, policy et cas limite avant la prod. C’est là qu’Apidog est essentiel.

Workflow recommandé :

Importez votre OpenAPI dans Apidog (même spec que Zuplo)
Appelez chaque endpoint avec API keys valides/invalides pour vérifier l’auth
Envoyez des payloads invalides pour valider la rejection
Testez les limites de rate-limit en overloadant un endpoint
Stockez vos variables d’URL (preview/prod) et clés pour switcher d’env
Générez du code cURL/JS/Python/Go pour vos docs internes

Vous pouvez aussi automatiser vos tests avec Apidog, plus rapide que des scripts maison. Si vous débutez, l’extension VS Code et le guide de migration Postman → Apidog vous guideront. Téléchargez Apidog pour démarrer.

FAQ Zuplo

Zuplo est-il open source ?

Le runtime principal est propriétaire, mais le portail développeur et plusieurs libs sont open source sur GitHub. Le plan Enterprise inclut une option Kubernetes auto-hébergée. La plupart des équipes optent pour le service managé.

Zuplo peut-il tourner sur mon infra ?

Oui, via le plan Enterprise (Kubernetes auto-hébergé), mais sans le déploiement edge global. À privilégier en cas d’exigences fortes de résidence de données.

Zuplo vs Cloudflare API Shield ?

API Shield = sécurité (schema validation, mTLS, etc.), Zuplo = plateforme API complète (routage, policies, portail, monétisation, MCP). Les deux peuvent coexister.

Zuplo fonctionne-t-il avec mon OpenAPI ?

Oui, OpenAPI = source de vérité dans Zuplo. Importez, les routes et la doc sont générées, la validation de requête se base dessus.

Puis-je exposer Zuplo à Claude/Codex/IA ?

Oui, via le gestionnaire MCP. Les policies d’auth/rate-limit s’appliquent aussi aux agents IA.

Déploiement Zuplo : combien de temps ?

Push → preview en <60 secondes. Passage en prod quasi-instantané (artefact déjà buildé).

Que se passe-t-il si Cloudflare tombe ?

Zuplo dépend du réseau edge Cloudflare (pannes régionales = impact local). Le plan Enterprise propose des options multi-cloud pour 99.999% de dispo.

Conclusion

Zuplo offre une passerelle API moderne : policies TypeScript natives, GitOps, portail dev instantané, monétisation Stripe, support agents IA/MCP. Le plan gratuit couvre la production réelle, le plan Enterprise comble les besoins avancés.

Pour tester, faites la config 30 min sur une de vos APIs, validez chaque policy avec Apidog, et décidez sur preuves techniques réelles. Coupler une passerelle edge managée à un client de tests robuste, c’est passer plus vite de « on a une API » à « on a un produit ». Téléchargez Apidog et commencez vos tests.

Comment utiliser DeepSeek V4 gratuitement ?

Antoine Laurent — Fri, 24 Apr 2026 05:32:24 +0000

DeepSeek V4 a été lancé le 23 avril 2026, et contrairement à la plupart des lancements de modèles de pointe, les options gratuites sont réellement utilisables. Le chat web officiel fonctionne avec V4-Pro sans nécessiter de carte de crédit. Les poids sont disponibles sous licence MIT et peuvent être téléchargés immédiatement. Les agrégateurs comme OpenRouter et Chutes proposent généralement des quotas gratuits peu après chaque version DeepSeek. En combinant ces options, vous pouvez exécuter des charges de travail V4 conséquentes sans dépenser, tout en préparant la montée en charge vers la facturation payante si nécessaire.

Essayez Apidog dès aujourd'hui

Ce guide détaille chaque méthode gratuite vérifiée, les cas d’utilisation adaptés, et explique comment mettre en place une collection prête pour la production dans Apidog pour assurer une transition fluide vers du payant au besoin.

Pour un aperçu du produit, consultez qu'est-ce que DeepSeek V4. Pour l'intégration API, lisez comment utiliser l'API DeepSeek V4.

En bref

chat.deepseek.com — Chat web gratuit sur V4-Pro, modes de raisonnement Non-Think, Think High, Think Max. Fonctionne sans carte, disponible immédiatement.
Poids Hugging Face + GPU personnel — Licence MIT, V4-Flash fonctionne sur 2 à 4 H100, V4-Pro nécessite un cluster.
Niveaux gratuits OpenRouter et Chutes — Passerelles offrant un quota gratuit sur DeepSeek peu après chaque lancement.
Fournisseurs d'inférence Hugging Face — Endpoint partagé pour expérimenter gratuitement.
Crédits d’essai Kaggle, Colab, RunPod — Calcul gratuit pour tester l’auto-hébergement.
Chaque chemin gratuit plafonne l’utilisation. Pour la production, prévoir la montée vers le payant avant d’atteindre la limite.

Option 1 : chat.deepseek.com (l'option gratuite par défaut)

Le moyen le plus rapide et fiable est d'utiliser le chat officiel. V4-Pro est activé par défaut ; en haut du compositeur, le sélecteur permet de basculer entre Non-Think, Think High et Think Max.

Configuration

Accédez à chat.deepseek.com.
Connectez-vous avec e-mail, Google ou WeChat.
Vérifiez que le modèle actif est bien V4-Pro.
Commencez à interagir.

Fonctionnalités

Contexte 1M tokens.
Téléchargement de fichiers (PDF, images, archives de code).
Recherche web intégrée.
Trois modes de raisonnement dont Think Max.
Historique des conversations et organisation par dossiers.

Limites d'utilisation

Aucune limite stricte publiée, mais le service applique du throttling en cas de forte charge. Si vous voyez des délais ou files d’attente persistantes, ralentissez ou passez à l’API.

Cas d’utilisation adaptés : Comparer V4 à Claude sur un prompt, revue de dépôt, analyse de contrat complexe.

Moins adapté : Automatisation, reproductibilité.

Option 2 : Auto-héberger V4-Flash sur votre propre GPU

V4-Flash (MIT) peut être déployé en interne. 284B paramètres (13B actifs), tourne sur 2+ H100 (FP8) ou une carte 80Go (INT4).

Coût : uniquement le matériel. Idéal pour ceux disposant déjà de GPU.

Télécharger les poids

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash

Environ 500 Go en FP8 : prévoyez l’espace disque.

Servir avec vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto \
  --port 8000

Une fois lancé, tout client OpenAI-compatible peut pointer vers http://localhost:8000/v1. Apidog gère cela comme n’importe quelle URL de base ; vos collections restent compatibles sans adaptation.

Exigences matérielles

Variante	Cartes minimales (FP8)	Cartes minimales (INT4)	Débit réaliste
V4-Flash	2 × H100 80 Go	1 × H100 80 Go	50 à 150 tokens/s
V4-Pro	16 × H100 80 Go	8 × H100 80 Go	dépend du cluster

Si vous louez des GPU, l’API payante est souvent plus économique. L’auto-hébergement cible les équipes avec capacité existante ou besoins de conformité.

Option 3 : Niveau gratuit OpenRouter

OpenRouter agrège divers modèles derrière une API unique. Des niveaux gratuits sur DeepSeek apparaissent souvent rapidement après chaque sortie.

Configuration

Inscrivez-vous sur openrouter.ai.
Générez une clé API.
Repérez deepseek/deepseek-v4-pro ou deepseek/deepseek-v4-flash (les variantes gratuites portent souvent le suffixe :free).
Appelez-les avec un SDK OpenAI-compatible :

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Write a Python CLI for semver bumping."}],
)

print(response.choices[0].message.content)

Limites

Niveaux gratuits limités à quelques centaines de requêtes/jour/clé, priorité abaissée en cas de charge. Idéal pour le prototypage, pas pour la production.

Option 4 : Fournisseurs d’inférence Hugging Face

Hugging Face héberge un endpoint d’inférence gratuit peu après chaque sortie V4. Limites de débit strictes, latence variable, mais appels gratuits.

from huggingface_hub import InferenceClient

client = InferenceClient(model="deepseek-ai/DeepSeek-V4-Flash")

response = client.chat_completion(
    messages=[{"role": "user", "content": "Summarize the V4 technical report in 5 bullets."}],
    max_tokens=512,
)

print(response.choices[0].message.content)

Le token HF est gratuit. Pour du volume, passez à un compte Pro pour des limites supérieures, mais le coût reste inférieur à l’API officielle.

Option 5 : Crédits d’essai sur Colab, Kaggle, RunPod, Lambda

Chaque loueur de GPU propose des crédits d’essai :

Google Colab : Le T4 gratuit est trop juste. Colab Pro+ (500 unités/mois) permet quelques tests V4-Flash sur A100.
Kaggle : Heures GPU gratuites sur T4/P100. Assez pour V4-Flash quantifié, insuffisant pour V4-Pro.
RunPod : 10 $ offerts = quelques heures sur H100, suffisant pour benchmarks vLLM.
Lambda : Offres ponctuelles d’heures gratuites H100/H200, vérifiez la page d’inscription.

Ces crédits sont pour l’expérimentation ponctuelle, pas pour un usage continu.

Créez une collection Apidog agnostique du fournisseur

L’avantage des options gratuites : tester le même prompt sur différentes plateformes, sans duplication.

Étapes :

Téléchargez Apidog.
Créez une collection avec quatre environnements :
- chat (placeholder)
- deepseek (https://api.deepseek.com/v1)
- openrouter (https://openrouter.ai/api/v1)
- self-hosted (http://localhost:8000/v1)
Enregistrez une requête POST sur {{BASE_URL}}/chat/completions.
Stockez chaque clé API comme variable secrète, pour garder un corps de requête identique partout.
Basculez d’environnement pour faire des tests A/B sur chaque backend.

Ce modèle, utilisé pour la collection gratuite GPT-5.5, évite toute duplication de travail.

Quelle option gratuite choisir ?

Suivez ces heuristiques :

Découverte rapide (5 min) : chat.deepseek.com.
Prototypage produit : Niveau gratuit OpenRouter, puis rechargez chez DeepSeek si besoin.
GPU disponible et conformité : Auto-hébergez V4-Flash sur vLLM.
Besoin de gratuit à long terme : Aucune option n’est illimitée. Combinez chat.deepseek.com pour l’interactif et un peu de payant pour automatiser.

Quand quitter le niveau gratuit

Trois signaux :

Throttling fréquent : Si limité plus d’une fois/jour, il est temps de budgétiser.
Besoins de SLA : Seule l’API officielle en fournit.
Exigences de logs/audit/conformité : L’API payante offre une facturation claire, les niveaux gratuits non.

Dans ces cas, basculez vers l’API officielle. Recharge minimale 2 $, tarification token au meilleur prix.

FAQ

chat.deepseek.com est-il vraiment gratuit ?

Oui. Sans carte, sans période d’essai. Limites douces, service gratuit.

Compte Hugging Face requis pour les poids ?

Pas strictement, mais un compte améliore les limites de téléchargement.

Quel chemin gratuit donne accès au vrai V4-Pro ?

chat.deepseek.com exécute V4-Pro complet. Les niveaux gratuits OpenRouter ciblent plus souvent V4-Flash.

Peut-on placer un niveau gratuit derrière un produit ?

Non. Ces niveaux sont instables, limités, parfois retirés sans préavis. Pour un produit, utilisez l’API payante ou auto-hébergez.

L’auto-hébergement est-il vraiment gratuit ?

La licence oui, le matériel non. Si vous possédez déjà des GPU, le coût marginal est faible. Louer des GPU coûte souvent plus cher que l’API.

Apidog propose-t-il un niveau gratuit pour les tests ?

Apidog est gratuit pour la conception et les tests d’API ; seuls les appels à des APIs payantes consomment des crédits. Vous pouvez donc combiner un environnement Apidog gratuit avec chat.deepseek.com ou OpenRouter pour un workflow 100% gratuit.

Comment exécuter DeepSeek V4 localement ?

Antoine Laurent — Fri, 24 Apr 2026 04:58:27 +0000

DeepSeek V4 est disponible depuis le 23 avril 2026 avec une licence MIT sur Hugging Face, un changement majeur pour les équipes souhaitant déployer une IA avancée sur leur propre infrastructure. V4-Flash (284 milliards de paramètres, 13 milliards actifs) fonctionne sur deux H100 en FP8. V4-Pro (1,6 To, 49 milliards actifs) nécessite un cluster, mais rivalise avec GPT-5.5 et Claude Opus 4.6 pour le code et le raisonnement.

Essayez Apidog dès aujourd'hui

Ce guide fournit un mode d'emploi pour déployer DeepSeek V4 localement : exigences matérielles, quantification, configurations vLLM et SGLang, utilisation des outils, et workflow de validation avec Apidog avant toute mise en production.

Pour un aperçu du produit, consultez qu'est-ce que DeepSeek V4. Pour utiliser l'API hébergée, voyez comment utiliser l'API DeepSeek V4. Pour la comparaison des coûts, voyez tarification de l'API DeepSeek V4.

En bref

V4-Flash tourne sur 2 × H100 80 Go en FP8, ou 1 × H100 en INT4 (~500 Go de poids en FP8).
V4-Pro requiert au moins 16 H100 en FP8 pour un usage production. Pas pour laptop.
vLLM est le moyen le plus rapide pour exposer une API compatible OpenAI. vllm>=0.9.0 supporte V4.
SGLang est préférable pour l'utilisation d'outils et la sortie structurée.
Quantification AWQ INT4 ou GPTQ INT4 : V4-Flash tient sur 1 carte de 80 Go (~5% de perte de qualité).
Utilisez Apidog pour pointer vers http://localhost:8000/v1 avec votre collection existante.

Qui devrait auto-héberger

L'auto-hébergement de V4 est pertinent pour :

Exigences de conformité (santé, finance, juridique, défense) : données sur site, licence MIT sans restrictions.
Charges importantes et stables : au-delà de 200 milliards de tokens/mois, le matériel dédié devient rentable.
Réglage fin et recherche : checkpoints de base prévus pour la pré-formation continue, licence MIT pour la redistribution.

À éviter si : vous prototypez, n'avez pas d'expérience GPU, ou si vos coûts API hébergée < 200 $/mois.

Exigences matérielles

DeepSeek V4 utilise en natif la précision mixte FP4 + FP8. La VRAM requise dépend du modèle et du niveau de quantification.

Variante	Paramètres totaux	Paramètres actifs	VRAM FP8	VRAM INT4	Cartes minimum
V4-Flash	284B	13B	~500Go	~140Go	2 × H100 80Go (FP8) ou 1 × H100 (INT4)
V4-Pro	1.6T	49B	~2.4To	~700Go	16 × H100 80Go (FP8) ou 8 × H100 (INT4)

Mémoire MoE : toute la VRAM pour tous les experts, pas seulement les actifs.
H200/MI300X : VRAM plus élevée = moins de cartes.
GPU grand public : insuffisant, même en INT4 sur RTX 5090.
Apple Silicon : M3 Max/M4 Max (128 Go) peuvent lancer V4-Flash quantifié, mais très lentement.

Étape 1 : Télécharger les poids

Dépôts officiels :

deepseek-ai/DeepSeek-V4-Flash
deepseek-ai/DeepSeek-V4-Pro
deepseek-ai/DeepSeek-V4-Flash-Base et DeepSeek-V4-Pro-Base pour le fine-tuning.

Installez la CLI et téléchargez :

pip install -U "huggingface_hub[cli]"
huggingface-cli login

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

Prévoyez 500 Go (V4-Flash) à plusieurs To (V4-Pro). ModelScope propose les mêmes checkpoints, plus rapide depuis la Chine.

Étape 2 : Choisir un moteur de service

vLLM : meilleur débit, API OpenAI la plus standard, communauté active. Par défaut.
SGLang : primitives avancées pour outils/fonctions, sortie structurée, meilleur gestion des contextes longs.

Les deux supportent V4 dès les dernières versions.

Étape 3 : Servir V4-Flash avec vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --dtype auto \
  --enable-prefix-caching \
  --port 8000

--tensor-parallel-size 2 : split sur 2 H100 (augmentez selon le nombre de cartes).
--max-model-len 1048576 : contexte 1M tokens. Diminuez pour économiser de la VRAM.
--enable-prefix-caching : accélère les prompts répétés (prix cache API reproduit).
--dtype auto : respecte la précision mixte FP8.

Le serveur expose /v1 compatible OpenAI.

Étape 4 : Servir V4-Pro avec vLLM

V4-Pro nécessite un cluster.

vllm serve deepseek-ai/DeepSeek-V4-Pro \
  --tensor-parallel-size 8 \
  --pipeline-parallel-size 2 \
  --max-model-len 524288 \
  --enable-prefix-caching \
  --port 8000

Ajustez le contexte et le parallélisme selon la VRAM disponible.

Étape 5 : Servir avec SGLang (utilisation d'outils)

pip install "sglang[all]>=0.4.0"

python -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp 2 \
  --context-length 1048576 \
  --port 30000

SGLang expose /v1 compatible OpenAI sur le port 30000. Son DSL lang facilite l'appel de fonctions et la sortie JSON.

Étape 6 : Quantifier pour un seul GPU

AWQ (recommandé) :

pip install autoawq

python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = './models/deepseek-v4-flash'
out_path = './models/deepseek-v4-flash-awq'
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.quantize(tokenizer, quant_config={'w_bit': 4, 'q_group_size': 128})
model.save_quantized(out_path)
tokenizer.save_pretrained(out_path)
"

GPTQ :

pip install auto-gptq
# Suivez la recette GPTQ, similaire à AWQ.

Servez le modèle quantifié avec vLLM via --quantization awq ou --quantization gptq.

Étape 7 : Tester avec Apidog

Validez d'abord le serveur local avant tout trafic en production.

Téléchargez Apidog.
Créez une collection pointant vers http://localhost:8000/v1/chat/completions.
Utilisez la même invite de test qu'avec l'API hébergée. Comparez les résultats.
Testez un contexte de 500K tokens pour valider le cache KV.
Testez un flux d'appel d'outils avant d'intégrer un agent.

La collection utilisée pour l'API DeepSeek V4 hébergée fonctionne localement sans autre modification que l'URL de base.

Observabilité et surveillance

Surveillez ces 4 métriques :

Tokens/secondes (invite/génération) : exposé sur /metrics (Prometheus).
Usage GPU : via nvidia-smi ou DCGM ; <70% indique souvent un batch size sous-optimal.
Taux d'accès au cache KV : avec --enable-prefix-caching, baisse = rotation trop rapide des prompts.
Latence p50/p95/p99 : traçage standard ; un p99 qui grimpe indique un blocage de file.

Intégrez le tout dans Grafana ou votre stack d'observabilité.

Réglage fin (fine-tuning) des checkpoints de base V4

Utilisez les checkpoints de base pour pré-formation continue ou SFT.

pip install "torch>=2.6" transformers accelerate peft trl

# SFT standard avec LoRA sur V4-Flash-Base
python -m trl sft \
  --model_name_or_path deepseek-ai/DeepSeek-V4-Flash-Base \
  --dataset_name your-org/your-sft-set \
  --output_dir ./models/v4-flash-custom \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 2e-5 \
  --bf16 true \
  --use_peft true \
  --lora_r 64 \
  --lora_alpha 128

Le fine-tuning complet sur V4-Pro est réservé à la recherche avancée. Pour la majorité des équipes, LoRA sur V4-Flash-Base offre un excellent compromis.

Pièges courants

OOM au démarrage : --max-model-len trop haut ou --tensor-parallel-size trop bas. Diminuez le contexte ou augmentez le parallélisme.
Première requête lente : vLLM compile les kernels à la volée. Préchauffez avec une requête factice.
Erreurs d'utilisation d'outils : l'encodage DeepSeek diffère légèrement d'OpenAI. Fixez votre SDK à une version compatible V4.
Erreurs FP8 sur anciens GPU : A100 ne supporte pas FP8. Utilisez BF16 (doublez la VRAM attendue).

Quand l'auto-hébergement est rentable

Calcul basé sur la tarification de l'API DeepSeek V4 :

V4-Flash, 200B tokens d'entrée/mois + 20B de sortie : ~33,6K$ sur l'API. Un boîtier 8 × H100 = ~20K$/mois en location. Économie ~40%.
V4-Pro, 500B entrée + 50B sortie/mois : ~1,04M$ sur l'API. Cluster 16 × H100 = ~35K$/mois. Économie >95%.

Le seuil de rentabilité pour V4-Flash : ~100 milliards de tokens/mois. En-dessous, l'API hébergée reste la meilleure option.

FAQ

Puis-je exécuter V4-Flash sur une A100 ?

Oui en INT4 et contexte court, mais lentement (5–15 tok/s). La H100 est la cible idéale.

V4 supporte-t-il le fine-tuning LoRA ?

Oui, avec les checkpoints de base et les pipelines TRL/Axolotl standards. MoE ne gêne pas LoRA.

Le serveur local est-il compatible OpenAI ?

Oui, vLLM/SGLang exposent /v1/chat/completions et /v1/completions. Le guide de l'API hébergée fonctionne sans changement contre localhost.

Comment activer le mode réflexion localement ?

Ajoutez thinking_mode: "thinking" ou "thinking_max" dans la requête. vLLM et SGLang transmettent ce paramètre.

Peut-on streamer depuis un serveur local V4 ?

Oui, définissez stream: true comme pour OpenAI ou l'API DeepSeek.

Comment tester avant d'investir dans du matériel ?

Louez une H100 sur RunPod/Lambda, exécutez V4-Flash en INT4, mesurez le débit réel. Moins de 30$ pour un test rapide.

Prix API DeepSeek V4

Antoine Laurent — Fri, 24 Apr 2026 04:28:27 +0000

DeepSeek a publié les tarifs V4 le jour même du lancement des modèles, le 23 avril 2026. Ces nouveaux prix redéfinissent le plancher pour l’IA de pointe : **0,14 $ par million de jetons d'entrée et 0,28 $ par million de jetons de sortie** pour V4-Flash, et **1,74 $ en entrée et 3,48 $ en sortie** pour V4-Pro. Les deux modèles offrent une fenêtre de contexte de 1 million de jetons et jusqu’à 384 000 jetons de sortie. Une remise agressive s’applique automatiquement sur les requêtes en cache, réduisant les coûts d’entrée de 80 % à 90 % sur les invites répétées.

Essayez Apidog aujourd’hui

Ce guide détaille la grille tarifaire, explique comment la mise en cache du contexte modifie le coût réel par appel, propose une comparaison avec GPT-5.5 et Claude Opus, et présente quatre méthodes pour garder vos dépenses prévisibles dans Apidog.

Pour un aperçu du produit, consultez qu'est-ce que DeepSeek V4. Pour le guide du développeur, consultez comment utiliser l'API DeepSeek V4. Pour les solutions gratuites, consultez comment utiliser DeepSeek V4 gratuitement.

En bref

V4-Flash : 0,14 $ / M en entrée (cache manqué), 0,028 $ / M en entrée (cache réussi), 0,28 $ / M en sortie.
V4-Pro : 1,74 $ / M en entrée (cache manqué), 0,145 $ / M en entrée (cache réussi), 3,48 $ / M en sortie.
Fenêtre de contexte : 1 million de jetons en entrée, 384 000 jetons en sortie, pour les deux variantes.
Remise sur les requêtes en cache : environ 80 % de réduction pour Flash, 92 % de réduction pour Pro sur les préfixes répétés.
deepseek-chat et deepseek-reasoner seront dépréciés le 24 juillet 2026 ; la facturation correspondra à V4-Flash.
Aux taux de cache manqué, V4-Pro est environ 2,9 fois moins cher que GPT-5.5 en entrée et environ 8,6 fois moins cher en sortie.

La grille tarifaire complète

Modèle	Entrée (cache manqué)	Entrée (cache réussi)	Sortie	Contexte
`deepseek-v4-flash`	0,14 $ / M	0,028 $ / M	0,28 $ / M	1M / 384K
`deepseek-v4-pro`	1,74 $ / M	0,145 $ / M	3,48 $ / M	1M / 384K
`deepseek-chat` (déprécié)	V4-Flash non-réflexion	—	—	—
`deepseek-reasoner` (déprécié)	V4-Flash réflexion	—	—	—

Trois points clés à retenir :

Les prix dépendent uniquement de l’ID du modèle (deepseek-v4-flash ou deepseek-v4-pro), pas du mode de raisonnement. Le mode modifie seulement la quantité de jetons consommés.
La tarification des requêtes en cache est automatique. Si le préfixe (≥ 1 024 jetons, identique à l’octet près) est répété pour le même compte, la remise s’applique sans configuration.
Les anciens IDs (deepseek-chat, deepseek-reasoner) sont déjà facturés comme V4-Flash. La migration reste possible jusqu’au 24 juillet 2026.

La mise en cache du contexte en pratique

La mise en cache est le principal levier pour réduire vos coûts sur DeepSeek V4. Tout segment d’invite ou de contexte qui se répète entre appels (par exemple longue invite système, schémas d’outils, contexte RAG) est automatiquement facturé à un tarif réduit lors des appels suivants.

Exemple concret :

Agent avec invite système de 20 000 jetons (fixe)
100 questions utilisateur de 200 jetons chacune

Sans mise en cache :

Entrée : 100 × 20 200 jetons × 1,74 $/M = 3,52 $
Sortie : 100 × 500 jetons × 3,48 $/M = 0,17 $
Total : 3,69 $

Avec mise en cache (1 appel manqué, 99 en cache réussi) :

Entrée premier appel : 20 200 × 1,74 $/M = 0,035 $
99 préfixes suivants en cache réussi : 99 × 20 000 × 0,145 $/M = 0,287 $
99 requêtes utilisateur (hors cache) : 99 × 200 × 1,74 $/M = 0,034 $
Sortie : 100 × 500 × 3,48 $/M = 0,174 $
Total : 0,53 $

Environ 7 fois moins cher pour une charge de travail identique. Sur V4-Flash, l’effet est encore plus marqué.

Comparaison avec GPT-5.5 et Claude

Modèle	Entrée (standard)	Entrée (en cache)	Sortie	Contexte
DeepSeek V4-Flash	0,14 $ / M	0,028 $ / M	0,28 $ / M	1M
DeepSeek V4-Pro	1,74 $ / M	0,145 $ / M	3,48 $ / M	1M
GPT-5.5	5 $ / M	1,25 $ / M	30 $ / M	1M
GPT-5.5 Pro	30 $ / M	—	180 $ / M	1M
Claude Opus 4.6	15 $ / M	1,50 $ / M	75 $ / M	200K

Analyse :

V4-Pro coûte ~8,6 fois moins cher que GPT-5.5 pour la sortie, et ~21 fois moins cher que Claude Opus 4.6. La sortie est souvent le principal poste de dépense.
En entrée mise en cache, V4-Pro est ~10 fois moins cher que GPT-5.5 et Claude.
Performance : V4-Pro égale ou dépasse GPT-5.5 sur LiveCodeBench (93,5) et Codeforces (3206) pour une fraction du coût. Voir le tableau complet des benchmarks dans qu'est-ce que DeepSeek V4.

Attention : Claude reste devant sur les tâches de récupération de contexte long, et Gemini 3.1 Pro est leader sur MMLU-Pro. Si la précision sur de très longs contextes est critique, l’écart de prix ne compensera pas toujours la différence de qualité.

Modélisation des coûts pour les charges de travail courantes

Voici le coût estimé de quatre scénarios types sur V4-Pro (cache manqué ; ajoutez la remise cache réussi le cas échéant).

1. Boucle de codage d’agent (contexte 50K, sortie 2K, 20 appels)

Entrée : 50 000 × 20 × 1,74 $/M = 1,74 $
Sortie : 2 000 × 20 × 3,48 $/M = 0,14 $
Coût par tâche : ~1,88 $ (vs ~6,20 $ sur GPT-5.5)

2. Q/R sur documents longs (contexte 500K, sortie 1K)

Entrée : 500 000 × 1,74 $/M = 0,87 $
Sortie : 1 000 × 3,48 $/M = 0,003 $
Coût par appel : ~0,87 $ (vs ~2,53 $ sur GPT-5.5)

3. Classification à haut volume (contexte 2K, sortie 200, 10 000 appels)

Utilisez V4-Flash pour ce cas ; V4-Pro est surdimensionné.

Entrée : 2 000 × 10 000 × 0,14 $/M = 2,80 $
Sortie : 200 × 10 000 × 0,28 $/M = 0,56 $
Coût d’exécution : ~3,36 $ (vs ~110 $ sur GPT-5.5)

4. Chatbot à invite répétée (invite système 10K, 500 jetons utilisateur, 1K sortie, 1 000 sessions)

Entrée premier appel : 10 500 × 1,74 $/M = 0,018 $
999 invites système en cache réussi : 999 × 10 000 × 0,145 $/M = 1,45 $
999 requêtes utilisateur hors cache : 999 × 500 × 1,74 $/M = 0,87 $
Sortie : 1 000 × 1 000 × 3,48 $/M = 3,48 $
Coût total : ~5,82 $ (vs ~26,35 $ sur GPT-5.5 avec cache)

Coûts cachés à surveiller

Quatre éléments peuvent gonfler la facture si vous ne les contrôlez pas :

Inflation des jetons en mode réflexion. thinking_max peut consommer 3 à 10 fois plus de jetons de sortie. Limitez-le via un flag.
Croissance silencieuse du contexte. Les boucles d’agent qui renvoient tout le contexte à chaque itération font exploser la facture avec des fenêtres de 1M jetons. Tronquez ou résumez le contexte.
Tempêtes de tentatives. Un bug qui relance à chaque erreur 500 peut doubler vos coûts très vite. Implémentez une temporisation exponentielle et un plafond de tentatives.
Frictions de développement. Utiliser curl pour itérer sur une invite fait repayer le contexte complet à chaque fois. Utilisez Apidog : la substitution de variables rend l’itération quasi-gratuite.

Suivre les coûts dans Apidog

Optimisez le suivi des coûts avec ce workflow :

Téléchargez Apidog et stockez votre DEEPSEEK_API_KEY comme variable secrète par environnement.
Créez une requête POST vers https://api.deepseek.com/v1/chat/completions.
Dans le panneau de réponse, épinglez usage.prompt_tokens, usage.completion_tokens, usage.reasoning_tokens pour voir le calcul des coûts à chaque appel.
Paramétrez model et thinking_mode pour tester simplement V4-Flash vs V4-Pro, ou Non-Think vs Think Max, sans dupliquer les requêtes.
Dupliquez la collection pour GPT-5.5 (voir le guide API GPT-5.5). Une seule interface, coûts comparés en direct.

Ce workflow détecte environ 80 % des surprises de coût avant la facture de fin de mois.

Quatre règles pour des dépenses prévisibles

Utilisez V4-Flash par défaut. Passez à V4-Pro uniquement si un gain de qualité mesuré a un impact business.
Utilisez Non-Think par défaut. Passez à Think High pour les tâches complexes, Think Max seulement si la justesse absolue est requise.
Limitez max_tokens. Le plafond de 384 000 jetons est une sécurité, pas un objectif. En production, visez 2 000 jetons par réponse.
Intégrez la télémétrie d’utilisation. Loggez prompt_tokens, completion_tokens, reasoning_tokens à chaque appel et alertez sur les pics de reasoning.

FAQ

Existe-t-il un niveau gratuit ?

Il n’existe pas de niveau d’API gratuit, mais les nouveaux comptes reçoivent parfois un petit crédit d’essai. Pour des solutions gratuites, consultez comment utiliser DeepSeek V4 gratuitement.

Comment fonctionne la tarification des requêtes en cache ?

Tout préfixe d’au moins 1 024 jetons répété à l’identique pour un même compte déclenche la remise cache. Le 1er appel paie le plein tarif, les suivants paient le tarif réduit. C’est automatique.

Les modes de réflexion coûtent-ils plus cher ?

Non, le tarif par jeton reste identique. Les modes de réflexion génèrent simplement plus de jetons (traces de raisonnement). Surveillez reasoning_tokens dans l’objet usage pour estimer le coût réel.

La tarification est-elle stable ?

DeepSeek ajuste périodiquement ses tarifs. Les tarifs V3.2 sont restés stables toute l’année 2025 ; V4 n’a pas de date de fin annoncée. Vérifiez la page de tarification en direct avant tout engagement.

V4-Pro et V4-Flash partagent-ils le même tarif de sortie ?

Non. V4-Pro : 3,48 $/M. V4-Flash : 0,28 $/M. Le ratio de 12,4x justifie d’utiliser V4-Flash par défaut.

Le point de terminaison Anthropic modifie-t-il la tarification ?

Non. https://api.deepseek.com/anthropic applique les mêmes tarifs que le point de terminaison OpenAI. Le format d’API n’influence pas la facturation.

Comment utiliser l'API DeepSeek V4 gratuitement ?

Antoine Laurent — Fri, 24 Apr 2026 04:28:15 +0000

DeepSeek V4 a été lancé le 23 avril 2026 avec une API dont le prix est suffisamment bas pour que la plupart des équipes évitent complètement la chasse aux offres gratuites. Toutefois, il existe plusieurs méthodes pour accéder gratuitement à V4 par API, idéales pour les développeurs souhaitant automatiser ou prototyper avant d'investir. Ce tutoriel montre comment combiner différents points d’accès gratuits pour automatiser vos appels DeepSeek V4 sans frais, en structurant une chaîne de secours dans Apidog afin de maximiser la résilience de vos prototypes.

Essayez Apidog dès aujourd'hui

Ce guide cible le chemin gratuit API. Pour un panorama incluant le chat web et l’auto-hébergement, lisez comment utiliser DeepSeek V4 gratuitement. Pour la procédure payante, rendez-vous sur comment utiliser l'API DeepSeek V4. Pour l’aperçu produit, voyez qu'est-ce que DeepSeek V4.

TL;DR

Niveau gratuit OpenRouter — deepseek/deepseek-v4-flash:free (parfois deepseek-v4-pro:free). Compatible OpenAI, quelques centaines de requêtes/jour/clé.
Fournisseurs d'inférence Hugging Face — endpoint partagé : https://router.huggingface.co/hf-inference. Limites de débit strictes, pratique pour tester.
Niveau gratuit Chutes — réseau GPU communautaire qui expose des endpoints DeepSeek gratuits peu après lancement.
Crédit d’essai DeepSeek — nouveaux comptes sur platform.deepseek.com reçoivent parfois un crédit initial.
Auto-hébergement V4-Flash — gratuit niveau licence si vous avez du GPU ; voir comment exécuter DeepSeek V4 localement.
Chaîne de secours dans Apidog — unifiez la structure de requête pour tous les fournisseurs.

Pourquoi le chemin d'API gratuit existe

Malgré des tarifs déjà compétitifs, exploiter l’accès gratuit se justifie dans plusieurs cas :

Prototypage sans friction : tester en code avant tout engagement financier.
Étudiants, chercheurs, projets open source : besoin de qualité sans budget.
Comparaison fournisseurs : mesurer latence, qualité et fiabilité sur diverses plateformes en conditions réelles.

Si vous êtes dans un de ces cas, poursuivez ! Pour produire à grande échelle, le mode payant devient rapidement plus simple.

Chemin 1 : Niveau gratuit OpenRouter

OpenRouter agrège plusieurs modèles derrière une API OpenAI-compatible et propose régulièrement des variantes gratuites lors des lancements DeepSeek.

Configuration

Inscrivez-vous sur openrouter.ai.
Créez une clé API via Paramètres → Clés.
Repérez les modèles suffixés :free, ex. deepseek/deepseek-v4-flash:free.
Utilisez un SDK compatible OpenAI pour appeler le modèle.

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_API_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Refactor this Go function to use channels."}],
)

print(response.choices[0].message.content)

Limites

50 à 200 requêtes/jour/clé, concurrence élevée
Prototypage uniquement ; pas de promesse de disponibilité

Version Node

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,
  baseURL: "https://openrouter.ai/api/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek/deepseek-v4-flash:free",
  messages: [{ role: "user", content: "Explain MoE routing like I'm 12." }],
});

console.log(response.choices[0].message.content);

Chemin 2 : Fournisseurs d'inférence Hugging Face

Hugging Face expose les checkpoints DeepSeek V4 via un endpoint partagé. Idéal pour un accès rapide, mais limites strictes.

import os
from huggingface_hub import InferenceClient

client = InferenceClient(
    model="deepseek-ai/DeepSeek-V4-Flash",
    token=os.environ["HF_TOKEN"],
)

response = client.chat_completion(
    messages=[
        {"role": "user", "content": "Write a Python decorator that retries with jitter."}
    ],
    max_tokens=512,
)

print(response.choices[0].message.content)

Générez votre token sur huggingface.co/settings/tokens
Latence variable, limites quotidiennes par compte
HF Pro lève les quotas

Chemin 3 : Chutes et passerelles communautaires

Chutes héberge régulièrement DeepSeek sur un réseau GPU communautaire, accessible via une API compatible OpenAI.

client = OpenAI(
    api_key=CHUTES_API_KEY,
    base_url="https://llm.chutes.ai/v1",
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash",
    messages=[{"role": "user", "content": "Compare CSA and HCA attention in two sentences."}],
)

Vérifiez disponibilité et coût dans le dashboard Chutes avant usage.

Chemin 4 : Crédit d'essai DeepSeek

DeepSeek crédite parfois les nouveaux comptes (montant et validité variables). Consultez votre dashboard sur platform.deepseek.com après inscription.

1 $ d’essai = ~7M jetons sur V4-Flash ou ~570K jetons sur V4-Pro
Suffisant pour plusieurs centaines de requêtes de prototypage

Construire une chaîne gratuite agnostique au fournisseur dans Apidog

Centralisez vos tests et automatisez la bascule entre fournisseurs dans Apidog :

Téléchargez Apidog et créez un projet.
Créez quatre environnements : openrouter, huggingface, chutes, deepseek-trial.
Stockez les clés API et définissez BASE_URL dans chaque environnement.
Créez une requête POST vers {{BASE_URL}}/chat/completions avec un champ model dynamique.
Changez d’environnement pour exécuter la même invite sur chaque fournisseur d’un clic.

Ce workflow est réutilisable pour d’autres APIs gratuites (ex : GPT-5.5) : dupliquez la collection, changez les endpoints.

Implémenter une chaîne de secours dans le code

Pour automatiser la bascule entre fournisseurs lors d’une limitation :

import os
from openai import OpenAI, RateLimitError, APIError

PROVIDERS = [
    {
        "base_url": "https://openrouter.ai/api/v1",
        "api_key": os.environ["OPENROUTER_API_KEY"],
        "model": "deepseek/deepseek-v4-flash:free",
    },
    {
        "base_url": "https://llm.chutes.ai/v1",
        "api_key": os.environ["CHUTES_API_KEY"],
        "model": "deepseek-ai/DeepSeek-V4-Flash",
    },
    {
        "base_url": "https://api.deepseek.com/v1",
        "api_key": os.environ["DEEPSEEK_API_KEY"],
        "model": "deepseek-v4-flash",
    },
]

def call_v4(messages):
    for provider in PROVIDERS:
        try:
            client = OpenAI(
                api_key=provider["api_key"],
                base_url=provider["base_url"],
            )
            return client.chat.completions.create(
                model=provider["model"],
                messages=messages,
            )
        except (RateLimitError, APIError) as e:
            print(f"{provider['base_url']} failed: {e}")
            continue
    raise RuntimeError("all providers exhausted")

À quoi sert chaque chemin gratuit ?

Chemin	Idéal pour	Moins adapté pour
OpenRouter gratuit	Prototypage, dev quotidien	SLA stricts
Inférence HF	Appels exploratoires, notebooks	Faible latence
Chutes	Expérimentation communautaire	Dépendances long terme
Essai DeepSeek	Tests production	Production soutenue
V4-Flash auto-hébergé	Conformité, autonomie	Équipes sans GPU

Calcul des quotas

OpenRouter gratuit : ~100 requêtes/jour/clé, ~50K jetons/chacune → 30-50 appels réels/jour.
Inférence HF gratuite : ~1K requêtes/jour/compte, latence variable.
Chutes : variable, à tester.
Essai DeepSeek (1 $) : ~700 appels de 10K jetons sur V4-Flash.
V4-Flash auto-hébergé : limité par votre matériel (ex : 4 × H100 = 50–150 tok/s).

Besoin de plus ? À 0,14 $/M sur V4-Flash, 10 000 appels de 2K contexte + 500 sortie coûtent ~2,80 $. Le payant devient optimal après prototypage.

Quand passer à l'API payante

Passez à l’API officielle lorsque :

Vous atteignez fréquemment les limites de débit.
Vous chaînez plusieurs fournisseurs juste pour tenir la charge.
Vos tests nécessitent une latence/SLA prévisible.

Le rechargement minimum sur platform.deepseek.com est de 2 $. Consultez le guide tarifaire DeepSeek V4.

FAQ

Un chemin gratuit est-il garanti ?

Non, ils changent sans préavis. Outils de prototypage uniquement.

OpenRouter :free délivre-t-il le vrai V4 ?

Oui, mais sur infra partagée et quotas stricts.

Usage commercial permis avec les chemins gratuits ?

Vérifiez les CGU. OpenRouter autorise pour usage limité, HF aussi mais restrictions. DeepSeek trial suit ses CGU principales.

Meilleure latence gratuite ?

Le propre crédit DeepSeek, suivi d’OpenRouter. HF et Chutes sont plus variables.

Auto-hébergement V4 gratuit ?

Licence MIT, oui. Le coût, c’est le matériel. Voir comment exécuter DeepSeek V4 localement.

Comment suivre quel chemin j'ai utilisé ?

Utilisez Apidog et épinglez usage dans le viewer, ou vérifiez les dashboards fournisseurs.

Comment Utiliser DeepSeek V4: Chat Web, API et Options Auto-Hébergées

Antoine Laurent — Fri, 24 Apr 2026 04:18:40 +0000

DeepSeek V4 a été lancé le 23 avril 2026 avec quatre checkpoints, une API en direct et des poids sous licence MIT sur Hugging Face. Vous pouvez l’utiliser en accès instantané, via API de production, ou en déploiement sur site. Ce guide montre comment choisir la meilleure approche selon vos besoins, détaille les compromis, et propose un flux de prompt prêt à l'emploi pour la production.

Essayez Apidog dès aujourd'hui

Si vous voulez une vue d’ensemble produit, lisez d'abord qu'est-ce que DeepSeek V4. Pour l’API complète, suivez le guide de l'API DeepSeek V4. Pour utiliser DeepSeek gratuitement, consultez comment utiliser DeepSeek V4 gratuitement. Pour tester les requêtes API, téléchargez Apidog et pré-construisez la collection.

TL;DR

Chemin le plus rapide : chat.deepseek.com. Chat web gratuit, V4-Pro par défaut, trois modes de raisonnement.
Chemin de production : https://api.deepseek.com/v1/chat/completions avec les modèles deepseek-v4-pro ou deepseek-v4-flash.
Chemin auto-hébergé : téléchargez les poids sur Hugging Face et exécutez les scripts /inference du dépôt.
Utilisez **Non-Think** pour le routage et la classification, **Think High** pour le code et l’analyse, **Think Max** seulement si la précision prime sur le coût.
Paramètres recommandés : temperature=1.0, top_p=1.0.
Apidog comme client API. Format compatible OpenAI : une requête sauvegardée fonctionne sur DeepSeek, OpenAI et Anthropic.

Choisissez le bon chemin pour votre charge de travail

Quatre options réalistes, chacune optimisée pour un usage différent :

Chemin	Coût	Temps d'installation	Idéal pour
chat.deepseek.com	Gratuit	30 secondes	Tests rapides, travail ad-hoc
API DeepSeek	Facturation par jeton	5 minutes	Production, agents, batchs
V4-Flash auto-hébergé	Coût matériel seulement	Quelques heures	Conformité, inférence hors-ligne
V4-Pro auto-hébergé	Coût cluster seulement	Une journée	Recherche, ajustements personnalisés
OpenRouter / agrégateur	Facturation par jeton	2 minutes	Multi-fournisseurs

Chemin 1 : Utiliser V4 dans le chat web

Pour tester V4 rapidement :

Accédez à chat.deepseek.com.
Connectez-vous (email, Google, WeChat).
V4-Pro est par défaut. Sélectionnez Non-Think, Think High ou Think Max en haut du composeur.
Saisissez votre prompt.

Le chat web prend en charge les uploads de fichiers, la recherche web, et jusqu'à 1M de jetons de contexte. Utilisez-le pour diagnostiquer une trace d’erreur, résumer un PDF volumineux, ou comparer V4 à GPT-5.5/Claude. À éviter pour les automatisations ou les tâches répétables.

Chemin 2 : Utiliser l'API DeepSeek

L’API DeepSeek est compatible OpenAI et adaptée à la production. Les modèles deepseek-v4-pro et deepseek-v4-flash sont maintenus après la dépréciation de deepseek-chat (juillet 2026).

Obtenir une clé API

Inscrivez-vous sur platform.deepseek.com.
Ajoutez un moyen de paiement (minimum 2 $).
Créez une clé API dans Clés API et copiez-la (visible une seule fois).

Exportez la clé pour vos clients :

export DEEPSEEK_API_KEY="sk-..."

Exemple de requête minimale

Utilisez l’interface compatible OpenAI :

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Refactor this Python function to async. Reply with code only."}
    ],
    "thinking_mode": "thinking"
  }'

Remplacez deepseek-v4-pro par deepseek-v4-flash pour réduire les coûts, et thinking par non-thinking pour la rapidité.

Client Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a concise senior engineer."},
        {"role": "user", "content": "Explain the CSA+HCA hybrid attention stack."},
    ],
    extra_body={"thinking_mode": "thinking_max"},
    temperature=1.0,
    top_p=1.0,
)

print(response.choices[0].message.content)

Client Node

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [{ role: "user", content: "Write a fizzbuzz in Rust." }],
  temperature: 1.0,
  top_p: 1.0,
});

console.log(response.choices[0].message.content);

Pour les détails avancés (paramètres, gestion erreurs), voir le guide de l'API DeepSeek V4.

Chemin 3 : Itérer avec Apidog

Curl suffit pour un test, mais Apidog permet d’itérer efficacement sans gaspiller de crédits ni surcharger le terminal.

Téléchargez Apidog pour Mac, Windows ou Linux.
Créez un projet API, ajoutez une requête POST vers https://api.deepseek.com/v1/chat/completions.
Ajoutez l’en-tête Authorization: Bearer {{DEEPSEEK_API_KEY}} et stockez la clé en variable d’environnement.
Collez le JSON du corps de requête, sauvegardez. Chaque modification est rejouable en un clic.
Utilisez la visionneuse intégrée pour comparer Non-Think vs Think Max sur un même prompt.

Vous pouvez mixer des requêtes OpenAI, Claude et DeepSeek dans une même collection pour des tests A/B multi-fournisseurs et un suivi centralisé de la facturation. Pour passer de GPT-5.5 à V4, changez juste l’URL de base. Voir la collection d’API GPT-5.5 correspondante.

Chemin 4 : Auto-héberger V4-Flash

Pour la conformité ou la maîtrise des coûts, la licence MIT permet l’auto-hébergement complet.

Matériel requis

V4-Flash (13B actif, 284B total) : 2–4 H100/H200/MI300X en FP8, ou une carte 80Go quantifiée INT4.
V4-Pro (49B actif, 1.6T total) : 16–32 H100 pour l’inférence production.

Télécharger les poids

# Installer le CLI Hugging Face
pip install -U "huggingface_hub[cli]"

# Connexion (V4 est public mais login = +de débit)
huggingface-cli login

# Télécharger V4-Flash
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

V4-Flash = ~500 Go (FP8). V4-Pro = plusieurs To.

Lancer l’inférence

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto

Une fois vLLM lancé, utilisez http://localhost:8000/v1 comme base URL dans vos clients compatibles OpenAI (ou Apidog).

Élaborer des prompts efficaces pour V4

Spécifiez explicitement le mode de raisonnement. Définissez thinking_mode pour chaque tâche.
Utilisez le prompt système pour la persona, pas pour la tâche. Décrivez la tâche dans le message utilisateur.
Pour le code, fournissez un harnais de test. Collez un test échoué à corriger plutôt qu’une demande vague.

Pour le contexte long, placez le contenu le plus important en début et fin d’input (biais de primauté/récence).

Contrôle des coûts

Utilisez V4-Flash par défaut. Passez à V4-Pro seulement si la qualité le justifie.
Préférez Non-Think. Passez à Think High pour les tâches complexes, Think Max pour les exigences critiques.
Limitez max_tokens. 1M est une limite haute, la plupart des réponses sont sous 2 000 tokens.

Dans Apidog, stockez DEEPSEEK_API_KEY dans l’environnement pour séparer facturation test/production. Apidog affiche aussi le nombre de tokens par réponse pour surveiller les prompts volumineux.

Migration depuis DeepSeek V3 ou autres modèles

Depuis deepseek-chat / deepseek-reasoner : remplacez l’ID modèle par deepseek-v4-pro ou deepseek-v4-flash avant le 24 juillet 2026.
Depuis OpenAI GPT-5.x : changez l’URL de base pour https://api.deepseek.com/v1 et l’ID modèle uniquement. Voir le guide GPT-5.5 pour la syntaxe.
Depuis Anthropic Claude : utilisez https://api.deepseek.com/anthropic pour garder le format message Anthropic, ou passez au format OpenAI avec le point de terminaison principal.

FAQ

Ai-je besoin d’un compte payant pour V4 ? Le chat web est gratuit. L’API nécessite un minimum de 2 $ de recharge. Voir comment utiliser DeepSeek V4 gratuitement pour les options sans frais.

Quelle variante utiliser par défaut ? V4-Flash en Non-Think, puis montez en gamme selon la qualité requise.

Puis-je exécuter V4 sur mon MacBook ? V4-Flash fonctionne sur M3/M4 Max avec 128 Go, lentement. V4-Pro non. Pour test local, préférez l’API ou le chat web.

V4 supporte-t-il l’appel de fonctions/outils ? Oui, le point compatible OpenAI accepte le champ tools. Les réponses incluent tool_calls. Le point Anthropic accepte le format natif.

Comment streamer les réponses ? Ajoutez stream: true dans le body. Flux SSE standard compatible OpenAI.

Y a-t-il une limite de débit ? L’API hébergée indique les limites par niveau sur api-docs.deepseek.com. En auto-hébergement, seule la capacité du matériel limite le débit.

Prix GPT-5.5 : Analyse Complète des Coûts API, Codex et ChatGPT (Avril 2026)

Antoine Laurent — Fri, 24 Apr 2026 02:32:46 +0000

OpenAI a doublé le prix par jeton sur la gamme GPT-5 avec la sortie de GPT-5.5 le 23 avril 2026. Le prix d'entrée passe de 2,50 $ à 5,00 $ par million de jetons. Le prix de sortie passe de 15,00 $ à 30,00 $ par million. La tarification Pro reste fixe à 30 $ / 180 $. C'est le titre ; les détails sont là où le coût réel se trouve.

Essayez Apidog dès aujourd'hui

Ce guide couvre toutes les surfaces de tarification : API standard, Batch, Flex et Priorité ; la tarification Pro ; les limites Codex par plan ; et comment calculer le coût de votre charge de travail réelle avant de vous engager dans un changement de modèle par défaut.

Pour un aperçu du modèle, consultez Qu'est-ce que GPT-5.5. Pour le guide du développeur, consultez Comment utiliser l'API GPT-5.5.

En bref

Surface	Entrée / M	Sortie / M
API standard GPT-5.5	$5.00	$30.00
API Pro GPT-5.5	$30.00	$180.00
Batch GPT-5.5 (50 % de réduction)	$2.50	$15.00
Flex GPT-5.5 (50 % de réduction)	$2.50	$15.00
Priorité GPT-5.5 (2.5×)	$12.50	$75.00
API standard GPT-5.4	$2.50	$15.00
API GPT-5.4-mini	$0.25	$2.00

Effet net : GPT-5.5 est 2× GPT-5.4 au niveau du jeton, mais OpenAI revendique une augmentation nette d'environ 20 % de l'indice d'intelligence une fois l'efficacité des jetons prise en compte.

Les chiffres clés

OpenAI a publié les tarifs sur la page de tarification de l'API le jour même du lancement.

GPT-5.5 : 5,00 $ par million de jetons d'entrée, 30,00 $ par million de jetons de sortie.
GPT-5.5 Pro : 30,00 $ par million de jetons d'entrée, 180,00 $ par million de jetons de sortie.
Fenêtre contextuelle : 1 million de jetons sur les deux variantes. Les jetons de raisonnement sont pris en compte dans la fenêtre et dans la facturation de la sortie.

Batch, Flex et Priorité

OpenAI propose trois niveaux alternatifs qui modifient le prix standard.

API Batch

Mettez les requêtes en file d'attente via le point de terminaison Batch et elles s'exécuteront à 50 % du prix standard. Le délai d'exécution est inférieur à 24 heures. Idéal pour :

Les évaluations nocturnes sur un ensemble de données complet.
Les compléments de données et le retraitement historique.
Tout flux de travail où le budget de latence se mesure en heures, et non en secondes.

Avec la tarification Batch, GPT-5.5 coûte 2,50 $ / 15,00 $ par million de jetons ; identique à la tarification standard de GPT-5.4. Pour les charges de travail hors ligne, le doublement du prix disparaît.

Traitement Flex

Flex vous offre également 50 % de réduction sur les tarifs standards, mais le temps d'attente est variable ; de quelques secondes à plusieurs minutes selon la charge. Utilisez Flex lorsque vous pouvez tolérer une latence imprévisible et que vous souhaitez une tarification de niveau Batch avec des réponses quasi-synchrones.

Traitement prioritaire

La Priorité coûte 2,5× le tarif standard (12,50 $ / 75,00 $ par million de jetons sur GPT-5.5) et vous offre un débit plus rapide, des plafonds de limite de débit plus élevés et un temps d'attente quasi nul. Réservez-le pour les expériences utilisateur en direct où la latence de queue impacte la rétention.

Calcul du coût en mode "Réflexion"

Le mode Réflexion de GPT-5.5 utilise le même ID de modèle avec un reasoning.effort plus élevé. Cela ne change pas le prix par jeton ; cela change le nombre de jetons qu'une seule requête utilise. Attendez-vous à ce que le multiplicateur se situe dans trois fourchettes.

Effort	Multiplicateur de jetons de sortie	Quand l'utiliser
`faible` (par défaut)	1×	La plupart des appels de routine
`moyen`	1.3–2×	Codage multi-étapes, génération structurée
`élevé`	2–4×	Recherche approfondie, révision critique pour la correction
`très élevé`	3–8×	Boucles d'agents avec chaînes d'outils, planification dense

Un seul appel très élevé sur une longue invite peut facilement consommer 20 000 jetons de raisonnement ; à 30 $ par million, cela représente 0,60 $ pour le raisonnement seul, en plus du coût des jetons de sortie finaux.

Budgettez par charge de travail, pas par requête.

Tarification Codex

L'accès à Codex est lié au plan ChatGPT, et non à la facturation par jeton. Au 23 avril 2026, la structure se présente comme suit.

Plan	Accès Codex	GPT-5.5	Notes
Gratuit	Oui (temps limité)	Oui	Plafonds hebdomadaires stricts
Go	Oui (temps limité)	Oui	2× plafonds du plan Gratuit
Plus (20 $ / mois)	Oui	Oui	Plafonds standards
Pro (200 $ / mois)	Oui	Oui + Réflexion + Pro (dans ChatGPT)	Plafonds par utilisateur les plus élevés
Business	Oui	Oui	Basé sur le siège
Entreprise / Éducation	Oui	Oui	Basé sur contrat

Pour les utilisateurs qui passent la majeure partie de leur temps dans un flux de travail de codage en terminal, Plus ou Pro est le moyen le moins cher d'utiliser GPT-5.5 ; le forfait mensuel bat même la tarification Batch une fois que vous dépassez quelques centaines de milliers de jetons par jour. Le guide du chemin gratuit couvre le point d'entrée sans coût.

Comparaison : GPT-5.5 vs le reste de la gamme

Quand devez-vous payer pour GPT-5.5 et quand devez-vous conserver GPT-5.4 ou GPT-5.4-mini ? Le calcul du coût dépend de l'intensité de sortie de votre charge de travail.

Modèle	Entrée / M	Sortie / M	Coût par 1 000 jetons de sortie
GPT-5.4-mini	$0.25	$2.00	$0.0020
GPT-5.4	$2.50	$15.00	$0.0150
GPT-5.5	$5.00	$30.00	$0.0300
GPT-5.5 Pro	$30.00	$180.00	$0.1800

Un flux de décision sommaire :

Sortie à volume élevé et à faible risque (classification, résumé, chat simple) : GPT-5.4-mini.
Trafic de production général où 5.4 respecte déjà les critères de qualité : GPT-5.4.
Codage complexe, travail d'agent multi-étapes, chaînes de recherche : GPT-5.5.
Sortie critique pour la correction où une mauvaise réponse est coûteuse à détecter en aval : GPT-5.5 Pro.

Exemple concret : coût d'un agent de codage par tâche

Une session de codage agentique typique via l'API sur GPT-5.5 avec reasoning.effort: "medium" se présente comme suit.

Jetons d'entrée par tâche (contexte du dépôt + invite utilisateur) : ~15 000
Jetons de sortie par tâche (code + explications) : ~3 000
Jetons de raisonnement par tâche (effort moyen) : ~6 000

Coût par tâche avec la tarification standard :

Entrée : 15 K × 5,00 $ / M = 0,075 $
Sortie : (3 K + 6 K) × 30,00 $ / M = 0,27 $
Total : 0,345 $ par tâche de codage terminée.

Exécution de la même charge de travail sur GPT-5.4 :

Entrée : 15 K × 2,50 $ / M = 0,0375 $
Sortie : 9 K × 15,00 $ / M = 0,135 $
Total : 0,1725 $ par tâche de codage terminée.

GPT-5.5 coûte exactement 2× plus par tâche pour le même effort de raisonnement. La mise à niveau est rentable lorsque l'écart SWE-bench (88,7 % contre environ 74 %) permet de réaliser suffisamment de tâches avec succès pour éliminer un deuxième aller-retour. Si une tâche sur huit sur GPT-5.4 nécessite une réécriture manuelle, GPT-5.5 est globalement moins cher.

Contrôles de coûts à intégrer dès le premier jour

Cinq leviers pour maintenir les factures GPT-5.5 sous contrôle :

Plafonds stricts pour max_output_tokens. À chaque appel, à chaque fois. Par défaut à 2 000, sauf si vous avez explicitement besoin d'une sortie longue.
Schémas JSON stricts. Une sortie mal formée signifie des tentatives de réessai ; les tentatives de réessai sont un appel facturé au prix plein.
Routage par difficulté. Aiguillez les requêtes faciles vers GPT-5.4-mini ; faites remonter les difficiles vers GPT-5.5. Un routeur de 10 lignes économise plus que toute optimisation au niveau de l'invite.
Utilisez Batch pour tout ce qui est hors ligne. Évaluations, compléments de données, génération de rapports nocturnes ; le tout à 50 % de réduction.
Suivez usage.reasoning_tokens. La surprise de facturation sur GPT-5.5 est presque toujours liée aux dépenses en jetons de raisonnement à effort élevé. Soyez alerté.

Estimation du coût mensuel par plan

Si vous choisissez un niveau ChatGPT pour l'accès à GPT-5.5, voici ce que chaque plan comprend :

Plan	Prix mensuel	Meilleur usage
Gratuit	$0	Essayer GPT-5.5 via Codex avant de s'engager
Go	$4 / mois	Étudiants et utilisateurs légers souhaitant 2× les plafonds du plan Gratuit
Plus	$20 / mois	Développeurs individuels utilisant Codex + ChatGPT quotidiennement
Pro	$200 / mois	Utilisateurs expérimentés souhaitant Réflexion et Pro dans ChatGPT
Business	$25 / siège / mois	Équipes ayant besoin d'espaces de travail partagés
Entreprise / Éducation	Personnalisé	Basé sur contrat avec SLA

Pour quiconque exécute plus de ~4 millions de jetons de sortie par mois sur l'API, le plan Pro dans ChatGPT plus l'interface de ligne de commande (CLI) de Codex s'avère moins cher que la facturation API à l'usage, tant que la charge de travail tient dans la fenêtre contextuelle de 400 K de la CLI.

Signaux de changement de prix à surveiller

Deux signaux à suivre si vous établissez un budget à long terme :

La disponibilité générale (GA) de l'API GPT-5.5. Les prix pourraient baisser à mesure qu'OpenAI répond à la pression concurrentielle d'Anthropic Claude Mythos, de Gemini 3.5 et des modèles à poids ouverts évalués dans le classement Vellum.
Démocratisation du modèle Pro. OpenAI a historiquement baissé les prix du niveau Pro dans les 3 à 6 mois suivant chaque publication. Ne supposez pas que les 30 $ / 180 $ d'aujourd'hui sont permanents ; ne supposez pas non plus qu'ils baisseront.

FAQ

Le caching réduit-il le coût d'entrée ? Oui. Les jetons d'entrée mis en cache sur GPT-5.5 sont facturés à une fraction du tarif standard ; la page de tarification d'OpenAI indique le multiplicateur exact. Mettez en cache tout ce que vous réutilisez dans plus d'une requête (invites système, schémas d'outils, contexte de dépôt).

Y a-t-il une réduction de volume ? Pas une réduction publiée. Les contrats d'entreprise incluent souvent des tarifs personnalisés, et OpenAI ajuste les prix en fonction de l'utilisation soutenue. Parlez aux ventes au-delà de sept chiffres de dépenses annuelles.

Le mode "Réflexion" coûte-t-il en supplément en plus de la tarification par jeton ? Non. Il coûte plus cher parce qu'il utilise plus de jetons, pas parce que le tarif par jeton change.

L'utilisation de la CLI Codex est-elle facturée séparément de l'utilisation de l'API ? Seulement si vous vous connectez avec une clé API. Les connexions ChatGPT facturent le coût du plan ; les connexions par clé API facturent le compte basé sur l'utilisation.

Quel est le moyen le moins cher d'essayer GPT-5.5 ? Le plan Gratuit ou Go plus la CLI Codex. Consultez notre guide du chemin gratuit pour toutes les options sans coût.

Comment utiliser GPT-5.5 gratuitement avec Codex ?

Antoine Laurent — Fri, 24 Apr 2026 02:30:56 +0000

OpenAI a lancé GPT-5.5 le 23 avril 2026 et, dans le cadre de ce lancement, a déployé Codex sur tous les forfaits ChatGPT, y compris les versions Gratuite et Go, pour une durée limitée. Cette seule phrase dans l'annonce représente le chemin gratuit le plus rapide vers le nouveau modèle : installez le CLI Codex, connectez-vous avec un compte ChatGPT, et utilisez GPT-5.5 depuis le terminal sans clé API ni carte de crédit.

Essayez Apidog dès aujourd'hui

Ce guide vous présente l'installation, les options d'authentification, le changement de modèle, les limites que vous rencontrerez et comment intégrer Codex dans un flux de travail de codage réel. Pour un aperçu du modèle sous-jacent, consultez Qu'est-ce que GPT-5.5. Pour d'autres chemins gratuits (crédits d'essai, agrégateurs), consultez notre guide GPT-5.5 gratuit.

TL;DR

Le CLI Codex exécute GPT-5.5 sur votre dépôt local avec une fenêtre de contexte de 400 K.
ChatGPT Gratuit, Go, Plus, Pro, Business, Enterprise et Édu ont tous accès à Codex ; les versions Gratuite et Go sont à durée limitée.
Installez avec npm install -g @openai/codex ou brew install codex.
Connectez-vous via ChatGPT OAuth dans un navigateur, ou utilisez le flux de code d'appareil sur des machines sans interface graphique.
Changez de modèle en cours de session avec /model gpt-5.5 ; vérifiez le quota avec /status.
Associez le CLI à Apidog afin que les appels API que vous exécuterez finalement en production soient pré-construits et testés.

Pourquoi Codex est le chemin gratuit le plus simple

L'API d'OpenAI est payante par défaut ; GPT-5.5 sur le point de terminaison Réponses coûte 5 $ par million de jetons d'entrée et 30 $ par million de jetons de sortie une fois qu'il est généralisé. Codex contourne cela en enveloppant le même modèle dans un CLI qui s'authentifie via un compte ChatGPT au lieu d'une clé API. Le niveau du forfait détermine la limite de débit ; le modèle sous-jacent est le véritable GPT-5.5.

Installer le CLI Codex

Deux méthodes d'installation prises en charge :

# npm (multiplateforme)
npm install -g @openai/codex

# ou Homebrew (macOS / Linux)
brew install codex

Vérifiez l'installation :

codex --version

Vous devriez voir une version égale ou supérieure à 0.28.0 ; les versions antérieures ne listent pas GPT-5.5 dans le sélecteur de modèle.

S'authentifier avec un compte ChatGPT

Exécutez le CLI pour la première fois et choisissez une méthode de connexion.

OAuth par navigateur (machines locales)

codex

Un onglet de navigateur s'ouvre. Connectez-vous avec l'e-mail de votre compte ChatGPT. La session est mise en cache pour les prochaines exécutions.

Flux de code d'appareil (machines sans interface graphique, serveurs distants)

codex login --device-auth

Le terminal affiche un code court et une URL. Ouvrez l'URL sur un autre appareil, collez le code, confirmez. La connexion est établie dès validation.

Option de secours par clé API

printenv OPENAI_API_KEY | codex login --with-api-key

Ce mode facture l’usage sur le compte de la clé API, pas le forfait ChatGPT. Utilisez-le si vous voulez que l’utilisation soit imputée à l’organisation API payante de l’équipe.

Choisir GPT-5.5 comme modèle

Codex utilise par défaut le modèle « recommandé » selon votre forfait. Sur les forfaits payants, c’est déjà gpt-5.5. Sur Gratuite et Go, sélectionnez-le manuellement :

En cours de session

/model gpt-5.5

Le CLI affiche le modèle actif et les limites de débit.

Depuis le drapeau de lancement

codex --model gpt-5.5

Vérifier le quota restant

/status

La sortie affiche les budgets de messages, la fenêtre de contexte et l’heure d’expiration de la fenêtre Gratuite/Go.

Première session : un exemple réaliste

Codex offre une interface terminal en plein écran capable de lire le dépôt, exécuter des commandes et éditer des fichiers. Exemple de workflow :

cd ~/Projects/my-app
codex --model gpt-5.5

Dans la session :

> Lisez README.md, puis ouvrez scripts/deploy.sh et résumez ce qu'il fait en cinq points.

Codex ouvre, lit et résume le fichier.

> Refactorisez deploy.sh afin qu'il se termine à chaque étape échouée, et ajoutez un drapeau dry-run. Maintenez la compatibilité ascendante.

GPT-5.5 propose un diff, attend l’approbation, puis applique.

> Exécutez la suite de tests de déploiement et montrez-moi le cas d'échec.

Le CLI diffuse la sortie des tests. Corrigez les erreurs via la boucle Codex jusqu’à résolution.

GPT-5.5 est optimisé pour ce type de scénario : travail multifichier, usage d’outils, pilotage terminal. Le billet de lancement d’OpenAI indique un score SWE-bench à 88,7 % (contre 74 % sur GPT-5.4).

Ce que Codex vous offre et que les appels API bruts n'offrent pas

Le CLI fournit :

Contexte du dépôt : lecture de l’arborescence, indexation des fichiers, envoi de descripteurs et non du contenu collé. Les 400K de contexte sont réservés aux vrais outils et sorties.
Exécution de commandes avec approbations : suggestion de commandes, validation manuelle avant exécution.
Aperçus des différences avant les écritures : chaque modification s’affiche sous forme de diff ; acceptez, rejetez ou modifiez.
Persistance de session : historique de projet, reprise du contexte à la prochaine ouverture.

Sans Codex, il faudrait implémenter ces fonctionnalités au-dessus de l’API Responses. Notre guide de l’API GPT-5.5 montre la version bare-metal, mais pour le quotidien, le CLI est bien plus ergonomique.

Limites de débit et plafonds par forfait

Au 23 avril 2026, la structure est :

Forfait	Accès GPT-5.5 dans Codex	Plafonnement hebdomadaire
Gratuit	Oui (durée limitée)	Strict ; taille prototype
Go	Oui (durée limitée), 2× limites Gratuites	Petit
Plus	Oui	Moyen
Pro	Oui, plafonds les plus élevés utilisateurs solo	Élevé
Business	Oui, basé sur le nombre de sièges	Élevé par siège
Enterprise / Édu	Oui, basé sur contrat	Personnalisé

Lorsque le plafond est atteint, Codex renvoie une erreur spécifique au forfait. La commande /status affiche le quota restant.

Intégration avec les éditeurs et IDE

La même authentification Codex fonctionne dans l’extension VS Code, le plugin JetBrains et l’application cloud Codex. Après connexion via le CLI, l’extension IDE réutilise l’authentification.

Pour les utilisateurs d’Apidog, adoptez ce workflow :

Prototyper une requête dans le CLI Codex (exécutez l'invite GPT-5.5 sur ce fichier).
Exporter l’invite et la sortie dans une collection Apidog pour partage.
Remplacer le chemin Codex par un appel API direct une fois le contrat stabilisé.

Voir Apidog dans VS Code pour intégrer la collection dans l’éditeur.

Maintenir la sécurité du flux de travail sur Gratuite et Go

Mettez en place dès le départ :

Approbation systématique des écritures de fichiers : dans ~/.codex/config.json, définissez "autoApproveWrites": false. Par défaut c’est déjà le cas sur Gratuite, mais sur Go certaines écritures triviales sont auto-appliquées.
Limitez l’espace de travail : lancez codex uniquement dans le dossier projet. Ne donnez pas accès à ~, sinon le CLI pourra lire tout votre dossier personnel.

OpenAI a fait auditer GPT-5.5 en sécurité par un tiers ; la couverture CNBC du lancement détaille le red-teaming. Mais le CLI s’exécute sur votre machine : révisez toujours les diffs avant de les appliquer.

Quand quitter le chemin gratuit

« Durée limitée » veut dire que Gratuite et Go demanderont une migration. Voici quand passer à une offre supérieure :

Quota dépassé chaque semaine : passez à Plus ou Pro.
Besoin de l’API directe : votre charge de travail dépasse le CLI ; voir le guide de l’API GPT-5.5.
Facturation par siège équipe : Business ou Enterprise via la répartition des prix.

La migration ne change que la facturation et l’interface, pas le modèle.

FAQ

Codex exécute-t-il également GPT-5.5 Pro ?

La version Pro n’est pas exposée dans Codex actuellement. Le CLI utilise le GPT-5.5 standard pour tous les forfaits ; Pro reste sur ChatGPT ou (bientôt) l’API.

Puis-je utiliser Codex sans compte ChatGPT ?

Non. Il faut un compte ChatGPT ou une clé API OpenAI. Le chemin gratuit exige une connexion ChatGPT.

Combien de temps durera l’accès Gratuite et Go ?

OpenAI annonce « pour une durée limitée ». Comptez de quelques semaines à quelques mois, prévoyez d’upgrader si votre usage augmente.

Codex fonctionne-t-il hors ligne ?

Non. Chaque appel GPT-5.5 nécessite un aller-retour vers OpenAI.

En quoi cela diffère-t-il de l’application web ChatGPT ?

Codex s’exécute en terminal, accède au système de fichiers local, au shell, et au contexte du dépôt. L’application web ne propose pas ces accès.

Comment Utiliser l'API GPT-5.5 Gratuitement

Antoine Laurent — Fri, 24 Apr 2026 02:18:13 +0000

GPT-5.5 a été lancé le 23 avril 2026 avec un mur de paiement pour la plupart des services : Plus, Pro, Business et Enterprise dans ChatGPT, et des jetons d'API payants pour les appels programmatiques. Cependant, trois voies gratuites fonctionnent aujourd'hui. Si vous acceptez des limites de débit et une expiration à terme, vous pouvez exécuter de vrais appels GPT-5.5 sans ajouter de mode de paiement.

Essayez Apidog dès aujourd'hui

Ce guide détaille chaque voie gratuite vérifiée, leur adéquation selon le cas d'usage, et comment pré-construire une collection prête pour la production dans Apidog afin de passer du niveau gratuit au payant sans friction.

TL;DR

Codex CLI sur ChatGPT Gratuit ou Go — accès gratuit temporaire à GPT-5.5 via l’outil CLI Codex. Pas de carte requise, fonctionne aujourd’hui.
Crédit d’essai OpenAI pour nouveaux comptes API — petit solde de démarrage qui débloque des appels GPT-5.5 quand l'API s'ouvre.
Niveaux gratuits d'OpenRouter et agrégateurs — passerelles tierces offrant parfois un quota gratuit sur les nouveaux modèles dans les jours suivant le lancement.
Chaque voie a ses limites. Passez au payant pour toute charge de travail en production.

Voie 1 : Codex CLI (la plus pratique)

OpenAI inclut Codex dans tous les plans ChatGPT au lancement, y compris Gratuit et Go, pour une durée limitée. Codex expose GPT-5.5 via ChatGPT (pas de clé API). Connectez-vous avec un compte gratuit, lancez le CLI, le modèle répond sur une fenêtre de 400 K jetons.

Installation

npm install -g @openai/codex
# ou
brew install codex

Vérifiez l'installation :

codex --version

Authentification

Lancez codex la première fois : un navigateur s’ouvre pour l’authentification OAuth ChatGPT. Sur une machine sans interface graphique :

codex login --device-auth

Un flux de code de périphérique vous donne une URL courte et un code — aucun besoin de clé API.

Choisir le modèle

Dans une session Codex active :

/model gpt-5.5

Ou démarrez le CLI directement :

codex --model gpt-5.5

Vérifiez le quota restant avec /status. Sur Gratuit/Go les limites sont strictes, mais suffisent pour prototyper.

Ce que vous obtenez / pas

Vous accédez au vrai modèle GPT-5.5 : contexte 400K, lectures de fichiers, exécution terminal, modifications de dépôt dans le CLI. Pas d’accès direct à l’API : tout passe par Codex connecté. Pour le guide complet, voir notre guide GPT-5.5 gratuit avec Codex.

Comme l’accès est « temporaire », structurez votre projet pour rendre l’ID du modèle configurable. Quand l’essai expire, passez au payant ou à l’API sans réécrire.

Voie 2 : Crédit d’essai OpenAI pour nouveaux comptes API

Créer un nouveau compte développeur OpenAI donne souvent un petit crédit d’essai (ex : 5 $ pour 90 jours, parfois plus pour les emails .edu). Dès que l’API GPT-5.5 est ouverte, ce crédit permet d’appeler gpt-5.5.

Mode d’emploi

Créez un nouveau compte sur platform.openai.com avec un email jamais utilisé pour OpenAI.
Vérifiez le numéro de téléphone (obligatoire pour le crédit).
Créez une clé API limitée à un projet sous l’organisation d’essai.
Vérifiez le montant de la subvention et la date d’expiration sur le dashboard.

Utilisation sur GPT-5.5

Avec 5 $ de crédit et un prix de 5 $/M jetons input, 30 $/M output, cela donne env. 1M jetons input ou 160K output — suffisant pour tester un prototype, pas pour la prod.

Optimisation du crédit :

Mode Batch : requêtes via l’API Batch = 50 % de réduction, idéal pour les traitements différés. Voir tarification OpenAI.
reasoning.effort à low : Les exécutions "réflexion" épuisent vite le budget. Gardez la valeur par défaut low pour les usages courants.

Limite

Le crédit d’essai n’est pas renouvelable. Une fois épuisé, les requêtes GPT-5.5 renvoient 402, et pas de second essai via le même utilisateur/téléphone/carte.

Voie 3 : Niveaux gratuits des agrégateurs

Des plateformes comme OpenRouter, Together, Groq offrent parfois un quota gratuit sur les modèles OpenAI tout juste lancés. Disponibilité variable : vérifiez le jour même.

Procédure classique pour un agrégateur :

Créez un compte, validez l’email.
Générez une clé API d’agrégateur.
Remplacez l’URL de base OpenAI par celle de l’agrégateur dans votre SDK.
Modifiez la chaîne modèle pour l’alias agrégateur (ex : openai/gpt-5.5).

Exemple en Python :

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-...",
)

response = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[{"role": "user", "content": "Explain the Responses API in two paragraphs."}],
)

print(response.choices[0].message.content)

Limites : débit propre à l’agrégateur, quota partagé, et le niveau gratuit disparaît parfois du jour au lendemain (erreur 402 ou 429). À utiliser pour prototypage, pas en production.

Quelle voie gratuite choisir ?

Cas d'utilisation	Meilleure voie gratuite
Assistant de codage basé sur le terminal	Codex CLI (Voie 1)
Expérimentations rapides en Python ou Node	Crédit d’essai (Voie 2)
Test depuis une application hébergée	Agrégateur (Voie 3)
Comparaison GPT-5.5 vs GPT-5.4 sur des requêtes réelles	Crédit d’essai + collection Apidog
Recherche ponctuelle « cela peut-il répondre à ma question »	ChatGPT Plus (pas gratuit, mais le moins cher par heure)

Pour tout ce qui dépasse un prototype, les trois voies atteignent vite leurs limites. L’objectif : apprendre à structurer les requêtes et ajuster les prompts avant de passer au payant.

Pré-construire la requête dans Apidog

Le plus efficace pour migrer du gratuit au payant sans réécriture : construire la requête une fois, versionner la collection.

Dans Apidog :

Créez une nouvelle collection, ajoutez une requête POST https://api.openai.com/v1/responses.
Définissez l’en-tête d’authentification via une variable d’environnement pour pouvoir changer la clé sans modifier le corps.
Stockez une réponse exemple pour que les devs puissent travailler sur une maquette même sans clé.
Clonez la collection pour l’agrégateur : pointez baseUrl vers OpenRouter et modifiez la chaîne modèle.

Quand l’essai expire ou que vous passez au payant, il suffit de basculer la variable d’environnement et la collection continue de fonctionner. Voir aussi la présentation d’Apidog dans VS Code pour une intégration à Cursor ou Claude Code.

Limitations des voies gratuites

Limites de débit fluctuantes : Codex Gratuit/Go ralentit aux heures de pointe.
Crédit d’essai non cumulable : pas de second essai si carte/téléphone/IP déjà utilisés.
GPT-5.5 Pro jamais inclus dans le gratuit : réservé aux plans payants.
Mode réflexion = budget vite épuisé : gardez reasoning.effort à low sauf test critique.
Fenêtres gratuites temporaires : accès Codex Gratuit/Go explicitement « pour une durée limitée » (annonce OpenAI).

Un prototype réaliste au niveau gratuit

Pour maximiser le quota gratuit :

Choisissez une tâche réelle : rapport, revue de code, note de recherche…
Exécutez 10 exemples via GPT-5.4 sur vos outils existants, notez la qualité.
Refaites les mêmes exemples via GPT-5.5 (Codex CLI ou crédit d’essai).
Comparez rendement par jeton et taux d’erreur.
Décidez si la montée de version justifie le surcoût pour votre cas.

C’est un test réalisable en une après-midi, qui optimise vos dépenses dès le premier mois de production.

FAQ

L’essai gratuit Codex et Go est-il permanent ?

Non. L’annonce OpenAI indique « durée limitée ». Prévoyez la fin dans les mois suivant le lancement.

ChatGPT Gratuit donne-t-il GPT-5.5 dans le navigateur ?

Non. ChatGPT Gratuit reste sur GPT-5.3. GPT-5.5 dans ChatGPT nécessite Plus ou supérieur.

Peut-on exécuter GPT-5.5 sur Hugging Face ou Ollama gratuitement ?

Non. GPT-5.5 est à poids fermé, uniquement via OpenAI ou Codex.

Réduction étudiant ?

OpenAI propose parfois des crédits/avantages pour emails .edu. Voir la page éducation OpenAI.

Comment passer du gratuit au payant sans réécrire ?

Gérez clés et URL de base via variables d’environnement (OPENAI_API_KEY, OPENAI_BASE_URL). Changez-les quand l’essai expire. Voir notre guide de l’API GPT-5.5 pour de bonnes pratiques sur les clés projet.

Comment utiliser l'API GPT-5.5

Antoine Laurent — Fri, 24 Apr 2026 02:14:57 +0000

GPT-5.5 a été lancé le 23 avril 2026. Pour les développeurs, la nouveauté clé : OpenAI a ouvert le modèle dans ChatGPT et Codex dès le premier jour, et promet l'accès aux endpoints API Responses et Chat Completions « très bientôt ». Ce guide explique comment appeler GPT-5.5 dès que les clés sont actives, et comment l'utiliser aujourd'hui via Codex.

Essayez Apidog dès aujourd'hui

Vous trouverez ici la structure des endpoints, l’authentification, des exemples concrets en Python et Node.js, le tableau complet des paramètres, le calcul des coûts en mode réflexion, la gestion des erreurs, et un workflow de test optimisé dans Apidog pour économiser vos crédits lors des itérations.

Pour une vue d’ensemble du modèle côté produit, consultez Qu'est-ce que GPT-5.5. Pour une méthode gratuite, lisez Comment utiliser l'API GPT-5.5 gratuitement.

En bref

Endpoints : Responses et Chat Completions. ID de modèle : gpt-5.5. Version Pro : gpt-5.5-pro.
Tarification API : 5 $ / M tokens entrée, 30 $ / M tokens sortie. Pro : 30 $ / M entrée, 180 $ / M sortie.
Fenêtre contextuelle : 1 M tokens (API), 400 K (CLI Codex).
Tant que l’API n’est pas ouverte à tous, utilisez GPT-5.5 via Codex en vous connectant avec un compte ChatGPT.
Utilisez Apidog pour préconstruire votre collection. La requête ressemble à GPT-5.4, mais avec un nouvel ID de modèle et un bloc reasoning étendu.

Prérequis

Avant d’envoyer votre première requête, préparez :

Compte développeur OpenAI avec facturation activée. Un abonnement ChatGPT Plus/Pro ne remplace pas la facturation API.
Clé API avec accès à GPT-5. Privilégiez les clés projet pour la production.
SDK compatible gpt-5.5 : Python openai>=2.1.0, Node openai@5.1.0 ou plus récent.
Client API capable de rejouer les requêtes (curl pour le premier appel, puis outil type Apidog pour l’itération).

Exportez la clé une fois :

export OPENAI_API_KEY="sk-proj-..."

Endpoint et authentification

GPT-5.5 s’utilise sur les mêmes endpoints que GPT-5 :

POST https://api.openai.com/v1/responses
POST https://api.openai.com/v1/chat/completions

L’API Responses est la plus récente, supporte le mode réflexion, la recherche web et l’usage de l’ordinateur. Chat Completions reste compatible avec les intégrations historiques.

Authentification via Bearer token. Chaque requête inclut un JSON avec l’ID du modèle, le prompt ou tableau de messages, et les paramètres.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Summarize the last 10 releases of the openai/codex repo in three bullets.",
    "reasoning": { "effort": "medium" }
  }'

Réponse : un objet JSON avec un tableau output et un bloc usage détaillant les tokens (entrée, sortie, raisonnement). Les erreurs renvoient un code et un message lisible ; voir la section gestion des erreurs.

Paramètres de requête

Chaque champ du body contrôle coût ou comportement. Carte complète pour gpt-5.5 :

Paramètre	Type	Valeurs	Notes
`model`	string	`gpt-5.5`, `gpt-5.5-pro`	Obligatoire. Pro = coût x6.
`input` / `messages`	string/array	prompt ou tableau de chat	Obligatoire. `input` pour Responses, `messages` pour Chat Completions.
`reasoning.effort`	string	`none`, `low`, `medium`, `high`, `xhigh`	Défaut : `low`. `xhigh` = "Réflexion" (coût tokens élevé).
`max_output_tokens`	int	1 – 128000	Limite stricte de sortie (hors tokens de raisonnement).
`tools`	array	Function, web_search, file_search, computer_use, code_interpreter	Définitions d’outils ; le modèle les enchaîne dynamiquement.
`tool_choice`	string/object	`auto`, `none`, ou outil nommé	Force un outil précis si besoin.
`response_format`	object	`{ "type": "json_schema", "schema": {...} }`	Sortie structurée ; strict par défaut.
`stream`	bool	true / false	Events serveur. Tokens de raisonnement en events séparés.
`user`	string	libre	Pour détection d’abus ; passer un ID utilisateur haché.
`metadata`	object	16 paires clé-valeur max	Apparaît dans le dashboard OpenAI.
`seed`	int	32 bits	Déterminisme doux.
`temperature`	number	0 – 2	Ignoré si `reasoning.effort >= medium`.

Les champs influant le plus sur le coût : reasoning.effort, max_output_tokens, tools. Les modes "Réflexion" (high ou xhigh) peuvent multiplier par 3 à 8 le coût par rapport à low.

Exemple Python

Utilisation du SDK Python (structure identique à GPT-5.4, seul l’ID change et la plage reasoning.effort s’étend) :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    input=[
        {
            "role": "system",
            "content": "You are a senior Go engineer. Answer in terse, runnable code.",
        },
        {
            "role": "user",
            "content": (
                "Write a worker pool with bounded concurrency and a context "
                "cancellation path. No third-party deps."
            ),
        },
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=4000,
)

print(response.output_text)
print(response.usage.model_dump())

Points clés :

response.output_text aplatit le tableau output. Pour des events structurés (appels outils, traces raisonnement, citations), lisez response.output.
usage fournit maintenant input_tokens, output_tokens, reasoning_tokens. La facturation est basée sur ces trois.

Exemple Node

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.5",
  input: [
    { role: "system", content: "You are a careful reviewer." },
    {
      role: "user",
      content:
        "Review this migration and flag any operation that would lock a write-heavy table for more than 200 ms.",
    },
  ],
  reasoning: { effort: "high" },
  tools: [{ type: "file_search" }],
  max_output_tokens: 6000,
});

console.log(response.output_text);
console.log(response.usage);

Définissez reasoning.effort: "high" pour les tâches de revue critique où un bug non détecté coûte plus cher que quelques centimes de tokens supplémentaires.

Mode de réflexion

Le mode de réflexion n'est pas un modèle distinct, mais une configuration : utilisez gpt-5.5 avec reasoning.effort: "high" ou "xhigh" + un max_output_tokens élevé. L’UI ChatGPT expose un switch ; en API, c’est vous qui le gérez.

Bonnes pratiques :

Par défaut, utilisez medium : couvre la plupart des tâches agentiques, débogage multi-fichiers, génération de docs.
Réservez high et xhigh pour recherche, révisions critiques, longues chaînes d’outils. Prévoyez de 3 à 8x plus de tokens, et surveillez le temps de réponse.

Pour des tâches complexes (computer_use, longues chaînes web), l’effort "Réflexion" réduit les hallucinations et améliore la fiabilité, comme documenté par OpenAI dans leur billet de lancement.

Sortie structurée

Le JSON strict est par défaut sur GPT-5.5. Passez un schéma pour garantir la structure :

response = client.responses.create(
    model="gpt-5.5",
    input="Extract the title, speaker, and start time from this transcript chunk.",
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "session_extract",
            "strict": True,
            "schema": {
                "type": "object",
                "required": ["title", "speaker", "start_time"],
                "properties": {
                    "title": {"type": "string"},
                    "speaker": {"type": "string"},
                    "start_time": {"type": "string", "format": "date-time"},
                },
            },
        },
    },
)

Pour toute pipeline downstream, définissez toujours un schéma pour éviter les boucles de retry sur JSON mal formé.

Utilisation d’outils et agents

L’API Responses expose 5 types d’outils :

web_search — recherche temps réel, avec citations.
file_search — recherche vectorielle sur fichiers uploadés.
code_interpreter — exécution Python sandboxée.
computer_use — souris, clavier et navigateur via Operator.
function — rappels custom.

L’avantage de GPT-5.5 : meilleure aptitude à chaîner et exploiter ces outils sans supervision. Lors des tests (The Decoder), GPT-5.5 a complété 11% de chaînes multi-étapes de plus que la 5.4, à prompt égal.

Gestion des erreurs et réessais

Quatre erreurs à traiter explicitement :

Code	Signification	Réessayer ?
`429 rate_limit_exceeded`	Limite minute/jour atteinte	Oui, backoff exponentiel + jitter
`400 context_length_exceeded`	Entrée + sortie + raisonnement > 1M tokens	Non, raccourcir l’entrée
`500 server_error`	Erreur transitoire OpenAI	Oui, jusqu’à 3 tentatives
`403 policy_violation`	Rejet pour violation de politique	Non, réécrire le prompt

Les tokens de raisonnement comptent dans la fenêtre contextuelle. Un appel reasoning.effort: "xhigh" sur 900K tokens d’entrée dépassera 1M avec peu de sortie.

Flux de travail de test avec Apidog

Tester GPT-5.5 coûte cher : évitez de brûler 20 prompts pour un bug de schéma. Voici le workflow le plus efficient :

Construisez la requête une fois dans Apidog, enregistrez-la dans une collection, taggez l’environnement (dev, staging, prod).
Utilisez le mock server intégré pour rejouer la dernière réponse réelle pendant vos itérations backend/front.
Passez en clé live uniquement lorsque le schéma est validé.

Apidog propose aussi une intégration Claude Code et Cursor : la même collection est accessible depuis votre éditeur. Lisez le guide Apidog dans VS Code et la comparaison Apidog vs. Postman pour la config complète.

Appeler GPT-5.5 avant que l’API ne soit générale

Tant que l’API Responses est en déploiement progressif, le chemin pour tester GPT-5.5 est via Codex. Le guide Codex gratuit explique comment installer la CLI, s’authentifier avec ChatGPT et sélectionner le modèle.

FAQ

Existe-t-il un gpt-5.5-mini ?

Non, pas au lancement. OpenAI maintient gpt-5.4-mini comme version optimisée coût.

Quelle est la fenêtre contextuelle ?

1M tokens (API), 400K (CLI Codex), tokens de raisonnement inclus.

Dois-je réécrire mon code GPT-5.4 ?

Non. Remplacez l’ID de modèle, augmentez max_output_tokens pour la réflexion, ajustez reasoning.effort selon la charge.

Comment réduire les coûts ?

Trois leviers : Batch (50% de réduction), Flex (50% avec une file plus lente), schémas stricts pour éviter les retries. Le calcul détaillé est disponible dans la répartition des prix GPT-5.5.

Où surveiller l’annonce de disponibilité générale de l’API ?

Suivez la communauté développeurs OpenAI et la page de tarification OpenAI.

DEV Community: Antoine Laurent

Facturation GitHub Copilot : Ce que les équipes API doivent savoir

En bref

Les trois indicateurs à suivre

1. Licence par siège

2. Requêtes premium

3. Minutes GitHub Actions pour la révision de code

Pourquoi les dépôts API coûtent souvent plus cher

1. Les pull requests touchent plus de fichiers

2. Le code généré augmente le volume à analyser

3. Plusieurs outils se déclenchent sur la même PR

Estimer votre facture mensuelle

Étape 1 : calculer les sièges

Étape 2 : calculer les requêtes premium

Étape 3 : calculer les minutes Actions de révision

Exemple

Adapter votre pipeline CI

1. Ignorer les PR de bots

2. Restreindre la révision aux chemins utiles

3. Échouer rapidement avant la révision Copilot

Gouvernance : quatre contrôles à mettre en place

1. Définir une limite de dépenses

2. Activer les alertes de requêtes premium

3. Utiliser une politique de déclenchement

4. Activer les fonctionnalités par équipe

Où placer Apidog dans le workflow

Que surveiller au prochain cycle de facturation

Jours 1 à 7

Jours 14 à 21

Jours 28 à 30

Erreurs courantes

1. Aucun plafond de dépenses

2. Révision activée sur tous les dépôts

3. Clients générés inclus dans la révision

4. PR de bots révisées

5. Pas de métriques de référence

FAQ

Le prix du siège est-il toujours de 10 $ par utilisateur ?

Les complétions en ligne sont-elles désormais mesurées ?

Que se passe-t-il quand le quota premium est épuisé ?

Les minutes Actions de révision sont-elles facturées séparément ?

Peut-on désactiver complètement Copilot Review ?

Copilot Review fonctionne-t-il sur des spécifications API privées ?

Copilot Review consomme-t-il aussi des requêtes premium ?

Comment utiliser l'API Zuplo ?

En bref

Prérequis

Étape 1 : Créez votre projet Zuplo

Option A : Portail

Option B : CLI

Étape 2 : Définissez votre première route

Étape 3 : Ajoutez l’authentification par clé API

Étape 4 : Limitez le débit de la route

Étape 5 : Validez les charges utiles des requêtes

Étape 6 : Écrivez une politique TypeScript personnalisée

Étape 7 : Déployez en périphérie

Étape 8 : Générez le portail développeur

Étape 9 : Testez tout avec Apidog

Questions fréquentes sur l’utilisation de Zuplo

Comment basculer une route entre les environnements sans modifier la spec ?

Puis-je exécuter Zuplo hors ligne ?

Comment annuler un mauvais déploiement ?

Que se passe-t-il pour les requêtes en cours durant un déploiement ?

Puis-je utiliser Zuplo avec gRPC ou WebSockets ?

Comment exposer mon API Zuplo aux agents IA ?

Combien coûte la passerelle en production ?

Conclusion

Qu'est-ce que la passerelle API Zuplo?

En bref

Qu’est-ce que Zuplo ?

Pourquoi choisir Zuplo plutôt que Kong, Apigee ou AWS API Gateway ?

Fonctionnalités principales de Zuplo

Programmabilité TypeScript-first

60+ politiques pré-construites

Portail développeur auto-généré

Monétisation API intégrée

Gestionnaire de serveur MCP (agents IA)

Déploiement edge, latence <50 ms

Comment fonctionne Zuplo sous le capot ?

Déployer rapidement votre première passerelle Zuplo

Option A : Portail

Option B : CLI

Étape 2 : Définissez votre première route

Étape 3 : Ajoutez l’authentification par clé API

Étape 4 : Limitez le débit de la route

Étape 5 : Validez les charges utiles des requêtes

Étape 6 : Écrivez une politique TypeScript personnalisée

Étape 7 : Déployez en périphérie

Étape 8 : Générez le portail développeur

Étape 9 : Testez tout avec Apidog

Comment basculer une route entre les environnements sans modifier la spec ?

Puis-je exécuter Zuplo hors ligne ?

Comment annuler un mauvais déploiement ?

Que se passe-t-il pour les requêtes en cours durant un déploiement ?

Puis-je utiliser Zuplo avec gRPC ou WebSockets ?

Comment exposer mon API Zuplo aux agents IA ?

Combien coûte la passerelle en production ?