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.
Sur cette page
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 |
|---|---|
| A1 | 10 développeurs |
| A2 | 20 pull requests par jour pour toute l'équipe |
| A3 | 5 pushes par pull request : le premier push plus quatre mises à jour |
| A4 | 21 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 |
| A6 | Prix catalogue, facturation annuelle quand un éditeur affiche les deux, sans remise ni taxe |
| A7 | Chaque 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églage | Formule | Une fois par PR (420 revues) | Chaque push (2 100 revues) |
|---|---|---|---|
| Sourcery Pro | 10 × $12 | $120 | $120 |
| CodeRabbit Essentials | 10 × $24 | $240 | $240 |
| Graphite Team | 10 × $40 | $400 | $400 |
| Revue de code de Copilot, Lite | revues × $0.05–$1 | $21–$420 | $105–$2 100 |
| Revue de code de Copilot, Balanced | revues × $0.25–$5 | $105–$2 100 | $525–$10 500 |
| Cursor Bugbot | revues × $1.00–$1.50 | $420–$630 | $2 100–$3 150 |
| Greptile Base | revues × 1 crédit × $1 | $420 | $2 100 |
| Greptile Plus | revues × 3 crédits × $1 | $1 260 | $6 300 |
| Qodo Pro Team | revues × ($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
- 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. - 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.
- 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).
- Ignorez les brouillons. Claude Code Review les ignore automatiquement, et Copilot ne les relit que si vous cochez « Review draft pull requests ».
- 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
| Outil | Modèle | Prix retenu | Source | Vérifié le |
|---|---|---|---|---|
| Sourcery | Par utilisateur | Pro $12/dév./mois en annuel ($15 en mensuel) | tarifs | 24 octobre 2026 |
| CodeRabbit | Par utilisateur | Essentials $24/dév./mois en annuel ($30 en mensuel) | tarifs | 24 octobre 2026 |
| Graphite | Par utilisateur | Team $40/utilisateur/mois en annuel | tarifs | 24 octobre 2026 |
| Bito | Par utilisateur | Team $12 ou $15/utilisateur/mois + $5 par tranche de 1 000 lignes au-delà de 5 000 | tarifs | 24 octobre 2026 |
| Greptile | Crédit | $1/crédit ; 1, 3 ou 10 crédits par revue | tarifs | 24 octobre 2026 |
| Qodo | Crédit | $30/mois pour 2 500 crédits (environ 18 revues) | tarifs | 24 octobre 2026 |
| GitHub Copilot | Crédit | $0.05–$1 (Lite) ou $0.25–$5 (Balanced) par revue | documentation | 24 octobre 2026 |
| GitHub Actions | Minutes | $0.006/min, Linux 2 cœurs | documentation | 24 octobre 2026 |
| Cursor Bugbot | Exécution | $1.00–$1.50 en moyenne par exécution | blog de Cursor | 24 octobre 2026 |
| Claude Code Review | Exécution | Pas de prix forfaitaire ; tokens consommés par revue | documentation | 24 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.
Voir aussi
- Combien coûte le codage par IA, et comment maîtriser ce coût ?
- Budgets de codage IA : limites souples, plafonds stricts et par workflow
- Outils de revue de code par IA en 2026 : le comparatif honnête
- Barrières qualité dans GitHub Actions : configurations pour 10 stacks
- Slopsquatting : quand les agents IA installent de faux paquets
- Revue des pull requests de Claude Code avec des barrières qualité
- Tous les articles du blog