CI/CD
Precios de GitHub Actions: lo que cuesta un minuto y cómo reducirlo
GitHub Actions factura por minuto por encima de los minutos incluidos en cada plan, y redondea cada job al minuto superior. CRACI ejecuta los mismos workflows aproximadamente el doble de rápido, a un precio por minuto más bajo y facturado por segundos. Un build de 10 minutos cuesta alrededor de un 67% menos.
Actualizado el
Cómo se factura GitHub Actions
Todos los planes de GitHub incluyen minutos de Actions al mes: 2.000 en GitHub Free, 3.000 en Pro y Team, y 50.000 en Enterprise Cloud. Los runners estándar alojados por GitHub son gratuitos en repositorios públicos, y GitHub no cobra por minuto por los runners autoalojados. Por encima de los minutos incluidos, los repositorios privados pagan por minuto de runner, y el precio depende del tamaño, el sistema operativo y la arquitectura del runner. Consulte qué cubren los minutos de CI gratuitos y qué dejan fuera.
A septiembre de 2026, un runner Linux x64 estándar de 2 núcleos cuesta $0.006 por minuto. Dos reglas hacen que la factura sea mayor de lo que sugiere el precio:
- Cada job se redondea al minuto superior. Un job de 10 segundos se factura como un minuto completo, y un workflow con diez jobs cortos paga al menos diez minutos.
- Los runners más grandes siempre se facturan. Los minutos incluidos no se pueden usar para ellos, y no son gratuitos en repositorios públicos.
Precios de GitHub Actions por minuto, todos los tamaños de runner
Precios por minuto de los runners alojados por GitHub a septiembre de 2026, por encima de los minutos incluidos. Los runners Linux de 1 a 32 vCPU pueden ejecutarse en CRACI a $0.002 por minuto de vCPU, tanto en x64 como en ARM64. Hoy CRACI solo funciona en Linux; Windows y macOS están en la hoja de ruta.
| Función | CRACI | GitHub Linux x64 | GitHub Linux ARM64 |
|---|---|---|---|
| 1 vCPU | $0.002 | $0.002 | - |
| 2 vCPU | $0.004 | $0.006 | $0.005 |
| 4 vCPU | $0.008 | $0.012 | $0.008 |
| 8 vCPU | $0.016 | $0.022 | $0.014 |
| 16 vCPU | $0.032 | $0.042 | $0.026 |
| 32 vCPU | $0.064 | $0.082 | $0.050 |
| 64 vCPU | - | $0.162 | $0.098 |
| 96 vCPU | - | $0.252 | - |
| Función | GitHub Windows x64 | GitHub Windows ARM64 |
|---|---|---|
| 2 vCPU | $0.010 | $0.010 |
| 4 vCPU | $0.022 | $0.014 |
| 8 vCPU | $0.042 | $0.026 |
| 16 vCPU | $0.082 | $0.050 |
| 32 vCPU | $0.162 | $0.098 |
| 64 vCPU | $0.322 | $0.194 |
| 96 vCPU | $0.552 | - |
| Función | Precio por minuto |
|---|---|
| macOS macos-latest (M1), 3 vCPU | $0.062 |
| macOS xlarge (M2 Pro), 5 vCPU | $0.102 |
| macOS macos-15-intel, 4 vCPU | $0.062 |
| macOS large (Intel), 12 vCPU | $0.077 |
| GPU Linux, 1x Tesla T4, 4 vCPU | $0.052 |
En Linux x64, el precio de lista de CRACI es inferior al de GitHub a partir de 2 vCPU. En ARM64, el precio de lista de GitHub es inferior a partir de 8 vCPU; la facturación por segundos y los builds más rápidos reducen o eliminan esa diferencia en pipelines reales.
Lo que cuesta un minuto: CRACI frente a los runners alojados por GitHub
| Función | CRACI | Alojados por GitHub | Diferencia |
|---|---|---|---|
| 2 vCPU Linux x64 | $0.004 | $0.006 | CRACI alrededor de un 33% menos |
| 2 vCPU Linux ARM64 | $0.004 | $0.005 | CRACI un 20% menos |
| 32 vCPU Linux x64 | $0.064 | $0.082 | CRACI alrededor de un 22% menos |
| Medición | Por segundos | Cada job redondeado al minuto superior | Sin redondeo en CRACI |
El precio de lista de CRACI es inferior en los runners Linux estándar, y factura por segundos. La diferencia por minuto es de alrededor de un 33% en x64 de 2 vCPU; en pipelines reales, la mayor parte del ahorro viene de eliminar el redondeo. A 32 vCPU en ARM64, el precio de lista de GitHub es inferior. Para ver los precios de todos los proveedores, consulte la comparativa de runners de GitHub Actions.
Los builds más rápidos usan menos minutos
El precio por minuto es solo la mitad de la factura; la otra mitad es cuántos minutos tarda un build. CRACI ejecuta los builds aproximadamente el doble de rápido que los runners alojados por GitHub, gracias a un hardware más rápido, menos tiempo en cola y la caché. Un build que tarda 10 minutos en un runner de 2 núcleos alojado por GitHub tarda unos 5 en CRACI, y usted paga esos 5.
| Función | CRACI | Alojados por GitHub | Ahorro con CRACI |
|---|---|---|---|
| Tiempo de build | Unos 5 minutos | 10 minutos | Alrededor de la mitad de la espera |
| Un build, 2 vCPU x64 | $0.020 | $0.060 | Alrededor de un 67% |
| Un build, 2 vCPU ARM64 | $0.020 | $0.050 | 60% |
| 1.000 builds al mes, 2 vCPU x64 | $20 | $60 | Alrededor de un 67% |
Los builds más rápidos también reducen el coste que nunca aparece en la factura: los ingenieros esperando un check verde antes de poder fusionar.
Dónde compensa la facturación por segundos
El lint, las comprobaciones de tipos, los fragmentos de pruebas unitarias y los pasos de despliegue suelen terminar en mucho menos de un minuto. En los runners alojados por GitHub, cada uno sigue costando un minuto completo. En CRACI paga los segundos que se ejecutó. Los ejemplos siguientes comparan jobs de la misma duración, antes de cualquier mejora de velocidad.
| Función | CRACI | Alojados por GitHub | Ahorro con CRACI |
|---|---|---|---|
| 1.000 jobs de 30 segundos | $2.00 | $6.00 | Alrededor de un 67% |
| 1.000 jobs de 70 segundos | $4.67 | $12.00 | Alrededor de un 61% |
| 1.000 builds de 10 minutos | $40.00 | $60.00 | Alrededor de un 33% |
| 1.000 builds de 10 minutos, 32 vCPU x64 | $640 | $820 | Alrededor de un 22% |
Cuanto más cortos son los jobs, mayor es el ahorro de la facturación por segundos. En los builds largos, el ahorro viene de la velocidad: alrededor de un 67% en un build de 10 minutos, frente a alrededor de un 33% solo por el precio por minuto.
Calcule su factura
Introduzca las cifras de su pipeline. El informe de uso de facturación de GitHub muestra las ejecuciones, los jobs y los minutos por workflow.
Precios de lista a septiembre de 2026, para los minutos que superan los incluidos en cada plan. GitHub redondea cada job al minuto completo; CRACI mide por segundo. Con la opción de velocidad, cada job tarda la mitad en CRACI.
Los costes que no aparecen por minuto
- Reejecuciones. Una prueba inestable que falla una de cada diez ejecuciones añade aproximadamente un 10% a la factura de su workflow, y cada job reejecutado se vuelve a redondear.
- Jobs colgados. Sin
timeout-minutes, un job atascado sigue ejecutándose hasta el límite de GitHub y se factura entero. - Ingenieros esperando. Los pipelines lentos cuestan tiempo de los desarrolladores, que suele valer mucho más que los minutos. Ajuste el tamaño de los runners a los jobs de la ruta crítica o ejecútelos en un runner más rápido.
- Sobrecoste del autoalojamiento. Los runners autoalojados evitan el precio por minuto, pero no el coste: las máquinas están inactivas entre builds, y alguien tiene que parchearlas, escalarlas y protegerlas. Consulte runners gestionados frente a autoalojados.
Ocho formas de reducir la factura
- Cancele las ejecuciones obsoletas. Un grupo
concurrencyconcancel-in-progressdetiene la ejecución de un commit antiguo cuando llega uno más reciente a la misma rama. - Omita el trabajo que no corresponda. Los filtros
pathsevitan que un cambio en la documentación ejecute todo el conjunto de pruebas. - Guarde las dependencias en caché. Restaurar paquetes desde una caché es más rápido que descargarlos en cada ejecución.
- Establezca tiempos de espera. Un valor
timeout-minutesen cada job impide que un job colgado consuma minutos hasta el límite por defecto. - Agrupe los jobs diminutos. Con el redondeo a minutos enteros, tres jobs de 10 segundos cuestan tres minutos; un job que haga los tres cuesta uno.
- Ajuste el tamaño de los runners. Un runner más grande cuesta más por minuto, pero puede costar menos por build si termina mucho antes. Mida ambas cosas.
- Use ARM64 donde sea más barato. En GitHub, el precio de lista de un runner ARM64 de 2 núcleos es inferior al de x64.
- Cambie a un runner más rápido y más barato. CRACI ejecuta los builds aproximadamente el doble de rápido, tiene un precio de lista más bajo en los runners Linux estándar y factura por segundos, sin más cambios en el workflow que
runs-on.
Cambiar a CRACI
CRACI sustituye el runner, no GitHub Actions. Instale la GitHub App de CRACI, cambie runs-on a craci, y el job se ejecutará en CRACI mientras el workflow, sus acciones y sus logs siguen en GitHub. Los tamaños van de 1 a 32 vCPU y se configuran con la acción cracicorp/setup. Mueva primero un workflow y compare el tiempo de build y la factura.
CRACI solo cobra por los minutos de build: $0.002 por minuto de vCPU ($0.004 para un runner de 2 vCPU por defecto), medidos por segundos, sin cuota mensual ni cargos por SBOM. Las startups pueden obtener al menos 100.000 minutos de build gratuitos a través del programa para startups. Consulte los precios.
El mismo runner también registra una SBOM de lo que descargó cada job, aplica una política de egress y registra datos de procedencia, de modo que el build más rápido y más barato viene con un registro de lo que entró en él. Consulte CRACI frente a los runners alojados por GitHub.
Precios de GitHub Actions: preguntas frecuentes
¿Cuánto cuesta GitHub Actions?
Los planes incluyen minutos gratuitos cada mes: 2.000 en GitHub Free, 3.000 en Pro y Team, y 50.000 en Enterprise Cloud. Por encima de eso, un runner Linux x64 estándar de 2 núcleos cuesta $0.006 por minuto a septiembre de 2026, y los runners más grandes cuestan más.
¿Cuánto cuesta GitHub Actions por minuto?
A septiembre de 2026, un runner Linux estándar de 2 núcleos cuesta $0.006 por minuto en x64 y $0.005 en ARM64. Windows cuesta $0.010 con 2 núcleos, y macOS empieza en $0.062. Los runners más grandes escalan con el tamaño, hasta $0.252 por minuto para Linux x64 de 96 núcleos. GitHub redondea cada job al minuto superior.
¿CRACI es más barato que los runners alojados por GitHub?
Sí, en los runners Linux estándar. CRACI tiene un precio de lista de $0.004 por minuto con 2 vCPU ($0.002 por minuto de vCPU), alrededor de un 33% por debajo de los $0.006 de GitHub para x64 de 2 núcleos, factura por segundos y ejecuta los builds aproximadamente el doble de rápido, de modo que cada build usa menos minutos. Un build que tarda 10 minutos en un runner de 2 núcleos alojado por GitHub cuesta alrededor de un 67% menos en CRACI, es decir, un tercio del precio.
¿Por qué CRACI es más rápido que los runners alojados por GitHub?
Por tres cosas a la vez: un hardware más rápido, menos tiempo en cola antes de que empiece un job y la caché. CRACI ejecuta los builds aproximadamente el doble de rápido que los runners alojados por GitHub.
¿GitHub redondea los minutos de Actions?
Sí. GitHub redondea cada job al minuto superior, de modo que un job que se ejecuta durante 10 segundos se factura como un minuto completo. Los pipelines con muchos jobs cortos son los que más pagan por el redondeo.
¿Los minutos incluidos cubren los runners más grandes?
No. GitHub indica que los minutos incluidos no se pueden usar para runners más grandes, y estos no son gratuitos en repositorios públicos. Se factura cada minuto en ellos.
¿GitHub Actions es gratuito para repositorios públicos?
Sí, en los runners estándar. GitHub indica que los runners estándar alojados por GitHub son gratuitos en repositorios públicos.
¿Los runners autoalojados son gratuitos?
GitHub no cobra por minuto por los runners autoalojados, pero usted paga las máquinas, incluidas las inactivas, y es responsable de su sistema operativo, su software y su seguridad. GitHub advierte de que los runners autoalojados casi nunca deberían usarse en repositorios públicos.
¿Cómo muevo un job a CRACI?
Instale la GitHub App de CRACI y cambie runs-on a craci en el job. El workflow, sus acciones y sus logs siguen en GitHub. Elija un tamaño de runner de 1 a 32 vCPU con la acción cracicorp/setup.
Reduzca su factura de GitHub Actions
Cambie runs-on en un workflow, ejecútelo en CRACI y compare el tiempo de build y la factura línea por línea.
Reservar una demo