Kay

Posted on Nov 15 Originally published at latchkey.dev

GitHub Actions cost calculator

#devops #githubactions #cloud #cicd

This GitHub Actions cost calculator turns a month of minutes into the bill GitHub sends: $0.006 a minute for a standard 2-core Linux runner, $0.010 for Windows and $0.062 for macOS, read from GitHub's runner pricing reference on 12 November 2026. Enter your Linux, Windows and macOS minutes, pick a runner size and say whether the repository is private or public, and the page works out the GitHub bill, the same month with the Linux minutes on Latchkey at $0.0025 a minute, and the gap between them.

The worked example below: 40,000 Linux, 4,000 Windows and 3,000 macOS minutes on a GitHub Team plan with $18 of included compute, priced at both vendors' published rates read on 12 November 2026.

Two numbers decide what you pay: how many minutes you run, and which machine runs them. The second one moves the bill much further than most teams expect, because a macOS minute lists at more than ten times a Linux minute and a 16-core runner lists at seven times a standard one.

The calculator below is arithmetic on published rates, nothing else. It runs in the page, sends nothing anywhere, and shows its working so you can check any line against the rate tables on this page. The calculator itself is below the rate tables it uses, so skip ahead if you already know your minutes.

What actually decides the bill

GitHub bills Actions on the time your jobs spend on a GitHub-hosted runner, at a rate set by the operating system and the size of the machine. Every job is rounded up to the whole minute, so a repository that runs many short jobs pays for more minutes than it uses.

Private repositories get a monthly amount of included compute, which resets at the start of the billing cycle. Since 28 October 2026 it is a dollar amount rather than a minute count: $12 on GitHub Free, $18 on Pro and Team, $300 on Enterprise Cloud. GitHub deducts each minute at the rate of the runner that used it, so a macOS minute spends it more than ten times faster than a Linux one. Standard runners on public repositories are free, and so are standard runners used by GitHub Pages and Dependabot. Larger runners are charged on public repositories as well as private ones, and on Team and Enterprise Cloud their cost draws on the same included amount.

Self-hosted runners cost nothing to attach. GitHub's billing documentation still states that Actions usage is free for self-hosted runners, which is the quiet reason a self-hosted fleet looks free until you count what the machines cost.

Minutes, rounded up per job, at the rate for the runner you chose.
The operating system: Linux is the floor, Windows is a little under twice it, macOS is more than ten times it.
The machine size: a larger runner lists at roughly double the rate for each doubling of cores.
Repository visibility: standard runners are free on public repositories, larger runners never are.
Storage, billed separately from minutes: artifacts and packages at $0.25 per GB-month, Actions cache at $0.07 per GB-month above the included 10 GB per repository.

The rates the calculator uses

These are the standard GitHub-hosted runner rates. They are the rates that took effect on 1 January 2026, when GitHub cut hosted runner prices by up to 39 percent, and they already include the $0.002 per minute Actions cloud platform charge that GitHub describes in the same announcement.

The Latchkey column is the published rate for the runner of the same size. Latchkey publishes Linux runners only, so Windows and macOS minutes stay on GitHub-hosted runners in every calculation on this page, priced at GitHub's rate on both sides of the comparison.

Runner	GitHub published rate	Latchkey published rate
Linux 2-core x64 (standard)	$0.006/min	latchkey-small, 2 vCPU: $0.0025/min
Linux 2-core arm64 (standard)	$0.005/min	no published arm64 rate
Linux 1-core x64 (standard)	$0.002/min	no published 1-core rate
Windows 2-core x64 (standard)	$0.010/min	no Windows runner published
macOS 3-core or 4-core (standard)	$0.062/min	no macOS runner published

GitHub rates read from Actions runner pricing on 12 November 2026, unchanged since 20 September. Latchkey rates read from latchkey.dev/pricing the same day.

Larger runners: billed everywhere, and the rate climbs with the cores

A larger runner is the same operating system on a bigger machine, and it is not free for public repositories, which is the line in GitHub's documentation that surprises people. Until 28 October 2026 included minutes could not pay for larger runners at all. Now, on Team and Enterprise Cloud, their cost draws on the same dollar amount as standard runners, so a 4-core runner at $0.012 spends a Team plan's $18 in 1,500 minutes.

The arithmetic is simple and unforgiving. Doubling the cores roughly doubles the rate, so a larger runner only pays for itself when it cuts the wall clock by more than it raises the rate. A 4-core Linux runner at $0.012 is worth it if the job finishes in less than half the time; if it finishes in 60 percent of the time, you have paid 20 percent more for a faster red build.

Larger Linux runner (x64)	GitHub published rate	Latchkey equivalent
4-core	$0.012/min	latchkey-medium, 4 vCPU: $0.005/min
8-core	$0.022/min	latchkey-large, 8 vCPU: $0.010/min
16-core	$0.042/min	latchkey-xlarge, 16 vCPU: $0.020/min
32-core	$0.082/min	no published 32 vCPU rate
64-core	$0.162/min	no published 64 vCPU rate

Rates read from Actions runner pricing and latchkey.dev/pricing on 12 November 2026, unchanged since 20 September. Larger runners are available to organizations on GitHub Team and GitHub Enterprise Cloud only. The included compute rules are from GitHub Actions billing, read on 12 November 2026.

A worked example, with every input written down

Take a month of 40,000 Linux minutes, 4,000 Windows minutes and 3,000 macOS minutes, all on standard runners, in private repositories, on a GitHub Team plan that includes $18 of compute a month.

Price every line first. The Linux minutes cost 40,000 at $0.006, which is $240. The Windows minutes cost 4,000 at $0.010, which is $40. The macOS minutes cost 3,000 at $0.062, which is $186. That is $466, and the $18 of included compute comes off the total, because GitHub deducts it in dollars whichever runner spent it. The month is $448.

Now move only the Linux minutes to Latchkey, at the published $0.0025 for a 2 vCPU latchkey-small runner. The Linux line becomes 40,000 at $0.0025, which is $100. Windows and macOS have not moved, so they still cost $40 and $186, and the $18 still comes off them. The month is $308, and the gap is $140, or $1,680 over a year.

Change one input and watch the shape change. If the included compute has already gone on something else, the GitHub month becomes $466 and the Latchkey month becomes $326, and the saving is still $140, because the only thing that moved was the Linux line. The included amount narrows the gap only when it is larger than what stays on GitHub: on Enterprise Cloud, $300 covers the $226 of Windows and macOS minutes and $74 of the Linux line, so the GitHub month is $166, the Latchkey month is $100, and the gap is $66. That is the shape of this comparison: the runner rate is the only lever a cheaper runner pulls, and how Latchkey cuts the GitHub Actions bill is the case for pulling it.

What the calculator does not include

Storage is billed apart from minutes and the calculator does not touch it. Artifacts share an allowance with GitHub Packages and cost $0.25 per GB-month above it, the Actions cache costs $0.07 per GB-month above the 10 GB that every repository gets, and GitHub measures cache by peak usage in each hour rather than at the end of the month.

Rounding is not modeled either. GitHub rounds every job up to the whole minute, so the figure you should type in is the minute count from your own usage report, which is already rounded. A workflow of twenty 20-second jobs bills twenty minutes, not seven.

On the Latchkey side, the calculator charges every Linux minute at the published per-minute rate. It does not subtract the free runner minutes each plan includes, which are 2,000 on Developer, 4,000 on Launch and 6,000 on Scale, and it does not add the monthly plan fee, which is $5, $19 and $49 for those plans. Those two omissions push in opposite directions, and both are left out so that every number on the screen is a published rate multiplied by a minute count you supplied.

Run your own numbers

Take the minute counts from your GitHub usage report rather than from memory, because the report is already rounded the way the bill is. The rate table renders below the form, so the calculation works with JavaScript switched off: multiply the minutes by the rate for your runner, add the lines, and subtract your plan's included compute.

If the result is uncomfortable, the next question is which workflows produced those minutes. Reduce your GitHub Actions costs ranks the changes by what each one saves, how GitHub Actions pricing works explains the rules behind every rate, and a job that dies halfway is a full set of minutes billed for nothing, which is why exit code 137 in GitHub Actions belongs on a cost page at all.

FAQ

How much does GitHub Actions cost?

On a private repository, it costs the per-minute rate of the runner you used, once your plan's included compute is gone: $12 a month on Free, $18 on Pro and Team, $300 on Enterprise Cloud. At the rates published on 12 November 2026 that is $0.006 a minute for a standard 2-core Linux runner, $0.010 for Windows, $0.062 for macOS, and $0.012 to $0.252 for larger Linux runners. On a public repository, standard runners cost nothing at all.

How is use of GitHub Actions measured?

By the processing time each runner type spends on your jobs, with every job rounded up to the whole minute, charged to the repository owner rather than whoever pushed. Storage is measured separately and hourly: artifacts and packages against a shared allowance, and the Actions cache against 10 GB per repository, measured at the peak usage in each hour.

Does GitHub round part minutes up to the next whole minute?

Yes. GitHub's pricing reference states that it rounds the minutes and partial minutes each job uses up to the nearest whole minute. A matrix of thirty 15-second jobs therefore bills thirty minutes rather than eight, which is why splitting a workflow into many tiny jobs can raise the bill while lowering the wall clock.

Is there a limit on usage by public repositories?

Standard GitHub-hosted runners are free on public repositories, and so is standard runner use by GitHub Pages and Dependabot. The exception is larger runners, which GitHub bills at the per-minute rate even on a public repository.

DEV Community