Calculateur de facturation au token GitHub Copilot : projetez votre facture de juin

Ce qui change réellement le 1er juin

La facturation actuelle de GitHub compte des « Premium Requests » — une unité forfaitaire qui varie selon le modèle mais n'expose pas à l'utilisateur l'arithmétique des tokens sous-jacente. Après le 1er juin, ce système disparaît. À sa place : les AI Credits, où 1 crédit coûte 0,01 $ USD et où chaque modèle consomme un nombre différent de crédits par million de tokens.

Les prix des plans ne changent pas. Copilot Pro reste à 10 $/mois. Business à 19 $. Enterprise à 39 $. Ce qui change, c'est la mécanique des dépassements : au lieu de buter sur un plafond de requêtes et d'être bloqué, votre consommation de tokens fait courir un compteur. Si ce compteur dépasse les crédits inclus dans votre plan, le dépassement vous est facturé à 0,01 $ par crédit.

Chaque plan inclut une dotation de crédits correspondante : Pro reçoit 1 000 crédits (10 $ de valeur token), Business 1 900, Enterprise 3 900. L'arithmétique est intentionnelle — les crédits inclus égalent la valeur du plan, ce qui place l'utilisateur en pur token à l'équilibre. La question est de savoir si vos schémas d'usage vous poussent au-delà de ce seuil.

Les complétions de code et les Next-Edit Suggestions ne sont pas concernées. Elles restent gratuites sur tous les plans payants. Le compteur ne s'applique qu'aux interactions chat, aux éditions inline qui font appel à un modèle premium et aux sessions agentiques. C'est la distinction que GitHub a soigneusement préservée — la complétion par tabulation, à laquelle la plupart des utilisateurs associent Copilot, ne change pas de coût.

Les tarifs sont publiés sur docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing. Ils sont au million de tokens, libellés en USD, et séparés entre l'entrée (ce que vous envoyez) et la sortie (ce que le modèle renvoie). Les modèles Anthropic affichent en plus un tarif de lecture cache et un tarif d'écriture cache — voir plus bas.

Un point que l'annonce ne souligne pas : les tarifs au million publiés par GitHub correspondent aux tarifs API publics des fournisseurs sous-jacents au 28 avril 2026. Vous ne payez aucune marge sur les tokens. Vous payez l'intégration à l'IDE, la complétion par tabulation et la dotation de crédits incluse — puis les tarifs API bruts par-dessus si vous dépassez.

Tarification par token, modèle par modèle — tableau complet

Tous les tarifs sont au million de tokens, en USD, et proviennent de docs.github.com/.../models-and-pricing, en vigueur au 1er juin 2026. La colonne Cache Write ne s'applique qu'aux modèles Anthropic — pour OpenAI, Google et xAI, les écritures de cache sont facturées au tarif d'entrée standard.

Le rapport sortie/entrée varie selon le fournisseur. La gamme Sonnet d'Anthropic est à 5:1 (la sortie coûte 5 fois l'entrée). GPT-5 mini est à 8:1. Grok Code Fast 1 est à 7,5:1. Pour le travail agentique, qui produit en général de longues sorties, le tarif de sortie est le chiffre qui pèse le plus.

La formule — comment se calculent les crédits

L'arithmétique des crédits chez GitHub est directe. Chaque événement de workflow (un tour de chat, un pas agentique, une revue de code) consomme un certain nombre de tokens d'entrée et de sortie. Les modèles Anthropic peuvent en plus lire dans le cache ou y écrire. Vous additionnez les coûts, vous divisez par la valeur du crédit, et vous obtenez la consommation de crédits pour cet événement.

crédits = (
    tokens_entrée  × tarif_entrée_$/M
  + tokens_sortie  × tarif_sortie_$/M
  + tokens_cache   × tarif_cache_$/M
  + tokens_écriture_cache × tarif_écriture_cache_$/M   ← Anthropic uniquement
) ÷ 1 000 000 ÷ 0,01 $

La division par 1 000 000 convertit les tokens bruts en millions. La division par 0,01 $ convertit le coût en USD en crédits. Tout le reste est une multiplication par le tarif publié du modèle.

Exemple chiffré : session agentique sur Claude Sonnet 4

Une session agentique de complexité moyenne sur Claude Sonnet 4 — ouverture d'une base de code, écriture d'une fonctionnalité, passe de revue :

• 50 000 tokens d'entrée (fichiers lus, consignes, conversation précédente)
• 20 000 tokens de sortie (code écrit, explications renvoyées)
• 30 000 tokens en cache (contexte réutilisé depuis le cache)
• 10 000 tokens d'écriture cache (nouveau contexte écrit en cache)

Cette seule session agentique coûte 49,65 crédits — soit environ 5 % des 1 000 crédits inclus dans un plan Copilot Pro. Lancez-la 20 fois dans le mois et vous aurez consommé 993 crédits, presque la dotation entière. La 21e session déclenche le dépassement.

Notez que les tokens de sortie dominent : 0,30 $ sur le total de 0,4965 $, soit 60 %, viennent des 20K tokens de sortie — alors même que l'entrée représente 2,5 fois plus de tokens. C'est cette arithmétique qui rend le travail agentique cher comparé au chat.

Les workflows qui coûtent le plus

Tous les usages de Copilot ne se valent pas dans une facturation au token. L'écart entre un mois à 10 $ et un mois à 35 $ tient surtout au choix des workflows, pas au volume.

• Les sessions agentiques sont la classe coûteuse. Une seule session agentique Claude Sonnet 4 d'échelle modérée — 50K entrée, 20K sortie, 30K cache — coûte 49,65 crédits, comme montré plus haut. Lancez-en 22 dans un mois et vous arrivez à environ 1 093 crédits sur ce seul workflow. Ce n'est pas une session isolée qui tue le budget ; c'est qu'un développeur en travail agentique quotidien atteint facilement 20 à 30 sessions par mois.
• La revue de code sur Sonnet est l'accumulateur silencieux. Une revue de code unique : 8 000 entrée (diff + contexte), 2 500 sortie (commentaires de revue), 4 000 cache (historique de fichiers). Cela représente environ 14,6 crédits par revue. Huit revues par mois ajoutent environ 117 crédits — pas catastrophique, mais cela s'additionne avec l'usage agentique.
• Le chat sur modèles bon marché est presque gratuit. 150 sessions de chat par mois sur GPT-5 mini — 800 entrée, 400 sortie chacune — totalisent environ 15 crédits sur le mois. Moins de 2 % de la dotation Pro. Si vous n'utilisez Copilot que pour la conversation et la complétion par tabulation, le changement de juin est un non-événement.
• Les sessions de brainstorm sur Opus sont brèves mais coûteuses. Un seul brainstorm Opus 4.7 — 8K entrée, 4K sortie — coûte 22 crédits. Six dans le mois ajoutent 132 crédits. Le coût par session n'est pas ruineux, mais il rapproche de la limite plus vite que ne le pensent les utilisateurs, parce qu'Opus est généralement choisi pour des tâches complexes à longue sortie.
• L'effet multiplicateur. Les schémas ci-dessus sont additifs. Un développeur qui enchaîne sessions agentiques quotidiennes sur Sonnet, revues de code hebdomadaires et brainstorms Opus occasionnels touchera la dotation Pro avant la fin du premier mois.

L'enseignement pratique : si votre usage Copilot est dominé par la complétion par tabulation et un chat occasionnel, vous ne verrez probablement aucun changement de facture. Si vous lanciez des sessions agentiques — surtout multi-étapes, avec outils, sur Sonnet ou Opus — faites les comptes avant le 1er juin.

Trois profils d'usage — factures projetées de juin

Ces projections sortent du Septim Meter CLI, calé sur les tarifs publiés à docs.github.com/.../models-and-pricing au 28 avril 2026. Tous les profils utilisent le plan Copilot Pro (10 $/mois, 1 000 crédits inclus).

L'angle dont personne ne parle : Copilot face à l'API directe

Les tarifs au million de GitHub correspondent aux tarifs API publics des fournisseurs sous-jacents au 28 avril 2026. Aucune marge sur les tokens. Du coup, l'arithmétique du « ne vaudrait-il pas mieux appeler Anthropic directement ? » devient inhabituellement claire.

Prenez le profil intensif : 21,78 $ de coûts de tokens projetés à l'intérieur de Copilot. La valeur de tokens consommée — 2 177,58 crédits — représente 21,78 $ d'appels API au tarif public. Appeler Anthropic et OpenAI directement coûterait les mêmes 21,78 $ en frais de tokens, mais sans le forfait de base de 10 $ par-dessus.

Sauf qu'il n'y a pas de forfait de base sur l'API directe. Vous payez exactement ce que vous consommez. Pas de crédits inclus, pas de frais de plan.

Pour l'utilisateur intensif, les chiffres sont identiques — parce que le forfait de base de 10 $ est exactement compensé par les 1 000 crédits inclus. La règle : si votre valeur de tokens dépasse 10 $, Copilot et l'API directe coûtent la même chose. Si elle reste sous 10 $, vous payez les 10 $ de base pour quelque chose que vous n'utilisez pas pleinement, et l'API directe revient moins cher.

Mais la comparaison demande une nuance : Copilot Pro n'est pas qu'un accès aux tokens. Il inclut :

• Complétion par tabulation et Next-Edit Suggestions — gratuites, illimitées. Pour la plupart des développeurs, c'est la fonctionnalité qui justifie le plan. Le chat et le travail agentique au token viennent en supplément.
• Intégration à l'IDE. GitHub Copilot est embarqué dans VS Code, JetBrains, Neovim et d'autres. Reproduire cela face à l'API directe demande de l'outillage supplémentaire.
• Le contexte GitHub Copilot Chat. L'intégration IDE transmet automatiquement le contexte de fichier et de dépôt utile. L'API directe vous impose de gérer ce contexte vous-même.

Pour l'utilisateur léger — 0,15 $ de valeur en tokens sur le mois — Copilot Pro coûte 9,85 $ de plus que les seuls appels d'API directe. Que ce surcoût en vaille la peine dépend presque entièrement de l'usage de la complétion par tabulation. S'il ouvre l'IDE chaque jour et accepte les suggestions, les 10 $ sont raisonnables. S'il n'utilise Copilot que pour un chat occasionnel en ligne de commande, l'API directe est nettement moins chère.

Pour l'utilisateur modéré, l'analyse est similaire : 1,92 $ de valeur en tokens, 10 $ de plan de base, 8,08 $ de la facture vont à la complétion et aux fonctionnalités IDE. Reste un bon arbitrage pour un développeur actif.

Le point d'équilibre, où Copilot Pro et l'API directe coûtent exactement la même chose en frais de tokens, est à 10 $ de valeur en tokens par mois. Au-dessus, les deux options se valent — et Copilot ajoute les complétions gratuites par-dessus. En dessous, l'API directe est moins chère mais perd la complétion par tabulation.

À lire aussi : Tarification de l'API Anthropic 2026 — calculateur de coûts et décomposition par modèle et Le Tokenocalypse — ce que coûte vraiment une session agentique qui s'emballe.

À faire avant le 1er juin

• Inspectez votre usage actuel dans le tableau de bord GitHub. Allez sur github.com/settings/copilot — il affiche une ventilation de vos interactions Copilot par type et par modèle. Repérez le nombre de sessions et le volume approximatif de travail agentique. Les organisations peuvent consulter l'usage depuis Settings → Billing → GitHub Copilot.
• Estimez votre facture de juin avec la formule ci-dessus. Multipliez vos comptages habituels de sessions par les chiffres de l'exemple chiffré : 49,65 crédits pour une session agentique Sonnet de taille moyenne, 14 à 22 crédits pour une revue de code, 1 à 2 crédits pour un chat sur modèle bon marché. Faites la somme et comparez aux crédits inclus dans votre plan. Ou attendez Septim Meter le 12 mai.
• Si la projection vous met mal à l'aise, choisissez un levier. Le plus net : basculer votre modèle agentique de Sonnet (3,00 $/M en entrée) à GPT-5 mini (0,25 $/M en entrée). Pour le travail agentique gourmand en entrée — chargement de gros fichiers, transmission d'un long contexte — le tarif d'entrée pèse le plus. GPT-5 mini divise le coût d'entrée agentique par 12. Les arbitrages de qualité dépendent de la tâche ; testez avant de vous engager.
• Réduisez la fréquence des sessions agentiques si le coût pèse plus que l'automatisation. Le profil modéré (4 sessions agentiques par mois) reste largement dans la dotation Pro. Le profil intensif (22 sessions) la dépasse. La ligne se situe vers 20 sessions Sonnet par mois sur un plan Pro — selon la taille des sessions.
• Envisagez une montée en Pro+ pour les utilisateurs agentiques intensifs. Copilot Pro+ à 39 $/mois inclut 3 900 crédits. Le profil intensif à 2 177,58 crédits coûterait exactement 39 $ au lieu de 21,78 $ — pire que la facture Pro avec dépassement. Sur ce profil précis, Pro reste meilleur. Mais pour des usages plus lourds — sessions agentiques quotidiennes pluri-horaires — Pro+ peut revenir moins cher que d'accumuler les dépassements Pro.
• Posez une limite de dépense dans la facturation GitHub. Sous Settings → Billing and plans → Spending limits, vous pouvez plafonner la dépense Copilot mensuelle. Une limite à 0 $ bloque l'accès une fois les crédits inclus épuisés. Une limite à 20 $ vous donne un plafond. C'est la garde contre les surprises.
• Si votre facture s'est déjà envolée de manière inattendue, contactez le support GitHub avant le 1er juin. Le système PRU et le système AI Credit obéissent à des mécaniques différentes ; si vous voyez des charges anormales sous le système actuel, réglez-les avant que la transition du 1er juin ne remette les compteurs à zéro.

Septim Meter — le calculateur

Nous sortons Septim Meter le 12 mai : 29 $, paiement unique, fonctionne hors ligne. Vous saisissez vos comptages de sessions et estimations de tokens ; il projette votre facture Copilot et lance la comparaison avec l'API directe en parallèle, sur tous les plans. La formule est exactement celle de ce billet — sans compte requis, sans aucune donnée qui quitte votre machine.

La CLI est déjà fonctionnelle en ligne de commande. La sortie du 12 mai ajoute la sortie en rapport HTML et la comparaison interactive de bascule entre modèles. Si vous voulez un accès anticipé ou être prévenu de la sortie :

FAQ