GitHub Actions arm64 runners pricing, size by size

Q: 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.

By Kaveh Alemi·Latchkey

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.

The arm64 discount against x64 widens from 16.7 percent at 2 cores to 39.5 percent at 64 cores — The arm64 discount at each Linux size, computed from the per-minute rates published on docs.github.com/en/billing/reference/actions-runner-pricing and read on 21 September 2026.

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%

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 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; 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, and for the larger-runner ladder in full, 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 }}

Key takeaways

The arm64 discount widens with the machine: 16.7 percent at standard Linux, 39.5 percent at 64 cores.
Standard Windows arm64 and x64 are both $0.010 a minute, so there is no discount at that size.
On the standard Linux runner an arm64 job may be 20 percent slower before the cheaper rate stops paying.
Larger runners of either architecture cannot use included minutes and are billed on public repositories.

Frequently asked questions

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.