GitHub Actions larger runners pricing

By Kaveh Alemi·Latchkey

GitHub Actions larger runners pricing runs from $0.006 a minute for the two-core Linux x64 machine to $0.252 for ninety-six cores, read from GitHub's runner pricing reference on 20 September 2026, and none of it can be paid for with the included minutes in your plan. This page puts the machine next to the rate, states the two exceptions that make a first larger-runner invoice bigger than expected, and makes the case that most teams should be sizing up for memory and disk rather than for cores.

A larger runner is not a different product. It is the same Ubuntu or Windows image on a bigger machine, reached by a label your organization has configured, and billed on its own terms rather than yours.

The Linux ladder, with the machine behind each rate

Seven Linux x64 sizes are published, and the specification table and the rate table are separate documents, which is why most write-ups give you one or the other. Together they say what a dollar buys: 4 cores brings 16 GB of RAM and 150 GB of SSD, and 96 brings 384 GB and 2,040 GB.

The arm64 ladder mirrors it up to 64 cores at lower rates, with no 96-core machine. The specification difference worth knowing is at 64 cores, where arm64 carries 208 GB of RAM against 256 GB on x64.

Two exceptions, quoted, because both surprise people

The first is that your plan's allowance does not apply. GitHub states it in one line: "Included minutes cannot be used for larger runners." A GitHub Team account with 3,000 minutes still unspent pays for the first minute of the first larger-runner job.

The second is that repository visibility does not help either: "The larger runners are not free for public repositories." An open source project that switches one job from ubuntu-latest to a 16-core runner goes from paying nothing to paying $0.042 a minute for that job, and is GitHub Actions free has the rest of that boundary.

There are prerequisites as well, and they exist because of those two rules. GitHub requires "a valid credit card on file in order to use larger runners", says the "GitHub Actions spending limit must be set to a value greater than zero", notes that enabling them "can take up to 10 minutes" after the card is added, and restricts larger runners to organizations on GitHub Team or GitHub Enterprise Cloud.

What a core-minute costs, and where the ladder turns

Divide each rate by its core count and the shape of the price list appears. A core-minute costs $0.00300 at both 2 and 4 cores, then falls with every step up to 64 cores, where it reaches $0.00253. At 96 cores it goes back up to $0.00263.

That last row is the only reversal on the Linux ladder, and it is arithmetic rather than opinion: the step from 64 to 96 cores multiplies the cores by 1.5 and the rate by about 1.56. If you are choosing between 64 and 96 cores on price per core alone, 64 is the better buy, and the 96-core machine earns its place only when a job needs more than 256 GB of RAM in one runner.

Most teams should be buying memory and disk, not cores

The standard Linux runner in a private repository has two vCPUs, 8 GB of RAM and 14 GB of disk. The disk number is the one that ends careers: it is the same 14 GB whether the repository is public or private, and it is why a Docker-heavy pipeline runs out of space long before it runs out of patience.

Read the specification column again with that in mind. The 4-core larger runner is not mainly twice the cores; it is twice the memory and more than ten times the disk. A job dying on exit code 137 or on no space left on device is asking for a resource the rate card happens to sell in a bundle with cores.

This matters for the cost case, because a runner bought for memory does not have to run faster to pay for itself. It has to stop a job failing, and a failed job is a full set of billed minutes plus the minutes of the re-run. If a 20-minute build fails one time in four on the standard runner, the re-runs alone cost you five minutes per run on average, and the 4-core machine only has to be no slower to come out level.

# The whole change, once the organization has a larger runner group
jobs:
  build:
    runs-on: ubuntu-latest
    timeout-minutes: 30

  build-larger:
    runs-on: ubuntu-latest-4-cores
    timeout-minutes: 30

Concurrency is the one number that goes up for free

GitHub publishes concurrency by plan and by runner class, and the larger-runner row is the generous one. Standard runners allow 20 concurrent jobs on GitHub Free, 40 on Pro, 60 on Team and 500 on Enterprise. Larger runners allow 1,000 concurrent jobs on both Team and Enterprise Cloud.

So a Team organization that moves a wide matrix onto larger runners raises its ceiling from 60 concurrent jobs to 1,000, which is a real change in how a big test suite behaves. The macOS sub-limit does not move with it: 5 concurrent macOS jobs on Team and 50 on Enterprise, whichever class of runner you use.

A public repository, priced honestly

Take an open source project running 5,000 minutes a month on a 16-core larger runner. At $0.042 that is $210 a month for work that would cost nothing on ubuntu-latest, where a public repository gets a four-vCPU, 16 GB machine for free. If the standard runner can do the job, it is the cheapest option available and nothing paid can beat it.

If the job genuinely needs the bigger machine, the comparison becomes a rate comparison. The same 5,000 minutes on a Latchkey xlarge runner at 16 vCPU and 64 GB is $100 of compute at the published $0.02 a minute, plus a monthly plan fee of $5 on Developer, $19 on Launch or $49 on Scale, with Latchkey's own included minutes not netted off: $105 to $149 all in against GitHub's $210, which is 29 to 50 percent lower. What a cheaper Linux runner changes is the rest of it.

For the sizes above 16 vCPU there is no Latchkey equivalent published, so a 32, 64 or 96-core job stays on GitHub's ladder. To decide whether it should be that size at all, runner cost by size does the per-job arithmetic.

Beyond Linux

Windows larger runners are published at roughly twice the Linux rate at every size, from $0.022 at 4 cores to $0.552 at 96. The larger macOS machines are the 12-core at $0.077 and the 5-core M2 Pro at $0.102, and macOS runner cost covers when either earns its premium. GPU larger runners are $0.052 for 4-core Linux and $0.102 for 4-core Windows.

The arm64 Linux ladder is cheaper than x64 at every size it covers, which is the one place in this price list where the newer option is also the cheaper one. Those rates, and the whole rate card in one table, are on how GitHub Actions pricing works.

Key takeaways

• Linux x64 larger runners run $0.006 at 2 cores to $0.252 at 96, and 96 cores brings 384 GB of RAM.
• Included minutes cannot pay for them, and they are billed on public repositories too.
• A core-minute gets cheaper up to 64 cores and more expensive again at 96.
• Larger runners allow 1,000 concurrent jobs on Team and Enterprise, against 60 and 500 for standard runners.

Frequently asked questions

Related guides

References

• GitHub: Actions runner pricing, every larger runner rate and the two exceptions (verified 2026-09-20)
• GitHub: larger runners, specifications and the credit card prerequisite (verified 2026-09-20)
• GitHub-hosted runners: standard runner specifications by repository visibility (verified 2026-09-20)
• GitHub Actions limits: concurrent jobs by plan and runner class (verified 2026-09-20)
• Latchkey pricing: published per-minute runner rates and plan fees (verified 2026-09-20)
• GitHub Actions documentation