GitHub Actions macOS runner cost

By Kaveh Alemi·Latchkey

GitHub Actions macOS runner cost is $0.062 a minute for the standard 3-core or 4-core machine, which is 10.3 times the $0.006 a standard Linux minute costs, read from GitHub's runner pricing reference on 20 September 2026. That single ratio is why a mobile team's Actions bill is mostly macOS even when most of its jobs never touch Xcode, and why the cheapest change available to you is usually moving work off macOS rather than making macOS faster.

One 25-minute build costs $0.15 on Linux, $1.55 on standard macOS, $1.93 on 12-core and $2.55 on M2 Pro — The same 25 minutes of runner time on each machine, at the per-minute rates published on docs.github.com and read on 20 September 2026.

macOS minutes are not billed with a multiplier any more. GitHub publishes a flat per-minute rate for each runner, and the macOS rates simply sit an order of magnitude above the Linux ones, which produces the same bill the old 10x multiplier did.

The rest of this page is arithmetic: what a macOS minute costs, what a real iOS pipeline costs at that rate, when a larger macOS runner is worth its higher rate, and which steps in a mobile workflow have no reason to be on macOS at all.

The rates, stated exactly

There are three macOS runners with published rates. The standard 3-core or 4-core machine, which is what macos-latest gives you, is $0.062 a minute. The 12-core larger runner is $0.077. The 5-core M2 Pro larger runner is $0.102, the most expensive minute GitHub sells outside its GPU tier.

Against the $0.006 standard Linux x64 rate, that is 10.3x, 12.8x and 17x. The comparison that matters more is against your allowance: included minutes are counted in minutes, not in dollars, so a 3,000 minute allowance spent on macOS is worth $186 of compute and the same allowance spent on Linux is worth $18.

Runner	Per-minute rate	Cost of 60 minutes	Against Linux x64
Linux 2-core x64 (standard)	$0.006	$0.36	1x
macOS 3-core or 4-core (standard)	$0.062	$3.72	10.3x
macOS 12-core (larger)	$0.077	$4.62	12.8x
macOS 5-core M2 Pro (larger)	$0.102	$6.12	17x

What an iOS pipeline costs, with the inputs written down

Take a team that merges 20 pull requests on a working day and runs its iOS workflow on every push and on every merge, so roughly 40 runs a day across 21 working days. Call the workflow 25 minutes of macOS time: checkout, dependency resolution, an Xcode build and a simulator test pass.

That is 840 runs, 21,000 macOS minutes, and 21,000 at $0.062 is $1,302 a month. A GitHub Team allowance of 3,000 minutes covers the first 3,000 of them, so the invoice is 18,000 at $0.062, which is $1,116. Add a nightly release build of 45 minutes and you add 1,350 minutes, or $83.70.

Now change one input. If half of those 25 minutes is work that does not need Xcode, moving that half to a standard Linux runner turns 10,500 macOS minutes into 10,500 Linux minutes: $651 becomes $63, and the month falls by $588 with no change to what the pipeline actually does. That is the whole argument of this page in one line.

Rounding hurts most on macOS

GitHub rounds the minutes and partial minutes each job uses up to the nearest whole minute. On a Linux runner that rounding is loose change. On macOS it is the most expensive rounding in the product.

A six-leg matrix of 90-second macOS jobs uses nine minutes of machine time and bills twelve, because each leg is rounded to two. At $0.062 that is $0.74 a run instead of $0.56, a third more, repeated on every push. Fewer, longer macOS jobs cost less than many short ones, which is the opposite of the advice that speeds up a Linux pipeline.

Larger macOS runners: the break-even is arithmetic, not opinion

A 12-core macOS runner costs 24.2 percent more per minute than the standard machine, and the 5-core M2 Pro costs 64.5 percent more. Neither is worth anything unless it returns more wall clock than it takes in rate.

Put your own build time through it. A 25-minute build has to finish in under 20 minutes and 8 seconds on the 12-core runner to break even, and in under 15 minutes and 12 seconds on the M2 Pro. If it does better than that, the faster machine is cheaper as well as quicker. If it does not, you have bought a more expensive red build.

Measure before you switch, on your own repository. Xcode builds are often bound by a single-threaded link step or by simulator boot time, and neither of those gets faster on a machine with more cores.

Larger macOS runner	Rate premium	A 25-minute build must finish in
macOS 12-core, $0.077	24.2% more than $0.062	20 minutes 8 seconds
macOS 5-core M2 Pro, $0.102	64.5% more than $0.062	15 minutes 12 seconds

What actually needs macOS, and what is just sitting there

Xcode, the iOS simulator, and Apple code signing and notarization need macOS. Very little else in a mobile pipeline does. Swift itself builds and runs on Linux, so SwiftLint and SwiftFormat do not need a Mac. Neither does the JavaScript bundle of a React Native app, a Ruby lane that only calls the App Store Connect API, a changelog step, a dependency audit, or anything that reads source text and writes a report.

The change is a job split, not a rewrite. Put the checks that do not need Xcode on ubuntu-latest, leave the Xcode build on macos-latest, and let the two run in parallel so the wall clock improves at the same time as the bill. Add paths-ignore so a documentation-only pull request does not start a macOS machine at all, a change priced alongside six others in how to reduce GitHub Actions costs.

.github/workflows/ios.yml

# before: everything on the most expensive machine in the product
jobs:
  ios:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v7
      - run: swiftlint --strict
      - run: bundle exec danger
      - run: xcodebuild -scheme App -destination "platform=iOS Simulator,name=iPhone 16" test

# after: only the Xcode step pays the macOS rate
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - run: swiftlint --strict
      - run: bundle exec danger
  ios:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v7
      - run: xcodebuild -scheme App -destination "platform=iOS Simulator,name=iPhone 16" test

Where a cheaper runner does and does not help

Be clear about the limit. Latchkey publishes Linux runners only, at $0.0025 a minute for 2 vCPU, so no managed runner on our price list makes an Xcode build cheaper. What it changes is the price of everything you move off macOS: the half of that pipeline that runs on Linux costs $63 a month at GitHub's rate and $26.25 at ours, and how Latchkey cuts the GitHub Actions bill is that argument in full.

If a cheaper Mac is what you actually need, the market has one and we do not. WarpBuild lists a 6 vCPU M4 Pro macOS runner at $0.08 a minute and a 12 vCPU one at $0.16, read from warpbuild.com/pricing on 20 September 2026: below the $0.102 GitHub charges for its 5-core M2 Pro, above the $0.062 standard macOS rate, and worth pricing against your own build times rather than against a rate card alone.

On a public repository the calculation changes again, because standard macOS runners are free there along with every other standard runner. Open source iOS projects pay nothing for the machine and should ignore this page entirely, right up until someone switches a job to a larger runner, which is billed on public repositories too.

For the whole billing model behind these rates, see how GitHub Actions pricing works. To price your own month, the GitHub Actions cost calculator takes macOS minutes as an input and keeps them on GitHub where they belong. If the answer is that you want your own Macs, what a self-hosted GitHub runner really costs works through that bill.

Key takeaways

A standard macOS minute is $0.062, which is 10.3 times a standard Linux minute.
Included minutes are counted in minutes, so an allowance spent on macOS is worth ten times more.
Per-job rounding makes short macOS matrix legs disproportionately expensive.
A 12-core macOS runner has to cut a 25-minute build to 20 minutes 8 seconds just to break even.

Frequently asked questions

Why is my GitHub Actions bill mostly macOS minutes?

Because a macOS minute lists at $0.062 and a Linux minute at $0.006. A pipeline that spends 20 percent of its minutes on macOS spends about 72 percent of its money there. The bill is not telling you that your iOS workflow is slow; it is telling you what the machine costs.

Does the 10x macOS multiplier still apply in 2026?

GitHub no longer publishes minute multipliers. It publishes a flat per-minute rate for each runner, and on 20 September 2026 those rates were $0.062 for standard macOS and $0.006 for standard Linux x64. The ratio is 10.3, so the old rule of thumb still predicts the bill even though the mechanism behind it is gone.

Are macOS minutes free on public repositories?

Yes, on standard runners. GitHub's billing documentation says the use of standard GitHub-hosted runners is free in public repositories, and standard macOS runners are included in that. Larger macOS runners, the 12-core and the M2 Pro, are always charged for, even on a public repository and even when your plan still has included minutes.

What do the larger macOS runners cost?

The 12-core macOS runner is $0.077 a minute and the 5-core M2 Pro is $0.102, against $0.062 for the standard machine. Neither can use included minutes. They pay for themselves only if they cut the build by more than 19.5 percent and 39.2 percent of its wall clock respectively, which is the rate ratio, not the premium.