AI CodeOps

Revue de code IA en 2026 : prix par utilisateur, crédit ou exécution

Matt · · Mis à jour le · 10 min de lecture · Études

Revue de code par IA : tarifs par utilisateur, par crédit et par exécution comparés sur un scénario à 10 développeurs, avec formules, hypothèses et prix datés.

En 2026, la revue de code par IA se vend de trois façons : par utilisateur (CodeRabbit, Sourcery, Graphite, Bito), au crédit (Greptile, Qodo, les AI Credits de Copilot) et à l'exécution (Cursor Bugbot, Claude Code Review). Pour une équipe de 10 développeurs qui ouvre 20 pull requests par jour, le même mois de revues coûte d'environ $120 à bien plus de $3 000, et l'écart tient surtout à un seul réglage : l'outil relit-il chaque push ? Voici les formules, les hypothèses et les prix, chacun vérifié le 24 octobre 2026.

Transparence : je développe AI CodeOps. Il ne propose pas de tarification à la revue, il ne figure donc pas dans le tableau du scénario ; sa place est expliquée à la fin.

Les trois modèles de tarification

Par utilisateur. Vous payez un prix fixe par développeur et par mois. Les revues sont « illimitées », dans le respect d'une limite de débit ou d'une politique d'usage raisonnable. Votre facture ne bouge que lorsque l'effectif change.

  • CodeRabbit : Essentials à $24 par développeur et par mois en facturation annuelle ($30 en mensuel), avec 5 revues de PR par développeur et par heure. Au-delà de ce quota horaire, les revues coûtent $0.25 par fichier relu.
  • Sourcery : Pro à $12 par développeur et par mois en facturation annuelle ($15 en mensuel).
  • Graphite : Team à $40 par utilisateur et par mois en facturation annuelle, avec des revues IA illimitées (limitées sur Hobby et Starter).
  • Bito : Team affiché à $12 ou $15 par utilisateur et par mois, avec 5 000 lignes relues par utilisateur et par mois incluses, puis $5 par tranche de 1 000 lignes.

Au crédit. Vous achetez une réserve de crédits et chaque revue en consomme une partie. Le prix d'une revue dépend de sa profondeur.

  • Greptile : $1 le crédit, sans frais par utilisateur. Une revue coûte 1, 3 ou 10 crédits (Base, Plus, Apex).
  • Qodo : Pro Team coûte $30 par mois pour 2 500 crédits à $0.012 l'unité, mis en commun pour toute l'équipe. Qodo estime que 2 500 crédits correspondent à environ 18 revues, soit environ $1.67 la revue.
  • GitHub Copilot est passé le 1er juin 2026 à une facturation à l'usage en « AI Credits ». Business coûte $19 par utilisateur et par mois, AI Credits à hauteur de $19 compris. La documentation de la revue de code de GitHub estime une revue à $0.05 à $1 de crédits en effort Lite et à $0.25 à $5 en effort Balanced, et la revue de code consomme aussi des minutes GitHub Actions.

À l'exécution. Chaque revue est facturée séparément, à un prix qui varie selon la pull request.

  • Cursor Bugbot a abandonné en 2026 son prix de $40 par utilisateur au profit d'une facturation à l'usage. Selon Cursor, une exécution coûte en moyenne $1.00 à $1.50, selon la taille et la complexité de la PR.
  • Claude Code Review n'a pas de prix forfaitaire par revue. Il facture les tokens consommés par chaque revue, et Anthropic conseille un pilote pour mesurer votre propre moyenne.

Pour estimer le coût au token des modèles sous-jacents, le suivi des coûts des modèles de codage IA liste les prix actuels des API. Combien coûte le codage par IA, et comment maîtriser ce coût ? explique pourquoi le travail d'un agent coûte plus cher qu'une conversation.

Un exemple chiffré : 10 développeurs, 20 PR par jour

Chaque chiffre ci-dessous provient du prix publié par l'éditeur et des hypothèses qui suivent. Aucun n'est mesuré sur de vraies factures.

#Hypothèse
A110 développeurs
A220 pull requests par jour pour toute l'équipe
A35 pushes par pull request : le premier push plus quatre mises à jour
A421 jours ouvrés par mois, soit 20 × 21 = 420 pull requests par mois
A5« Une fois » signifie une revue par PR : 420 revues. « Chaque push » signifie 420 × 5 = 2 100 revues
A6Prix catalogue, facturation annuelle quand un éditeur affiche les deux, sans remise ni taxe
A7Chaque revue coûte le chiffre annoncé par l'éditeur, même une petite revue de suivi

Les formules :

  • Par utilisateur : coût mensuel = développeurs × prix par utilisateur.
  • Au crédit ou à l'exécution : coût mensuel = pull requests × revues par pull request × coût par revue.
  • Copilot ajoute en plus : revues × minutes Actions par revue × $0.006 (un runner Linux standard à 2 cœurs, d'après la tarification des runners de GitHub).

J'ai exécuté ce script pour produire le tableau. Remplacez les constantes par les chiffres de votre équipe :

// review-cost.ts: monthly AI code review cost for one team, from list prices.
// Run: bun review-cost.ts   (or: npx tsx review-cost.ts)

const devs = 10 // A1
const prsPerDay = 20 // A2, across the team
const pushesPerPr = 5 // A3, the first push plus four updates
const workDays = 21 // A4
const prs = prsPerDay * workDays // 420 PRs a month
const reviews = { once: prs, everyPush: prs * pushesPerPr } // 420 or 2,100

type Range = [low: number, high: number]
const perReview: Record<string, Range> = {
  "Copilot, Lite effort": [0.05, 1], // GitHub's estimate, AI credits only
  "Copilot, Balanced effort": [0.25, 5],
  "Cursor Bugbot": [1, 1.5], // Cursor's average per run
  "Greptile Base (1 credit)": [1, 1],
  "Greptile Plus (3 credits)": [3, 3],
  "Qodo (2,500 credits ≈ 18 reviews)": [30 / 18, 30 / 18],
}
const perSeat: Record<string, number> = {
  "Sourcery Pro (annual)": 12,
  "CodeRabbit Essentials (annual)": 24,
  "Graphite Team (annual)": 40,
}

const usd = (n: number) => "$" + Math.round(n).toLocaleString("en-US")
const range = ([lo, hi]: Range, n: number) => (lo === hi ? usd(lo * n) : `${usd(lo * n)}–${usd(hi * n)}`)

console.log(`${prs} PRs, ${reviews.once} or ${reviews.everyPush} reviews a month`)
for (const [tool, price] of Object.entries(perSeat)) console.log(`${tool}: ${usd(price * devs)}`)
for (const [tool, r] of Object.entries(perReview))
  console.log(`${tool}: once ${range(r, reviews.once)}, every push ${range(r, reviews.everyPush)}`)
// Copilot also uses GitHub Actions minutes: $0.006 a minute on a Linux 2-core runner.
console.log(
  `Each Actions minute per review adds: once $${(reviews.once * 0.006).toFixed(2)}, every push $${(reviews.everyPush * 0.006).toFixed(2)}`,
)

Sa sortie, sous forme de tableau :

Outil et réglageFormuleUne fois par PR (420 revues)Chaque push (2 100 revues)
Sourcery Pro10 × $12$120$120
CodeRabbit Essentials10 × $24$240$240
Graphite Team10 × $40$400$400
Revue de code de Copilot, Literevues × $0.05–$1$21–$420$105–$2 100
Revue de code de Copilot, Balancedrevues × $0.25–$5$105–$2 100$525–$10 500
Cursor Bugbotrevues × $1.00–$1.50$420–$630$2 100–$3 150
Greptile Baserevues × 1 crédit × $1$420$2 100
Greptile Plusrevues × 3 crédits × $1$1 260$6 300
Qodo Pro Teamrevues × ($30 ÷ 18)$700$3 500

Lisez ce tableau en gardant ses limites à l'esprit :

  • Les lignes Copilot ne comptent que les crédits. Ajoutez $190 pour dix licences Business, qui incluent $190 de crédits sur lesquels puisent aussi les autres usages de Copilot, ainsi que les minutes Actions : chaque minute que prend une revue ajoute $2.52 (une fois) ou $12.60 (chaque push) par mois.
  • La ligne Bugbot ne compte pas l'abonnement Cursor. La page de tarifs de Cursor liste Bugbot sur Premium, Super, Ultra, Teams et Enterprise, pas sur Free ni Plus.
  • A7 surestime probablement les revues de suivi. Par défaut, Bugbot ne relit que ce qui a changé depuis sa dernière revue, et une petite revue peut coûter moins qu'une revue moyenne. Aucun éditeur ne me donne de chiffre par push, je n'en ai donc pas inventé.
  • Les lignes par utilisateur ne valent que dans les limites de débit. Dans ce scénario, chaque développeur déclenche en moyenne 10 revues par jour, sous les 5 par heure de CodeRabbit sur Essentials. Une rafale de pushes avant une release pourrait atteindre cette limite.
  • Bito ne figure pas dans le tableau, car son quota de lignes dépend du nombre de lignes que modifient vos pull requests, un chiffre qu'il m'aurait fallu inventer.

Les coûts cachés

Les nouvelles revues à chaque push. C'est le plus gros levier du tableau, et les réglages par défaut diffèrent :

  • Bugbot relit par défaut chaque mise à jour d'une pull request ; « Run only once » et « Run only when mentioned » sont des options (documentation de Bugbot).
  • Un dépôt que vous ajoutez à Claude Code Review démarre sur « After every push », ce qui, selon Anthropic, multiplie le coût par le nombre de pushes (coûts).
  • Copilot ne relit qu'une fois, sauf si vous cochez « Review new pushes » dans le ruleset (revue automatique).

Les minutes de CI. La revue de code de Copilot consomme des minutes GitHub Actions en plus des crédits. Le Code Review Flow de GitLab Duo s'exécute comme un job CI/CD et a besoin d'un runner (documentation de GitLab). Un relecteur que vous exécutez vous-même comme GitHub Action, PR-Agent par exemple, consomme vos minutes et votre clé de modèle.

Les limites de débit et les dépassements. Les offres par utilisateur plafonnent les revues par heure. CodeRabbit facture $0.25 par fichier relu au-delà du quota horaire ; Graphite limite les revues IA sur Hobby et Starter.

Les réglages de profondeur. Une revue Greptile Apex consomme dix fois plus de crédits qu'une revue Base. L'estimation Balanced de Copilot vaut cinq fois son estimation Lite, aux deux bornes de la fourchette.

Comment plafonner les dépenses

  1. Faites relire une fois par pull request, et relancez la revue à la demande. Dans le scénario, cela réduit de 80% chaque ligne facturée à l'usage. Utilisez les commandes de commentaire (@claude review, bugbot run) quand une nouvelle revue compte.
  2. Choisissez la profondeur dépôt par dépôt. Des réglages légers pour le code courant, des réglages approfondis pour les dépôts où un bug manqué coûte cher.
  3. Fixez une limite mensuelle stricte quand l'éditeur en propose une. Claude Code Review dispose d'une limite de dépenses mensuelle et ignore les revues une fois qu'elle est atteinte (coûts). Qodo vous permet de fixer un plafond de dépenses mensuel sur les dépassements (tarifs).
  4. Ignorez les brouillons. Claude Code Review les ignore automatiquement, et Copilot ne les relit que si vous cochez « Review draft pull requests ».
  5. Menez un pilote de deux semaines et lisez la facture. Tous les éditeurs à l'usage cités ici disent que le coût varie avec la taille des PR. Votre propre moyenne vaut mieux que n'importe quelle estimation, la mienne comprise.

Le calculateur de coûts du codage par IA estime la part modèles de la facture si vous exécutez les revues avec vos propres clés. Budgets et plafonds de dépenses explique les limites souples et strictes en général.

Les prix utilisés, avec leur date de vérification

OutilModèlePrix retenuSourceVérifié le
SourceryPar utilisateurPro $12/dév./mois en annuel ($15 en mensuel)tarifs24 octobre 2026
CodeRabbitPar utilisateurEssentials $24/dév./mois en annuel ($30 en mensuel)tarifs24 octobre 2026
GraphitePar utilisateurTeam $40/utilisateur/mois en annueltarifs24 octobre 2026
BitoPar utilisateurTeam $12 ou $15/utilisateur/mois + $5 par tranche de 1 000 lignes au-delà de 5 000tarifs24 octobre 2026
GreptileCrédit$1/crédit ; 1, 3 ou 10 crédits par revuetarifs24 octobre 2026
QodoCrédit$30/mois pour 2 500 crédits (environ 18 revues)tarifs24 octobre 2026
GitHub CopilotCrédit$0.05–$1 (Lite) ou $0.25–$5 (Balanced) par revuedocumentation24 octobre 2026
GitHub ActionsMinutes$0.006/min, Linux 2 cœursdocumentation24 octobre 2026
Cursor BugbotExécution$1.00–$1.50 en moyenne par exécutionblog de Cursor24 octobre 2026
Claude Code ReviewExécutionPas de prix forfaitaire ; tokens consommés par revuedocumentation24 octobre 2026

Les prix changent souvent sur ce marché. Le comparatif complet des outils de revue de code par IA décrit ce que fait chaque outil, pas seulement ce qu'il coûte.

La place d'AI CodeOps

AI CodeOps ne facture pas à la revue et ne relit pas les pull requests que votre équipe ouvre : il ne peut donc pas figurer comme une ligne équivalente dans le tableau. Des agents IA écrivent un changement, le testent et le relisent au sein d'une session, et la revue est une étape de cette session. Pendant la bêta ouverte, il est gratuit, avec un quota mensuel de tokens sur les modèles de la plateforme, ou vous apportez votre propre clé de fournisseur (tarifs). Les offres payantes n'ont pas encore été annoncées. Les sessions sont décomptées d'un budget de l'espace de travail que vous pouvez définir, avec une limite stricte et des plafonds par workflow (maîtrise des coûts). La page Maîtrise des coûts montre ce que vous voyez pour chaque session.

À retenir

  • La tarification par utilisateur (CodeRabbit, Sourcery, Graphite, Bito) est prévisible ; la tarification à l'usage (Copilot, Bugbot, Greptile, Qodo, Claude) suit le nombre de pull requests et de pushes.
  • Dans un scénario à 10 développeurs et 20 PR par jour, les offres par utilisateur coûtent de $120 à $400 par mois ; les offres à l'usage vont de $21 à plus de $10 000 selon le réglage.
  • Relire chaque push plutôt qu'une fois par PR multiplie les coûts à l'usage par le nombre de pushes par PR, soit par cinq ici.
  • La revue de code de Copilot coûte des crédits plus des minutes Actions ; laissez « Review new pushes » désactivé sauf si vous en avez besoin.
  • Menez un pilote et fixez une limite de dépenses stricte quand l'éditeur en propose une ; votre propre moyenne par revue est le chiffre qui compte.

Questions fréquentes

Combien coûte la revue de code par IA pour une pull request ?

Tout dépend du modèle de tarification. Les outils facturés à l'usage publient des chiffres allant d'environ $0.05 (Copilot en effort Lite, bas de la fourchette) à $1.00–1.50 (exécution moyenne de Bugbot) et $1–10 (une revue Greptile, selon la profondeur). Les outils facturés par utilisateur coûtent le même prix quel que soit le nombre de pull requests ouvertes, tant qu'ils restent sous leurs limites de débit.

La revue de code par IA revient-elle moins cher par utilisateur ou à l'usage ?

Pour une équipe très active qui fait relire chaque push, les offres par utilisateur étaient bien moins chères dans mon scénario à 10 développeurs. La tarification à l'usage l'emporte pour les petites équipes, quand les pull requests sont peu nombreuses, ou quand la revue ne s'exécute qu'une fois par pull request avec un réglage léger.

La revue de code de Copilot est-elle facturée en plus ?

Chaque revue consomme des crédits IA et des minutes GitHub Actions. GitHub estime le coût d'une revue à $0.05 à $1 de crédits en effort Lite et à $0.25 à $5 en effort Balanced, minutes Actions non comprises.