# Calculadora de custo do GitHub Actions: da fatura ao preço fixo

> A sua fatura do GitHub Actions são os minutos de cada trabalho vezes a tarifa por minuto do executor, menos a computação incluída no seu plano. 20.000 minutos por mês em um executor de 4 núcleos dão $222; o Skipbox roda os mesmos trabalhos por $39 fixos, ilimitados.

A sua fatura do GitHub Actions cresce a cada minuto que os seus trabalhos rodam. Uma equipe que roda 20.000 minutos por mês no executor de 4 núcleos do GitHub paga $222 por mês, e no mês seguinte vai rodar mais.

O Skipbox roda os mesmos trabalhos por $39 fixos por mês com minutos ilimitados. Para mover um trabalho, troque a linha `runs-on` dele para `skipbox`.

- A fatura do GitHub = minutos × a tarifa do executor − a computação incluída no seu plano
- 20.000 minutos em um executor de 4 núcleos: $222 no GitHub, $39 no Skipbox, $183 economizados todo mês
- A [calculadora da página inicial](https://skipbox.dev/?ref=g-github-actions-cost-calculator-pt-br#cost) calcula o preço dos seus próprios minutos, sem precisar entrar

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=g-github-actions-cost-calculator-pt-br)

## Como o GitHub calcula a sua fatura

O GitHub multiplica os minutos de cada trabalho pela tarifa por minuto do executor e arredonda cada trabalho para cima até um minuto inteiro, então um trabalho de 2 minutos e 5 segundos é cobrado como 3. Execuções que falham e novas execuções também são cobradas. A computação incluída no seu plano ($18 por mês no GitHub Team) é descontada do total, e cada minuto depois dela é cobrado.

**fatura = Σ (minutos em cada executor × a tarifa dele) − computação incluída**

| Executor (repositórios privados) | Por minuto |
|---|---|
| `ubuntu-latest` (2 núcleos) | $0,006 |
| Linux de 4 núcleos | $0,012 |
| Linux de 8 núcleos | $0,022 |
| Linux de 16 núcleos | $0,042 |

Para ver os seus próprios minutos, abra **Billing & Licensing → Usage** nas configurações da sua organização, filtre por Actions e agrupe por SKU. Para uma única execução, abra o resumo dela e clique em **Usage** em Run details.

## Quanto dá a fórmula

No GitHub Team, um executor de 4 núcleos, contra o plano S do Skipbox com os mesmos 4 vCPU:

| Minutos por mês | GitHub | Skipbox S | Você economiza todo mês |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Sempre ligado | $500,40 | $39 | **$461,40** |

Em executores maiores, a diferença cresce:

| 20.000 minutos por mês | GitHub | Skipbox | Você economiza todo mês |
|---|---|---|---|
| 8 núcleos | $422 | $79 (M) | **$343** |
| 16 núcleos | $822 | $149 (L) | **$673** |

Para os seus próprios números, coloque os seus minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-github-actions-cost-calculator-pt-br#cost). Ela não pede login e mostra a fatura do GitHub ao lado do preço fixo do Skipbox para o tamanho de máquina que você escolher.

## Por que o número do mês que vem é maior

A fórmula não tem teto, e cada entrada continua subindo.

- **Agentes de IA para programação** abrem pull requests e enviam correções o dia todo. O CI roda a cada push, então a fatura acompanha os pushes, não as pessoas.
- **Mais testes.** Uma suíte E2E ou uma matriz de build transforma um push em muitos trabalhos.
- **Novas execuções.** Um teste instável executado de novo cobra os minutos dele outra vez.
- **Orçamentos.** Limite a fatura com um orçamento do GitHub, e quando ele acaba no meio do mês, os trabalhos param e os merges esperam.

Cortar minutos dá trabalho: cancelar execuções substituídas, filtros de caminho, chaves de cache, executores menores, e depois conferir tudo de novo no mês seguinte. Um preço fixo acaba com a conta.

## O que o Skipbox muda

- **Preço fixo, minutos ilimitados.** $39, $79 ou $149 por mês por 4, 8 ou 16 vCPU. Sem cobrança por uso. Adicione planos para rodar mais trabalhos ao mesmo tempo; os trabalhos além das suas máquinas esperam a vez.
- **Nenhum minuto do GitHub.** As máquinas do Skipbox se conectam como executores auto-hospedados, que o GitHub não cobra e que nunca consomem um orçamento.
- **Trabalhos mais rápidos.** A sua própria máquina guarda imagens e camadas Docker, caches de pacotes e ferramentas instaladas entre os trabalhos: pelo menos 7× o cache que o GitHub dá a um repositório, sem chaves de cache para escrever.
- **Nada para manter.** O Skipbox atualiza a imagem, limpa tudo depois de cada trabalho e recria a máquina que falha na verificação de integridade.

## Mudar é uma linha

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
```

1. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os seus repositórios.
3. Troque o `runs-on` e faça push.

O próximo trabalho roda no Skipbox; os trabalhos Linux rodam sem mudanças.

## Segurança

- A máquina é só da sua conta; nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados. A partir de 13 de novembro de 2026, o seu checkout e a saída de build dele (o `target/` do Cargo) ficam na sua própria máquina para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma VM nova, excluída depois. [Como os trabalhos são mantidos separados](https://docs.skipbox.dev/isolation).

## Teste nos seus próprios trabalhos

O teste não pede cartão e dura 7 dias ou 3.000 minutos de trabalhos. Mova o seu workflow mais caro para `runs-on: skipbox` e veja essa linha sair da sua fatura do GitHub.

## Perguntas frequentes

### Como o GitHub Actions é cobrado?

Por minuto. Os minutos de cada trabalho, arredondados para cima até um minuto inteiro, são multiplicados pela tarifa do executor, e a computação incluída no seu plano é descontada do total. O Skipbox troca isso por um preço fixo a partir de $39 por mês, com minutos ilimitados.

### Quanto custa o minuto do GitHub Actions?

Em um repositório privado, o ubuntu-latest (2 núcleos) custa $0,006 por minuto, o executor Linux de 4 núcleos $0,012, o de 8 núcleos $0,022 e o de 16 núcleos $0,042. No Skipbox, uma máquina de 4 vCPU custa $39 por mês, não importa quantos minutos ela rode.

### Existe uma calculadora de custo do GitHub Actions?

Sim. A calculadora da página inicial do Skipbox recebe os seus minutos por mês e o tamanho da máquina, e mostra a fatura do GitHub e quanto você economiza com o preço fixo do Skipbox. Não precisa entrar.

### Trabalhos que falham e novas execuções custam dinheiro?

Sim. Cada minuto que um trabalho roda é cobrado, incluindo execuções que falham e novas execuções. No Skipbox elas não custam nada a mais: o preço é fixo.

### Executores auto-hospedados entram na fatura?

Não. O GitHub não cobra nada pelos minutos de executores auto-hospedados. As máquinas do Skipbox se conectam como executores auto-hospedados, então os trabalhos que você move para lá saem da sua fatura do GitHub, e o preço fixo do Skipbox é tudo o que você paga por eles.

Atualizado em 2026-11-11 · https://skipbox.dev/pt-br/guides/github-actions-cost-calculator