GitHub Copilot: Faturamento e Custos para Equipes de API

O modelo de faturamento do GitHub Copilot mudou duas vezes no ano passado e mudou novamente este mês. A partir deste mês, a revisão de código do Copilot em pull requests começa a consumir minutos do GitHub Actions da conta de faturamento proprietária do repositório. Combinado com a cota de solicitações premium que foi implementada no último trimestre, as equipes de API agora gerenciam três medidores simultaneamente: licenças do Copilot, solicitações premium e minutos do Actions. Este guia explica o que cada medidor mede, como o novo faturamento de revisão de código afeta os repositórios de API em particular e como modelar os custos antes que eles apareçam em uma fatura.

No final, o combinamos com um fluxo de trabalho dentro do Apidog para que a especificação da API, os testes de contrato e as etapas de revisão de IA residam em um único lugar, em vez de estarem espalhados por três painéis de faturamento.

Se você também está precificando modelos de APIs que sua equipe consome diretamente, os guias mais aprofundados sobre precificação do GPT-5.5 e precificação do DeepSeek V4 abordam o lado por token da mesma conversa.

TL;DR

• O Copilot tem três medidores: licença por usuário, solicitações premium (dependentes do modelo) e agora minutos do Actions para revisão de código do Copilot.
• A revisão de código em PRs é executada como uma GitHub Action nos bastidores. Cada revisão consome minutos do Actions da cota normal da organização.
• Repositórios de API são consumidores mais pesados do que a média porque os PRs são maiores (especificação + clientes gerados + manipulador + testes) e as revisões são disparadas por múltiplos agentes.
• As solicitações premium limitam o trabalho "agêntico" (Workspace, modo agente, Copilot Spaces). O chat padrão e as conclusões de código ainda não são tarifados para os planos pagos.
• Defina limites de gastos antes do próximo ciclo de faturamento. Orce cerca de 400 a 800 minutos do Actions por mês por repositório de API ativo e revise após 30 dias.

Os três medidores e o que eles realmente medem

O Copilot costumava ser uma única fatura. Agora são três.

Medidor 1: licença por usuário

A taxa fixa. $10 por usuário por mês para Copilot Business, $19 por usuário por mês para Copilot Enterprise. Isso cobre o chat, conclusões inline, sugestões de múltiplas linhas, as integrações de IDE e o acesso ao pool de modelos padrão. As licenças são o item de linha mais fácil de prever e o mais propenso a ser superdimensionado. Audite-o uma vez por trimestre e recupere licenças de usuários inativos.

Medidor 2: solicitações premium

Solicitações premium são a moeda do GitHub para os recursos mais caros. Qualquer coisa que seja executada no modo agente, Workspace, Copilot Spaces ou seleção de modelo além do padrão, conta como uma ou mais solicitações premium, dependendo do modelo.

As taxas atuais (sujeitas a revisão):

Cada licença do Copilot Business inclui 300 solicitações premium por mês. O Copilot Enterprise inclui 1.000. Os excedentes são cobrados a $0.04 por solicitação, limitados pelo limite de gastos que você definir para a organização.

Para uma equipe de API, as solicitações que movimentam o medidor são tarefas no modo agente como “regenerar o cliente OpenAPI” ou “escrever um teste de contrato para este novo endpoint”. Essas tarefas tendem a ter múltiplas etapas internamente, então um único prompt do usuário pode resultar em quatro ou cinco solicitações premium.

Medidor 3: Minutos do Actions (novidade para revisão de código)

Esta é a mudança que surpreendeu as equipes este mês. Quando o Copilot realiza uma revisão de código automatizada em um pull request, a revisão é executada como uma GitHub Action sob a mesma infraestrutura do Actions que sua CI utiliza. Os minutos que a revisão consome são debitados da cota normal do Actions da organização.

Duas coisas a saber:

• Os minutos ESTÃO incluídos na sua cota existente do GitHub Plans Actions (3.000 min/mês no Team, 50.000 no Enterprise para runners Linux). Eles NÃO são uma cota separada.
• Revisões em repositórios privados custam mais do que em repositórios públicos porque o Actions em repositórios privados é cobrado contra seu orçamento de minutos, enquanto o Actions em repositórios públicos é gratuito.

Uma revisão de código típica do Copilot em um pull request de API consome de 2 a 6 minutos do Actions. Uma revisão pesada (diff grande, múltiplos arquivos, contexto completo do repositório) pode chegar a 15 minutos. Multiplique pelo número de PRs que sua equipe mescla e você terá um item de linha significativo.

Por que repositórios de API atingem esses medidores com mais força

Três propriedades dos repositórios de API amplificam o custo:

1. Pull requests são maiores. Uma mudança típica de API afeta a especificação (openapi.yaml), os clientes gerados em duas ou três linguagens, o manipulador do servidor e os testes de contrato. A revisão do Copilot lê todos eles, leva mais tempo e consome mais minutos do que um pequeno ajuste de frontend em um único arquivo.
2. Código gerado distorce a contagem de tokens. Mesmo quando os clientes gerados são ignorados pelo git, muitas equipes os commitam. A revisão lê todos eles e se paga pelo privilégio.
3. Múltiplos agentes de revisão são acionados por PR. Equipes que executam a revisão do Copilot junto com CodeQL, Snyk e um scanner de segurança personalizado pagam por cada um deles separadamente. O Copilot é o recém-chegado; os outros já eram medidos.

O impacto prático: uma equipe de API que mescla 50 PRs por mês a 4 minutos por revisão consome 200 minutos do Actions por mês apenas com a revisão do Copilot. Isso representa 7% da cota mensal de um plano Team para um único repositório. Três repositórios e você já está em 21% antes de qualquer execução de CI.

Como estimar sua fatura mensal

O número que pega as pessoas de surpresa é o custo total, não um único medidor. Construa a estimativa em três etapas.

Etapa 1: licenças

Conte os usuários ativos do Copilot e multiplique pelo preço da licença.

seats = active_users × $10  (Business)
      = active_users × $19  (Enterprise)

Etapa 2: solicitações premium

Estime por desenvolvedor por mês. Um usuário pesado do Workspace gera cerca de 600 a 800 solicitações; um usuário que só usa o chat fica mais próximo de 150. Com a cota incluída de 300 (Business), espere que o excedente comece pelo lado do usuário pesado.

premium_overage = max(0, requests_used - 300_per_seat) × $0.04

Defina um limite de gastos no nível da organização para que um loop de agente descontrolado não estoure seu orçamento. O padrão é ilimitado, o que é o padrão errado para qualquer equipe que não esteja monitorando ativamente.

Etapa 3: Minutos do Actions para revisão de código

Multiplique o número de PRs mesclados por mês pelos minutos por revisão. A média de 4 minutos é razoável para PRs de API de tamanho médio.

review_minutes = prs_per_month × 4
review_overage = max(0, review_minutes - actions_quota_remaining)
                 × $0.008  (Linux private repos)

Empilhe os três. Para uma equipe de 10 desenvolvedores mesclando 200 PRs por mês, os números aproximados são os seguintes:

• Licenças: $190 (Enterprise)
• Excedente premium: $40 (uso modesto de agente)
• Minutos de revisão: 800/mês, bem dentro da cota Enterprise, $0
• Total: ~$230 acima do valor base das licenças

Equipes menores no plano Business atingem o excedente mais rapidamente porque as cotas são mais restritas. Uma equipe Business de 5 desenvolvedores mesclando os mesmos 200 PRs esgotaria a cota do Actions e começaria a pagar $6 por 1.000 minutos de revisão.

O que muda em seu pipeline de CI

Três mudanças concretas no pipeline pagam o custo da noite para o dia.

1. Pule a revisão do Copilot em bots e PRs do dependabot. A maioria das equipes não precisa de revisão de IA em uma atualização do Renovate. Adicione um filtro de caminho ou ator ao gatilho do fluxo de trabalho.

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. Armazene em cache os diffs de cliente gerados. Se seu repositório regenera clientes em cada PR, a revisão lê o diff toda vez. Armazene a saída gerada por trás de um hash calculado e pule a tarefa de revisão quando o hash corresponder ao branch base.

3. Execute a revisão do Copilot com um filtro de caminho menor para repositórios de API. Restrinja a revisão aos arquivos de manipulador, especificação e teste. Pule os clientes gerados completamente. A qualidade da revisão permanece alta; os minutos caem pela metade.

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

Governança: os quatro controles que toda equipe de API deve configurar

Eles levam 20 minutos e previnem a maioria das faturas surpresa.

1. Limite de gastos. Defina-o no nível da organização, não no nível do repositório. O padrão é ilimitado; escolha um número que você não hesitaria e arredonde para baixo em 20%.
2. Alertas de solicitação premium. O GitHub envia e-mails em 50, 75 e 90 por cento da cota incluída. Conecte-os ao Slack ou à sua ferramenta de incidentes para que não se percam nas caixas de entrada.
3. Política de repositório sobre gatilhos de revisão. Decida se a revisão do Copilot é acionada em cada PR ou apenas em PRs rotulados com review-please. O modelo baseado em rótulos reduz os custos em aproximadamente 60% sem perder as revisões que detectam problemas reais.
4. Implementação por equipe. Habilite os recursos do Copilot Enterprise por equipe, em vez de em toda a organização. Novos recursos são lançados como opt-in; você não precisa absorver o custo de cada lançamento no momento em que ele chega.

Onde o Apidog se encaixa

O Apidog não é um substituto do Copilot; é a camada que mantém seus testes de contrato dentro de uma única ferramenta em vez de três. O padrão que mantém custos e qualidade previsíveis:

• A especificação e os exemplos de solicitação salvos residem na coleção do Apidog, commitada junto com o repositório.
• Os testes de contrato são executados contra o servidor mock do Apidog, não a API real. As execuções de mock são gratuitas e rápidas.
• A revisão do Copilot foca na lógica do manipulador e na cobertura de testes, não em se o exemplo da especificação está atualizado.
• O fluxo de trabalho de CI executa o apidog-cli para validação de contrato em 30 segundos e só aciona a revisão do Copilot se a validação for aprovada.

Essa sequência é importante porque a revisão do Copilot é a etapa mais cara do pipeline. Falhar rapidamente em um problema de contrato economiza minutos de revisão para o código que realmente os merece. O guia de testes de API sem Postman cobre o fluxo de trabalho de mock subjacente do Apidog; o guia da API DeepSeek V4 mostra o padrão aplicado a um modelo de API.

O que esperar no próximo ciclo de faturamento

Três coisas para colocar no calendário:

• Dia 1 a 7: O uso de solicitações premium parece normal. A maioria das equipes permanece abaixo da cota incluída de 300/licença na primeira semana.
• Dia 14 a 21: Usuários pesados excedem a cota incluída. Se você definir um limite de gastos, as solicitações começarão a falhar para esses usuários. Sem um limite, a fatura cresce.
• Dia 28 a 30: O uso de minutos do Actions da revisão do Copilot se acumula. É aqui que as equipes percebem o novo item de linha. Compare com a fatura do mês anterior lado a lado.

Audite no final do mês. Mova usuários pesados para o plano Enterprise (1.000 solicitações incluídas), reduza as licenças de usuários inativos e restrinja o filtro de caminho no fluxo de trabalho de revisão.

Erros comuns

Após auditar uma dezena de equipes de API no mês passado, os mesmos cinco problemas surgem:

1. Sem limite de gastos. Um único loop de agente pode ser executado por horas. Sempre defina um limite.
2. Revisão habilitada em todo repositório. Escolha os repositórios onde a revisão realmente compensa. Desative nos outros.
3. Clientes gerados revisados. Filtre-os pelo caminho.
4. PRs de bot revisados. Filtre dependabot, renovate e quaisquer atualizadores automáticos internos.
5. Sem métricas de linha de base. Sem um instantâneo "antes", você não pode dizer se uma mudança no fluxo de trabalho economizou dinheiro. A UI de faturamento do GitHub oferece uma exportação CSV; baixe-a mensalmente.

FAQ

O preço da licença ainda é $10 por usuário?O Copilot Business custa $10 por usuário por mês, o Copilot Enterprise custa $19 por usuário por mês, e o Copilot Pro para indivíduos custa $10 por mês. O nível da licença define a cota de solicitações premium incluídas.

As conclusões inline agora são tarifadas?Não. O modelo padrão para chat e conclusões inline não é tarifado para planos pagos. As solicitações premium cobrem os recursos mais caros e a seleção de modelos.

O que acontece quando minha cota premium se esgota?Por padrão, as solicitações começam a falhar com um erro de cota. Você pode definir um limite de gastos para permitir o excedente a $0.04 por solicitação até o limite.

Os novos minutos do Actions para revisão de código são cobrados separadamente?Não. Eles consomem o mesmo pool de minutos do Actions que o restante do seu CI. Acompanhe o uso total do Actions e ajuste os gatilhos do fluxo de trabalho para manter o orçamento em ordem.

Posso desabilitar a revisão de código do Copilot por completo?Sim. O administrador da organização pode desativar repositórios no nível da política. A mesma configuração controla a inscrição por equipe.

A revisão do Copilot funcionará em especificações de API privadas?Sim. Repositórios privados consomem minutos do Actions; repositórios públicos são gratuitos. O revisor lê os arquivos de especificação e manipulador como qualquer outra fonte.

A revisão do Copilot também usa solicitações premium?Atualmente, consome apenas minutos do Actions. O modelo que o revisor usa faz parte da plataforma Copilot e não é cobrado separadamente como uma solicitação premium. Esta é a parte mais provável de mudar no próximo trimestre; fique atento ao changelog do GitHub.

Para equipes que executam tanto a revisão do Copilot quanto chamadas diretas de API de modelo em CI, o guia do Codex gratuito GPT-5.5 cobre o lado por token e o Apidog envolve a camada de mock e contrato para que a revisão de IA seja executada apenas em PRs que passem nos checks mais baratos primeiro.