# Quanto custa de verdade um executor auto-hospedado do GitHub Actions, e o caminho do preço fixo

> O GitHub não cobra nada pelos minutos de executores auto-hospedados; o custo real é o servidor mais as horas que você passa mantendo-o no ar. O Skipbox é um executor auto-hospedado com esse trabalho feito, por $39 fixos por mês com minutos ilimitados.

Um executor auto-hospedado do GitHub Actions não custa nada em minutos do GitHub. O custo real dele é o servidor e as horas que alguém passa mantendo-o atualizado, limpo e online, e essas horas saem da semana da sua equipe.

O Skipbox é um executor auto-hospedado sem essas horas: a sua máquina dedicada, mantida para você, por $39 fixos por mês com minutos ilimitados. Troque uma linha de `runs-on` para mover um trabalho.

- O GitHub não cobra nada pelos minutos de executores auto-hospedados; os executores do Skipbox são executores auto-hospedados
- 20.000 minutos por mês em um executor de 4 núcleos: $222 no GitHub, $39 no Skipbox
- As atualizações, a limpeza depois de cada trabalho, as verificações de integridade e as recriações ficam com o Skipbox, não com você

**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-self-hosted-runner-cost-pt-br)

## Quanto custa um executor auto-hospedado

A documentação do GitHub diz com todas as letras: os executores auto-hospedados são de uso gratuito com o GitHub Actions, e você é responsável pelo custo de manter as máquinas. A documentação de cobrança do GitHub os lista como uso que continua gratuito e não reduz a sua computação incluída. O GitHub anunciou uma cobrança para eles em 16 de dezembro de 2025 e a engavetou no dia seguinte.

Então o custo tem três partes:

| Parte | O que é |
|---|---|
| O servidor | Uma máquina dimensionada para o seu maior trabalho, paga todo mês, rodem trabalhos ou não |
| As horas | Instalar o executor, atualizar o sistema operacional e as ferramentas, limpar entre os trabalhos, espaço em disco, acrescentar máquinas, consertá-lo quando fica offline |
| O risco | Uma máquina que guarda o que o último trabalho deixou: arquivos, processos, contêineres, tokens |

## Quanto custam, em comparação, os minutos hospedados pelo GitHub

| Minutos por mês (4 vCPU) | 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** |

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

Os valores do GitHub são a fatura no GitHub Team depois da computação incluída. Calcule os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-github-self-hosted-runner-cost-pt-br#cost); sem login.

Essa fatura cresce todo mês: os agentes de programação fazem push de correções o dia todo, cada suíte de teste nova multiplica os trabalhos por push, e um orçamento do GitHub para os trabalhos no meio do mês quando se esgota. É por isso que as equipes mudam para executores auto-hospedados. A questão é quem faz a manutenção.

## As horas, em detalhe

Manter o seu próprio executor significa:

- registrar o executor com um token que expira depois de uma hora, e instalá-lo como serviço
- manter o aplicativo do executor atualizado; o GitHub para de mandar trabalhos para as versões que ficam muito para trás
- instalar e aplicar patches no Docker, no Node, no Python e em cada ferramenta que um trabalho espera
- limpar a máquina entre os trabalhos, ou recriá-la para cada trabalho e perder todo o cache
- apagar imagens Docker e checkouts antigos antes de o disco encher
- registrar mais executores, mais máquinas ou um autoscaler no Kubernetes quando os trabalhos entram na fila
- perceber quando o executor fica offline, antes de um trabalho esperar 24 horas e falhar

Coloque o seu valor por hora nessa lista e some ao servidor. O preço do Skipbox já inclui tudo isso.

## O que o Skipbox faz por você

- **Um preço fixo.** $39, $79 ou $149 por mês por 4, 8 ou 16 vCPU, minutos ilimitados, sem cobrança por uso. Acrescente planos para rodar mais trabalhos ao mesmo tempo; os trabalhos além das suas máquinas esperam a vez.
- **A sua máquina dedicada aquecida.** As imagens, as camadas e o cache de build do Docker, os caches de pacotes e o cache de ferramentas ficam entre os trabalhos: pelo menos 7× o cache que o GitHub dá a um repositório.
- **Limpa e verificada.** Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados, e uma verificação de integridade roda. Uma máquina que falha nela é recriada automaticamente. 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 máquina dedicada para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.
- **Sempre atualizada.** O executor, o Ubuntu 24.04, o Docker, o Node 22 e o Python 3.12 ficam por conta do Skipbox atualizar.

## Mudar é uma linha

```yaml
jobs:
  build:
    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.

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 e os arquivos de credenciais como o `~/.npmrc` 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 máquina dedicada 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/pt-br/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 um trabalho para `runs-on: skipbox` e compare com um servidor que você teria que manter.

## Perguntas frequentes

### Quanto custa um executor auto-hospedado do GitHub Actions?

O GitHub não cobra nada pelos minutos dele. Você paga o servidor e as horas gastas com atualizações, limpeza, espaço em disco e escalonamento. O Skipbox junta tudo isso em um preço fixo: $39 por mês por uma máquina de 4 vCPU com minutos ilimitados.

### O GitHub cobra pelos minutos de executores auto-hospedados?

Não. Os executores auto-hospedados são grátis e não reduzem a sua computação incluída; o GitHub engavetou no dia seguinte a cobrança que anunciou em 16 de dezembro de 2025. As máquinas do Skipbox se conectam como executores auto-hospedados, então custam só o preço fixo do Skipbox.

### Vale a pena manter o seu próprio executor do GitHub Actions?

Os minutos são grátis, então compensa quando a sua fatura do GitHub é maior que o servidor mais o seu tempo. O Skipbox te dá os minutos grátis sem o tempo: com 20.000 minutos por mês em um executor de 4 núcleos, ele economiza $183 todo mês.

### Um executor auto-hospedado pode rodar mais de um trabalho por vez?

Um executor registrado aceita um trabalho por vez; mais significa mais executores, mais máquinas ou um autoscaler. No Skipbox, você acrescenta planos para rodar mais trabalhos ao mesmo tempo, e os trabalhos além das suas máquinas esperam a vez.

### Os executores auto-hospedados são seguros?

O GitHub avisa que um executor auto-hospedado guarda o que os trabalhos anteriores deixaram, a menos que você o limpe. O Skipbox apaga as credenciais, os processos e os contêineres do executor depois de cada trabalho, e roda o código de pessoas sem acesso de escrita (como pull requests de forks) em uma VM nova. 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 máquina dedicada para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/github-self-hosted-runner-cost
