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

Le modèle de facturation de GitHub Copilot a changé deux fois l'année dernière et a de nouveau changé ce mois-ci. À partir de ce mois-ci, la révision de code Copilot sur les pull requests commence à consommer des minutes GitHub Actions du compte de facturation propriétaire du dépôt. Combiné au quota de requêtes premium introduit le trimestre dernier, les équipes API gèrent désormais trois indicateurs à la fois : les licences Copilot, les requêtes premium et les minutes Actions. Ce guide explique ce que chaque indicateur mesure, comment la nouvelle facturation de la révision de code affecte particulièrement les dépôts API, et comment modéliser les coûts avant qu'ils n'apparaissent sur une facture.

Nous l'associons à la fin à un workflow à l'intérieur d'Apidog afin que la spécification API, les tests de contrat et les étapes de révision IA soient regroupés au même endroit plutôt que dispersés sur trois tableaux de bord de facturation.

Si vous estimez également le coût des API de modèles que votre équipe consomme directement, les guides approfondis sur la tarification de GPT-5.5 et la tarification de DeepSeek V4 couvrent l'aspect par jeton de la même conversation.

En bref

• Copilot dispose de trois indicateurs : la licence par siège, les requêtes premium (dépendantes du modèle) et désormais les minutes Actions pour la révision de code Copilot.
• La révision de code sur les PR s'exécute en tant qu'action GitHub en arrière-plan. Chaque révision consomme des minutes Actions par rapport à l'allocation normale d'Actions de l'organisation.
• Les dépôts API sont des consommateurs plus importants que la moyenne car les PR sont plus volumineuses (spécification + clients générés + gestionnaire + tests) et les révisions sont déclenchées par plusieurs agents.
• Les requêtes premium plafonnent le travail « agentique » (Workspace, mode agent, Espaces Copilot). Le chat standard et les complétions de code sont toujours illimités pour les niveaux payants.
• Fixez des limites de dépenses avant le prochain cycle de facturation. Prévoyez un budget d'environ 400 à 800 minutes Actions par mois par dépôt API actif et réévaluez après 30 jours.

Les trois indicateurs et ce qu'ils mesurent réellement

Copilot était auparavant une seule facture. Il y en a maintenant trois.

Indicateur 1 : Licence par siège

Le forfait. 10 $ par utilisateur et par mois pour Copilot Business, 19 $ par utilisateur et par mois pour Copilot Enterprise. Cela couvre le chat, les complétions en ligne, les suggestions multi-lignes, les intégrations IDE et l'accès au pool de modèles standard. Les sièges sont la ligne la plus facile à prévoir et la plus susceptible d'être sur-provisionnée. Auditez-les une fois par trimestre et récupérez les sièges des utilisateurs inactifs.

Indicateur 2 : Requêtes premium

Les requêtes premium sont la monnaie de GitHub pour les fonctionnalités les plus coûteuses. Tout ce qui s'exécute en mode agent, Workspace, Espaces Copilot ou la sélection de modèle au-delà du défaut compte comme une ou plusieurs requêtes premium selon le modèle.

Les tarifs actuels (sujets à révision) :

Chaque siège Copilot Business est livré avec 300 requêtes premium incluses par mois. Copilot Enterprise en inclut 1 000. Les dépassements sont facturés à 0,04 $ par requête, plafonnés par la limite de dépenses que vous avez fixée pour l'organisation.

Pour une équipe API, les requêtes qui font évoluer l'indicateur sont les tâches en mode agent comme « régénérer le client OpenAPI » ou « écrire un test de contrat pour ce nouveau point de terminaison ». Celles-ci ont tendance à être multi-étapes en interne, de sorte qu'une seule invite utilisateur peut se résoudre en quatre ou cinq requêtes premium.

Indicateur 3 : Minutes Actions (nouveau pour la révision de code)

C'est le changement qui a surpris les équipes ce mois-ci. Lorsque Copilot effectue une révision de code automatisée sur une pull request, la révision s'exécute en tant qu'action GitHub sous la même infrastructure Actions que votre CI utilise. Les minutes consommées par la révision sont débitées de l'allocation normale d'Actions de l'organisation.

Deux choses à savoir :

• Les minutes SONT incluses dans votre quota d'Actions des plans GitHub existants (3 000 min/mois pour Team, 50 000 pour Enterprise pour les runners Linux). Ce NE SONT PAS un quota séparé.
• Les révisions sur les dépôts privés coûtent plus cher que sur les dépôts publics car les Actions sur les dépôts privés sont mesurées par rapport à votre budget de minutes, tandis que les Actions sur les dépôts publics sont gratuites.

Une révision de code Copilot typique sur une pull request API consomme de 2 à 6 minutes Actions. Une révision importante (différence volumineuse, plusieurs fichiers, contexte complet du dépôt) peut atteindre 15 minutes. Multipliez cela par le nombre de PR que votre équipe fusionne et vous obtenez une ligne de dépense significative.

Pourquoi les dépôts API sollicitent davantage ces indicateurs

Trois propriétés des dépôts API amplifient le coût :

1. Les pull requests sont plus volumineuses. Un changement API typique touche la spécification (openapi.yaml), les clients générés dans deux ou trois langages, le gestionnaire de serveur et les tests de contrat. La révision Copilot les lit tous, dure plus longtemps et consomme plus de minutes qu'une modification frontend d'un seul fichier.
2. Le code généré fausse le nombre de jetons. Même lorsque les clients générés sont ignorés par Git, de nombreuses équipes les commettent. La révision les lit tous et facture ce privilège.
3. Plusieurs agents de révision se déclenchent par PR. Les équipes qui exécutent la révision Copilot en parallèle de CodeQL, Snyk et d'un scanner de sécurité personnalisé paient pour chacun d'eux séparément. Copilot est le nouvel arrivant ; les autres étaient déjà mesurés.

L'impact pratique : une équipe API fusionnant 50 PR par mois à 4 minutes par révision consomme 200 minutes Actions par mois uniquement pour la révision Copilot. Cela représente 7 % d'un quota mensuel de niveau Team pour un seul dépôt. Trois dépôts et vous êtes à 21 % avant toute exécution de CI.

Comment estimer votre facture mensuelle

Le chiffre qui prend les gens au dépourvu est le coût total, et non un seul indicateur. Établissez l'estimation en trois étapes.

Étape 1 : Sièges

Comptez les utilisateurs Copilot actifs et multipliez par le prix du siège.

sièges = utilisateurs_actifs × 10 $  (Business)
      = utilisateurs_actifs × 19 $  (Enterprise)

Étape 2 : Requêtes premium

Estimez par développeur et par mois. Un utilisateur intensif de Workspace utilise environ 600 à 800 requêtes ; un utilisateur de chat uniquement est plus proche de 150. Avec le quota inclus de 300 (Business), attendez-vous à ce que le dépassement commence du côté des utilisateurs intensifs.

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

Fixez une limite de dépenses au niveau de l'organisation afin qu'une boucle d'agent échappée ne dépasse pas votre budget. Le défaut est illimité, ce qui est le mauvais défaut pour toute équipe qui ne surveille pas activement.

Étape 3 : Minutes Actions pour la révision de code

Multipliez le nombre de PR fusionnées par mois par les minutes par révision. La moyenne de 4 minutes est raisonnable pour les PR API de taille moyenne.

minutes_révision = prs_par_mois × 4
dépassement_révision = max(0, minutes_révision - quota_actions_restant)
                 × 0,008 $  (dépôts privés Linux)

Empilez les trois. Pour une équipe de 10 développeurs fusionnant 200 PR par mois, les chiffres bruts s'établissent autour de :

• Sièges : 190 $ (Enterprise)
• Dépassement premium : 40 $ (utilisation modeste de l'agent)
• Minutes de révision : 800/mois, bien dans le quota Enterprise, 0 $
• Total : ~230 $ au-dessus du coût de base des sièges

Les équipes plus petites au niveau Business atteignent le dépassement plus rapidement car les quotas sont plus stricts. Une équipe Business de 5 développeurs fusionnant les mêmes 200 PR épuiserait le quota Actions et commencerait à payer 6 $ par 1 000 minutes de révision.

Ce qui change dans votre pipeline CI

Trois changements concrets de pipeline rentabilisent le coût du jour au lendemain.

1. Ignorez la révision Copilot sur les bots et les PR de dependabot. La plupart des équipes n'ont pas besoin de révision IA sur une mise à jour de Renovate. Ajoutez un filtre de chemin ou d'acteur au déclencheur de workflow.

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. Mettez en cache les différences des clients générés. Si votre dépôt régénère les clients à chaque PR, la révision lit la différence à chaque fois. Stockez la sortie générée derrière un hachage calculé et ignorez la tâche de révision lorsque le hachage correspond à la branche de base.

3. Exécutez la révision Copilot sur un filtre de chemin plus restreint pour les dépôts API. Limitez la révision aux fichiers de gestionnaire, de spécification et de test. Ignorez entièrement les clients générés. La qualité de la révision reste élevée ; les minutes diminuent de moitié.

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

Gouvernance : les quatre contrôles que chaque équipe API devrait mettre en place

Ces mesures prennent 20 minutes et préviennent la plupart des factures surprises.

1. Limite de dépenses. Définissez-la au niveau de l'organisation, et non au niveau du dépôt. La valeur par défaut est illimitée ; choisissez un montant qui ne vous ferait pas sourciller et arrondissez à la baisse de 20 %.
2. Alertes de requêtes premium. GitHub envoie des e-mails à 50, 75 et 90 % du quota inclus. Intégrez-les à Slack ou à votre outil d'incident afin qu'ils ne soient pas perdus dans les boîtes de réception.
3. Politique de dépôt sur les déclencheurs de révision. Décidez si la révision Copilot se déclenche sur chaque PR ou seulement sur les PR étiquetées review-please. Le modèle basé sur les étiquettes réduit les coûts d'environ 60 % sans perdre les révisions qui détectent de vrais problèmes.
4. Déploiement par équipe. Activez les fonctionnalités Copilot Enterprise par équipe plutôt qu'à l'échelle de l'organisation. Les nouvelles fonctionnalités sont livrées en option ; vous n'avez pas à absorber le coût de chaque version dès sa sortie.

La place d'Apidog

Apidog n'est pas un remplacement de Copilot ; c'est la couche qui maintient vos tests de contrat au sein d'un seul outil au lieu de trois. Le modèle qui maintient les coûts et la qualité prévisibles :

• Les exemples de spécifications et de requêtes sauvegardées résident dans la collection Apidog commise avec le dépôt.
• Les tests de contrat s'exécutent contre le serveur de maquette Apidog, et non l'API en direct. Les exécutions de maquette sont gratuites et rapides.
• La révision Copilot se concentre sur la logique du gestionnaire et la couverture des tests, et non sur la mise à jour de l'exemple de spécification.
• Le workflow CI exécute apidog-cli pour la validation des contrats en 30 secondes et ne déclenche la révision Copilot que si la validation réussit.

Cet ordonnancement est important car la révision Copilot est l'étape la plus coûteuse du pipeline. Échouer rapidement sur un problème de contrat permet d'économiser les minutes de révision pour le code qui les mérite réellement. Le guide de test API sans Postman couvre le workflow de maquette Apidog sous-jacent ; le guide API DeepSeek V4 montre le modèle appliqué à une API de modèle.

À quoi s'attendre lors du prochain cycle de facturation

Trois choses à noter dans votre calendrier :

• Jours 1 à 7 : L'utilisation des requêtes premium semble normale. La plupart des équipes restent en dessous du quota inclus de 300/siège durant la première semaine.
• Jours 14 à 21 : Les utilisateurs intensifs dépassent le quota inclus. Si vous avez défini une limite de dépenses, les requêtes commencent à échouer pour ces utilisateurs. Sans limite, la facture augmente.
• Jours 28 à 30 : L'utilisation des minutes Actions pour la révision Copilot s'accumule. C'est là que les équipes remarquent la nouvelle ligne de dépense. Comparez-la à la facture du mois précédent côte à côte.

Vérifiez à la fin du mois. Déplacez les utilisateurs intensifs vers le niveau Enterprise (1 000 requêtes incluses), supprimez les sièges des utilisateurs inactifs et resserrez le filtre de chemin sur le workflow de révision.

Erreurs courantes

Après avoir audité une douzaine d'équipes API le mois dernier, les cinq mêmes problèmes reviennent :

1. Pas de limite de dépenses. Une seule boucle d'agent peut fonctionner pendant des heures. Toujours plafonner.
2. Révision activée sur chaque dépôt. Choisissez les dépôts où la révision est réellement rentable. Désactivez-la ailleurs.
3. Clients générés révisés. Filtrez-les par chemin.
4. PR de bots révisées. Filtrez dependabot, renovate et tout autre outil de mise à jour automatique interne.
5. Pas de métriques de référence. Sans un instantané « avant », vous ne pouvez pas savoir si un changement de workflow a permis d'économiser de l'argent. L'interface de facturation de GitHub propose une exportation CSV ; téléchargez-la mensuellement.

FAQ

Le prix du siège est-il toujours de 10 $ par utilisateur ?Copilot Business est à 10 $ par utilisateur et par mois, Copilot Enterprise à 19 $ par utilisateur et par mois, et Copilot Pro pour les particuliers est à 10 $ par mois. Le niveau du siège définit le quota de requêtes premium inclus.

Les complétions en ligne sont-elles désormais mesurées ?Non. Le modèle par défaut pour le chat et les complétions en ligne n'est pas mesuré pour les niveaux payants. Les requêtes premium couvrent les fonctionnalités plus coûteuses et la sélection de modèle.

Que se passe-t-il lorsque mon quota premium est épuisé ?Par défaut, les requêtes commencent à échouer avec une erreur de quota. Vous pouvez définir une limite de dépenses pour autoriser les dépassements à 0,04 $ par requête jusqu'à cette limite.

Les nouvelles minutes Actions pour la révision de code sont-elles facturées séparément ?Non. Elles consomment le même pool de minutes Actions que le reste de votre CI. Suivez l'utilisation totale des Actions et ajustez les déclencheurs de workflow pour maintenir le budget en ligne.

Puis-je désactiver complètement la révision de code Copilot ?Oui. L'administrateur de l'organisation peut désactiver les dépôts au niveau de la politique. Le même paramètre contrôle l'inscription par équipe.

La révision Copilot fonctionnera-t-elle sur les spécifications API privées ?Oui. Les dépôts privés consomment des minutes Actions ; les dépôts publics sont gratuits. Le réviseur lit les fichiers de spécification et de gestionnaire comme toute autre source.

La révision Copilot utilise-t-elle également des requêtes premium ?Actuellement, elle ne consomme que 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. C'est la partie la plus susceptible de changer au cours du prochain trimestre ; consultez le journal des modifications de GitHub.

Pour les équipes exécutant à la fois la révision Copilot et les appels API de modèles directs en CI, le guide Codex gratuit GPT-5.5 couvre l'aspect par jeton et Apidog encapsule la couche de maquette et de contrat afin que la révision IA ne s'exécute que sur les PR qui passent d'abord les vérifications peu coûteuses.