# GitHub Actions larger runners pricing

> GitHub Actions larger runners pricing by size, with the vCPU, RAM and disk behind each rate, the two exceptions, and what to size up for.

Source: https://latchkey.dev/learn/cost/github-actions-larger-runners-pricing  
Updated: 2026-09-20

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.

| Larger Linux runner | vCPU and RAM | SSD | Rate, x64 | One 10-minute job |
| --- | --- | --- | --- | --- |
| 2-core advanced | 2 vCPU, 8 GB | 75 GB | $0.006 | $0.06 |
| 4-core | 4 vCPU, 16 GB | 150 GB | $0.012 | $0.12 |
| 8-core | 8 vCPU, 32 GB | 300 GB | $0.022 | $0.22 |
| 16-core | 16 vCPU, 64 GB | 600 GB | $0.042 | $0.42 |
| 32-core | 32 vCPU, 128 GB | 1,200 GB | $0.082 | $0.82 |
| 64-core | 64 vCPU, 256 GB | 2,040 GB | $0.162 | $1.62 |
| 96-core | 96 vCPU, 384 GB | 2,040 GB | $0.252 | $2.52 |

> Rates from [Actions runner pricing](https://docs.github.com/en/billing/reference/actions-runner-pricing) and specifications from [larger runners](https://docs.github.com/en/actions/reference/runners/larger-runners), both read 20 September 2026. The last column is the rate times ten minutes.

## 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](/learn/cost/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.

| Size | Rate a minute | Cost of one core-minute |
| --- | --- | --- |
| 2-core | $0.006 | $0.00300 |
| 4-core | $0.012 | $0.00300 |
| 8-core | $0.022 | $0.00275 |
| 16-core | $0.042 | $0.00263 |
| 32-core | $0.082 | $0.00256 |
| 64-core | $0.162 | $0.00253 |
| 96-core | $0.252 | $0.00263 |

> Each row is the published rate in [Actions runner pricing](https://docs.github.com/en/billing/reference/actions-runner-pricing), read 20 September 2026, divided by the core count of that 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](/learn/failures/exit-code-137-in-github-actions) or on [no space left on device](/learn/failures/no-space-left-on-device-github-actions) 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.

```.github/workflows/build.yml
# 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](/github-actions-cost-reduction) 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](/learn/cost/github-actions-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](/learn/cost/github-actions-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](/learn/cost/github-actions-pricing-explained).

## FAQ

### How big does a GitHub Actions larger runner get?

The largest published Linux and Windows machine is 96 vCPU with 384 GB of RAM and 2,040 GB of SSD, on x64 only, billed at $0.252 a minute for Linux and $0.552 for Windows. The arm64 ladder stops at 64 vCPU with 208 GB. There is also a GPU size: 4 vCPU with one Tesla T4, 28 GB of RAM and 16 GB of VRAM.

### Do larger runners use my included minutes?

No. GitHub's pricing reference states that included minutes cannot be used for larger runners, so they bill from the first minute of the first job even on an account whose allowance is untouched. They are also billed on public repositories, where standard runners are free and unlimited, which is the combination that makes the first invoice larger than expected.

### What do I need before I can use a larger runner?

An organization on GitHub Team or GitHub Enterprise Cloud, a valid credit card on file, and a GitHub Actions spending limit set above zero. GitHub notes that enabling larger runners can take up to 10 minutes after the card is added. Without all three, the runner label exists but no job will start on it.

### How many larger runner jobs can run at once?

1,000 concurrent jobs on both GitHub Team and GitHub Enterprise Cloud, against 60 and 500 for standard runners on the same plans. The macOS ceiling is separate and does not rise: 5 concurrent macOS jobs on Team and 50 on Enterprise, shared between standard and larger macOS runners.

## References

- [GitHub: Actions runner pricing, every larger runner rate and the two exceptions (verified 2026-09-20)](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [GitHub: larger runners, specifications and the credit card prerequisite (verified 2026-09-20)](https://docs.github.com/en/actions/reference/runners/larger-runners)
- [GitHub-hosted runners: standard runner specifications by repository visibility (verified 2026-09-20)](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)
- [GitHub Actions limits: concurrent jobs by plan and runner class (verified 2026-09-20)](https://docs.github.com/en/actions/reference/limits)
- [Latchkey pricing: published per-minute runner rates and plan fees (verified 2026-09-20)](https://latchkey.dev/pricing)

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt