$ ~/cicdcalculator
This site is open for sponsorshipHow it works →

GitHub Actions larger runners pricing
./per-minute --team-and-enterprise --2026

By Oliver Wakefield-Smith, Founder, Digital Signet

The standard GitHub-hosted runners (Linux, Windows, macOS) are available on every plan. Larger runners are a separate SKU, available only on Team and Enterprise Cloud: more cores, more RAM, optional GPUs and static IPs, priced per minute. GitHub counts included compute in dollars ($18 a month on Team, $300 on Enterprise Cloud), and a larger runner spends those dollars faster than a standard one, so the allowance runs out sooner and the rest of the month is billed. On public repositories, standard runners are free but larger runners are billed. This page lists every current per-minute rate and shows what a real month of larger-runner CI costs.

Direct answer

Larger runners are billed per minute and are only available on Team and Enterprise Cloud. They draw on the plan's included compute ($18 a month on Team, $300 on Enterprise Cloud) but spend it faster than standard runners, and everything past it is billed. On public repositories they are billed while standard runners are free. 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 larger runners at every size, and a 2-core arm64 larger runner ($0.005/min) costs the same as the standard 2-core arm64 runner.

Linux 4-core (x64)
$0.012 / min
Linux 64-core (x64)
$0.162 / min
Cheapest larger (arm64 2-core)
$0.005 / min
Draws included compute?
Yes, on Team/EC

Linux x64 larger runners

The default larger-runner family. Every rate is all-in and billed per minute of execution time.

RunnerRate / minCost / hour10,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), re-read 20 November 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.

RunnerRate / minCost / hour10,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, re-read 20 November 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 / minx64 equivalentSaving
arm64 2-core$0.005$0.006 (standard)-17%
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, re-read 20 November 2026. The arm64 2-core larger runner costs the same as the standard 2-core arm64 runner; its x64 comparison is the standard Linux 2-core runner. 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 on Team and Enterprise Cloud they draw on the plan's included compute at that rate.

GPU runnerRate / minCost / 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, re-read 20 November 2026.

The catch that bites

Larger runners spend your included compute faster

GitHub counts each plan's included compute in dollars ($12 a month on Free, $18 on Team, $300 on Enterprise Cloud, worth 2,000, 3,000 and 50,000 standard Linux 2-core minutes) and only meters once that is gone. Larger runners are only available on Team and Enterprise Cloud, and there they spend the same dollars at their own rate: a 4-core Linux minute at $0.012 uses twice what a 2-core minute at $0.006 uses, and a 16-core minute at $0.042 uses seven times as much. Once the included amount is gone, every minute is billed. On public repositories, standard runners are free but larger runners are billed, so moving a routine public-repo job onto a larger runner swaps 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.

Linux 2-core (standard)
$0.180
30 min build
$0.006/min x 30. Cheapest per minute, slowest result.
Linux 8-core
$0.176
8 min build
$0.022/min x 8. Same cost, 22 minutes sooner.
Linux 16-core
$0.168
4 min build
$0.042/min x 4. Cheapest overall and fastest, if the build parallelises.

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

How much do GitHub Actions larger runners cost?>
GitHub-hosted larger runners are billed per minute at a rate that scales with core count. On Linux x64 the rates are $0.012 per minute for 4-core, $0.022 for 8-core, $0.042 for 16-core, $0.082 for 32-core and $0.162 for 64-core. Windows larger runners cost roughly double: $0.022 (4-core) up to $0.322 (64-core). arm64 larger runners are cheaper than x64 at every size. Rates per the docs.github.com Actions runner pricing reference, re-read 20 November 2026.
Do larger runners use my free or included minutes?>
Yes, on Team and Enterprise Cloud, which are the only plans that can use larger runners. GitHub counts included compute as a dollar amount ($18 a month on Team, $300 on Enterprise Cloud), and a larger runner spends it at its own per-minute rate: a 4-core Linux minute at $0.012 uses twice what a standard 2-core Linux minute at $0.006 uses. Anything past the included amount is billed. Free and Pro accounts cannot use larger runners. On public repositories, standard runners are free but larger runners are billed.
Are arm64 larger runners cheaper than x64?>
Yes, noticeably. GitHub prices Linux arm64 larger runners below their x64 equivalents at every size: $0.008 per minute for 4-core (vs $0.012 x64), $0.014 for 8-core (vs $0.022), $0.026 for 16-core (vs $0.042), $0.050 for 32-core (vs $0.082) and $0.098 for 64-core (vs $0.162). There is also a 2-core arm64 larger runner at $0.005 per minute, the same rate as the standard 2-core arm64 runner. If your build runs on ARM (or can be made architecture-agnostic), arm64 runners cut the compute bill by roughly 40 percent.
Do larger runners cost extra on public repositories?>
Yes. Standard runners are free on public repositories, but larger runners are an exception: they are billed per minute even for public repos. If you attach a larger runner to an open-source project's workflow, you pay the per-minute rate for every minute it executes, so most public projects keep heavy jobs on the free standard runners and reserve larger runners for private, time-critical builds.
What is the cheapest GitHub Actions larger runner?>
The Linux arm64 2-core larger runner at $0.005 per minute is the cheapest larger runner, the same rate as the standard 2-core arm64 runner. Among the higher-core options, arm64 is always cheaper than x64 for the same core count. If you only need extra RAM or a static IP (a common reason to reach for larger runners) rather than raw cores, the smallest arm64 runner is the most economical way to get it.
How much do GPU runners cost on GitHub Actions?>
GitHub-hosted GPU larger runners are billed per minute like other larger runners: a Linux 4-core GPU runner is $0.052 per minute and a Windows 4-core GPU runner is $0.102 per minute. As with all larger runners, they spend a Team or Enterprise Cloud plan's included compute at their own rate and are billed past it. A single hour of GPU CI time on Linux costs about $3.12.
When are larger runners worth the extra cost?>
Larger runners pay off when a faster machine finishes the job in enough less wall-clock time to offset the higher per-minute rate, or when a build genuinely needs more RAM, more cores for parallel test suites, a static outbound IP for allow-listing, or a GPU. A 16-core runner at $0.042/min that completes a build in 4 minutes ($0.168) beats a 2-core runner at $0.006/min that takes 30 minutes ($0.180) and returns the result 26 minutes sooner. Always time the trade-off on your real workload rather than assuming the cheapest per-minute runner wins.