# GitHub Actions arm64 runners pricing, size by size

> GitHub Actions arm64 runners pricing against x64 at every size, with the discount at each step and how much slower arm64 may run before it pays.

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

GitHub Actions arm64 runners pricing is a discount that grows with the machine: 16.7 percent below x64 on the standard 2-core Linux runner, and 39.5 percent below it at 64 cores, read from GitHub's runner pricing reference on 21 September 2026. The standard Windows runner is the exception that catches people out, because arm64 and x64 are both $0.010 a minute there, so switching a small Windows job to arm64 saves nothing at all.

There is one arithmetic question on this page and everything else serves it: how much slower is your job allowed to be on arm64 before the cheaper minute stops being cheaper? The answer is the ratio of the two rates, it is different at every size, and at the standard size it is tighter than most people expect.

The rates below are GitHub's published ones. They changed from a multiplier model to flat per-minute rates, so nothing here needs a conversion step, and the included-minutes allowance is counted in minutes rather than in dollars.

## Every arm64 rate, against the x64 rate beside it

Standard Linux arm64 is $0.005 a minute against $0.006 for standard Linux x64. That is the rate most workflows would move to, and it is the smallest discount on the page: one tenth of a cent a minute, or $10 a month on ten thousand minutes.

The larger runners are where the money is. Linux arm64 at 4 cores is $0.008 against $0.012, at 8 cores $0.014 against $0.022, at 16 cores $0.026 against $0.042, at 32 cores $0.050 against $0.082, and at 64 cores $0.098 against $0.162. The discount widens monotonically from a third to just under 40 percent, and there is no arm64 runner at 96 cores, so the top of the x64 ladder has no cheaper twin.

Windows behaves differently at both ends. The standard Windows runner is $0.010 a minute on arm64 and $0.010 on x64, an identical rate, so the arm64 discount does not exist at standard size. On the larger Windows runners it reappears and is the largest on the rate card: $0.014 against $0.022 at 4 cores, rising to $0.194 against $0.322 at 64. There is also a 2-core Windows arm64 larger runner at $0.008 with no x64 counterpart at that size.

| Machine | arm64 rate | x64 rate | arm64 discount | Slower it may run and still pay |
| --- | --- | --- | --- | --- |
| Linux 2-core, standard | $0.005 | $0.006 | 16.7% | 20% |
| Linux 4-core, larger | $0.008 | $0.012 | 33.3% | 50% |
| Linux 16-core, larger | $0.026 | $0.042 | 38.1% | 61% |
| Linux 64-core, larger | $0.098 | $0.162 | 39.5% | 65% |
| Windows 2-core, standard | $0.010 | $0.010 | none | not at all |
| Windows 16-core, larger | $0.050 | $0.082 | 39.0% | 64% |

> Rates from [Actions runner pricing](https://docs.github.com/en/billing/reference/actions-runner-pricing), read 21 September 2026. The break-even column is the x64 rate divided by the arm64 rate, rounded down to a whole percent.

## What the break-even column actually means

Read the last column as a permission rather than a promise. On the standard Linux runner, arm64 costs five sixths of x64, so an arm64 job may take up to 20 percent longer and cost exactly what the x64 job cost. Beyond that the cheaper minute buys you a more expensive job, and you have also made every pipeline slower.

Twenty percent is not a lot of headroom. It is comfortably inside the range an interpreted test suite moves by between two architectures, and it is well inside what an emulated container costs, so on the standard runner the switch has to be measured rather than assumed. On a 16-core larger runner the same job is allowed to be 61 percent slower before it stops paying, which is enough headroom that the decision usually goes the other way.

Rounding shortens the odds again at the small end, because GitHub "rounds the minutes and partial minutes each job uses up to the nearest whole minute". A 65-second job bills two minutes on either architecture, so the whole saving on that job is $0.002, and a matrix of twenty short jobs saves four cents a run. The arm64 discount is a large-job and large-machine instrument.

## Where the saving lands on a real month

Take ten thousand Linux minutes a month in private repositories. On the standard x64 runner that is $60 and on standard arm64 it is $50: a real ten dollars, and not a number anyone will notice on an invoice. Put the same work on a 4-core larger runner and it is $120 against $80, which is a $40 difference on the same ten thousand minutes, and on a 16-core runner it is $420 against $260.

Two rules move that number more than the architecture does. Included minutes cannot be used for larger runners, so every larger-runner minute is billed from the first one, and larger runners are not free on public repositories while standard runners are. An open source project running on `ubuntu-24.04-arm` pays nothing; the moment it switches to a larger arm64 runner for speed, it starts paying for every minute.

None of this is a rate you can improve by moving vendor on the arm64 line specifically, and it would be dishonest of us to imply otherwise: Latchkey sells Linux x64 managed runners at $0.0025 a minute for 2 vCPU with 8 GB and does not sell arm64 at all. Ubicloud does, publishing $0.00125 a minute for a 2 vCPU arm64 runner on its own pricing page read the same day, which is below every rate on this page. [What Ubicloud CI is](/learn/runners/ubicloud-runners-explained) works through what that rate comes with.

## Before you move the label

The labels are `ubuntu-24.04-arm`, `ubuntu-22.04-arm` and `ubuntu-26.04-arm` on Linux, and `windows-11-arm` on Windows. In a private repository they give you 2 vCPU with 8 GB of memory and 14 GB of SSD, the same shape as the x64 standard runner; in a public repository the standard runners are 4 vCPU with 16 GB.

The cost of getting this wrong is not a failed build, it is a slow one that still bills. Anything that pulls a container image without an arm64 variant will either fail to pull or quietly run under emulation, and an emulated job is several times slower, which turns a 16.7 percent discount into a large net loss. The compatibility work is the subject of [running GitHub Actions on ARM](/learn/speed/run-github-actions-on-arm); this page is only the rate card behind it.

Measure one workflow at both labels for a week before you move the rest, and compare billed minutes rather than wall clock, because rounding is what you are actually charged on. For the model behind the whole rate card, see [how GitHub Actions pricing works](/learn/cost/github-actions-pricing-explained), and for the larger-runner ladder in full, [GitHub Actions larger runners pricing](/learn/cost/github-actions-larger-runners-pricing).

```.github/workflows/ci.yml
# x64 today
jobs:
  test:
    runs-on: ubuntu-latest

# arm64, same 2 vCPU and 8 GB in a private repo, $0.005 against $0.006
jobs:
  test:
    runs-on: ubuntu-24.04-arm

# both, for one week, so you can compare billed minutes rather than guess
jobs:
  test:
    strategy:
      matrix:
        runner: [ubuntu-latest, ubuntu-24.04-arm]
    runs-on: ${{ matrix.runner }}
```

## FAQ

### How much cheaper are GitHub arm64 runners than x64?

It depends entirely on the size. Standard Linux arm64 is $0.005 against $0.006, a 16.7 percent discount. Larger Linux runners run from 33.3 percent cheaper at 4 cores to 39.5 percent at 64. Standard Windows arm64 is the same $0.010 as x64, so there is no discount there at all.

### How much slower can an arm64 job be before it costs more?

Divide the x64 rate by the arm64 rate. On the standard Linux runner that is 1.2, so a 20 percent slowdown is break-even. On a 4-core larger runner it is 1.5, and at 64 cores it is about 1.65. The bigger the machine, the more slowdown the discount absorbs.

### Are arm64 runners free on public repositories?

The standard arm64 runners are, because the use of standard GitHub-hosted runners is free and unlimited on public repositories, and `ubuntu-24.04-arm` is a standard runner. Larger runners of any architecture are billed even on public repositories, so switching a public project to a larger arm64 runner starts a bill that did not exist before.

### Is there a 96-core arm64 runner?

No. The published arm64 Linux ladder stops at 64 cores and $0.098 a minute, while x64 continues to 96 cores at $0.252. If a job genuinely needs 96 cores there is no cheaper architecture available for it, and the question becomes whether the job parallelises well enough to justify the top of the x64 ladder at all.

### Which arm64 runner labels does GitHub publish?

On Linux, `ubuntu-24.04-arm`, `ubuntu-22.04-arm` and `ubuntu-26.04-arm`; on Windows, `windows-11-arm` and `windows-11-vs2026-arm`. In private repositories they are 2 vCPU with 8 GB of memory and 14 GB of SSD, and in public repositories the standard runners are 4 vCPU with 16 GB.

## References

- [GitHub: Actions runner pricing, every arm64 and x64 per-minute rate (verified 2026-09-21)](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [GitHub: hosted runner specifications and the arm64 workflow labels (verified 2026-09-21)](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)
- [GitHub: Actions billing, included minutes and the larger-runner exceptions (verified 2026-09-21)](https://docs.github.com/en/billing/concepts/product-billing/github-actions)
- [Ubicloud pricing: a second published arm64 runner rate card (verified 2026-09-21)](https://www.ubicloud.com/docs/about/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