GitHub Actions larger runners pricing
./per-minute --always-billed --2026
The standard GitHub-hosted runners (Linux 2-core, Windows 2-core, macOS) are what your free minutes and plan allowances buy you. Larger runners are a separate SKU: more cores, more RAM, optional GPUs and static IPs, priced per minute and billed from the first second. The catch that surprises most teams is that larger runners never touch your included minutes, so a job you thought was covered by the free tier can quietly meter a bill. This page lists every current per-minute rate and shows what a real month of larger-runner CI costs.
Larger runners are billed per minute and are always charged for — even on public repositories, even when you have free minutes left. Linux x64 runs from $0.012/min (4-core) to $0.162/min (64-core). Windows larger runners cost roughly double. arm64 runners are the cheapest at every size, and a 2-core arm64 runner ($0.005/min) undercuts even the standard Linux rate.
Linux x64 larger runners
The default larger-runner family. Every rate is all-in and billed per minute of execution time.
| Runner | Rate / min | Cost / hour | 10,000 min / mo |
|---|---|---|---|
| Linux 4-core | $0.012 | $0.72 | $120 |
| Linux 8-core | $0.022 | $1.32 | $220 |
| Linux 16-core | $0.042 | $2.52 | $420 |
| Linux 32-core | $0.082 | $4.92 | $820 |
| Linux 64-core | $0.162 | $9.72 | $1,620 |
Rates per docs.github.com (Actions runner pricing reference), verified August 2026. Cost/hour and monthly columns are this page's own arithmetic (rate × minutes).
Windows x64 larger runners
Windows larger runners cost close to double the Linux rate for the same core count, reflecting Windows licensing on top of the compute.
| Runner | Rate / min | Cost / hour | 10,000 min / mo |
|---|---|---|---|
| Windows 4-core | $0.022 | $1.32 | $220 |
| Windows 8-core | $0.042 | $2.52 | $420 |
| Windows 16-core | $0.082 | $4.92 | $820 |
| Windows 32-core | $0.162 | $9.72 | $1,620 |
| Windows 64-core | $0.322 | $19.32 | $3,220 |
Rates per docs.github.com Actions runner pricing reference, verified August 2026.
arm64 larger runners: the cheapest option
Linux arm64 larger runners undercut their x64 equivalents at every size. If your workload already runs on ARM, or can be made architecture-agnostic, this is the single biggest lever on a larger-runner bill: roughly 40 percent off the x64 rate.
| Runner (arm64) | Rate / min | x64 equivalent | Saving |
|---|---|---|---|
| arm64 2-core | $0.005 | n/a (below std) | cheapest of all |
| arm64 4-core | $0.008 | $0.012 | -33% |
| arm64 8-core | $0.014 | $0.022 | -36% |
| arm64 16-core | $0.026 | $0.042 | -38% |
| arm64 32-core | $0.050 | $0.082 | -39% |
| arm64 64-core | $0.098 | $0.162 | -40% |
Rates per docs.github.com Actions runner pricing reference, verified August 2026. Saving column is this page's own arithmetic against the x64 rate.
GPU runners
GitHub also hosts GPU larger runners for machine-learning builds, model tests and CUDA workloads. Like all larger runners, they are billed per minute and never draw from included minutes.
| GPU runner | Rate / min | Cost / hour |
|---|---|---|
| Linux 4-core GPU | $0.052 | $3.12 |
| Windows 4-core GPU | $0.102 | $6.12 |
Rates per docs.github.com Actions runner pricing reference, verified August 2026.
Larger runners never use your free minutes
Standard runners spend your included allowance first (2,000 Linux minutes on Free, 3,000 on Team, 50,000 on Enterprise) and only meter once that is gone. Larger runners work differently: GitHub charges for every minute they execute, even on public repositories and even when your plan's included minutes are untouched. Move a routine job onto a larger runner to shave a few minutes and you swap a free build for a metered one. Keep the everyday PR checks on standard runners and reserve larger runners for the jobs that genuinely need the cores, the RAM, the static IP or the GPU.
Does a bigger runner actually cost more?
Not always. A larger runner that finishes the same build in proportionally less time can cost the same or less, and returns the result sooner. The honest comparison is total cost per build, not the per-minute rate.
The catch is that the speed-up only materialises if the build actually uses the extra cores. A single-threaded compile or a test suite that runs serially will take the same wall-clock time on a 16-core runner as on a 2-core one, and you will pay seven times as much per minute for nothing. Measure your build's parallelism before upgrading.
Keep going
Frequently Asked Questions
# click any question to expand