# GitHub Actions pricing in 2026 and how to lower your bill

What GitHub Actions costs in 2026: per-minute rates for every hosted runner, how the bill is calculated, and the settings and runner choices that lower it.

[All posts](https://avrea.com/blog)

[Blog](https://avrea.com/blog)
[CI/CD](https://avrea.com/category/ci-cd)

What GitHub Actions costs in 2026: per-minute rates for every hosted runner, how the bill is calculated, and the settings and runner choices that lower it.

[Tatu Mäkijärvi](https://avrea.com/team/tatu-makijarvi)
2 October 2026

GitHub Actions is free on public repositories with standard runners. For private repositories, runner costs draw from the plan's included compute allowance, then add to your bill. Standard rates are $0.006 per minute for 2-core Linux x64, $0.010 for Windows and $0.062 for macOS.

Those rates have applied since January 1, 2026, when GitHub cut hosted-runner prices by up to 39%. After the included allowance, runner charges depend on each job’s runtime, rounded up to a whole minute, and the runner’s rate.

To lower the bill, start by canceling outdated runs and cutting retries, check that each job is on the cheapest runner that can do it, and then compare what the same workflow costs on another provider.

## Free usage and included compute

GitHub doesn’t charge for:

- standard GitHub-hosted runners in public repositories
- jobs on self-hosted runners in any repository, public or private (you pay for the machines, not for Actions)
- GitHub Pages and Dependabot jobs on standard runners

GitHub plans include a monthly dollar allowance for compute. Private and internal repository runners share it with cloud sandbox compute and memory.

| Plan | Included compute per month | Artifact storage | Cache storage per repository |
| --- | --- | --- | --- |
| GitHub Free (personal accounts and organizations) | $12 | 500 MB | 10 GB |
| GitHub Pro | $18 | 1 GB | 10 GB |
| GitHub Team | $18 | 2 GB | 10 GB |
| GitHub Enterprise Cloud | $300 | 50 GB | 10 GB |

The allowance resets each billing cycle. It covers standard runners in private and internal repositories, plus eligible larger runners on Team and Enterprise Cloud. Larger runners are still charged in public repositories. Without a payment method, usage stops when the allowance runs out; larger runners require a payment method. With one, additional usage is billed unless a [budget](https://docs.github.com/en/billing/how-tos/set-up-budgets) is set to stop it.

Usage is charged to the owner of the repository, not to the person who triggered the run.

Each runner uses the allowance at its listed rate. Ten minutes on standard Linux x64 uses $0.06; ten minutes on standard Windows uses $0.10. The Team plan’s $18 covers 3,000 standard Linux x64 minutes if no other eligible compute uses it.

Source: [GitHub Actions billing](https://docs.github.com/en/billing/concepts/product-billing/github-actions), checked November 17, 2026.

## GitHub-hosted runner pricing

Standard runners are what you get from labels such as `ubuntu-latest`, `windows-latest` and `macos-latest`.

| Standard runner | Per minute |
| --- | --- |
| Linux 1-core (x64) | $0.002 |
| Linux 2-core (x64) | $0.006 |
| Linux 2-core (arm64) | $0.005 |
| Windows 2-core (x64 or arm64) | $0.010 |
| macOS 3-core or 4-core (M1 or Intel) | $0.062 |

[Larger runners](https://docs.github.com/en/actions/concepts/runners/larger-runners) are available on the Team and Enterprise Cloud plans and are priced by core count. The table includes GitHub’s 2-core larger-runner SKUs. The 2-core Linux x64 entry is Linux Advanced; the 2-core Windows ARM rate is a larger-runner rate, distinct from the standard Windows rate above.

| Cores | Linux x64 | Linux arm64 | Windows x64 | Windows arm64 |
| --- | --- | --- | --- | --- |
| 2 | $0.006 (Advanced) | $0.005 | not listed | $0.008 |
| 4 | $0.012 | $0.008 | $0.022 | $0.014 |
| 8 | $0.022 | $0.014 | $0.042 | $0.026 |
| 16 | $0.042 | $0.026 | $0.082 | $0.050 |
| 32 | $0.082 | $0.050 | $0.162 | $0.098 |
| 64 | $0.162 | $0.098 | $0.322 | $0.194 |
| 96 | $0.252 | not offered | $0.552 | not offered |

| Other larger runners | Per minute |
| --- | --- |
| macOS 12-core | $0.077 |
| macOS 5-core (M2 Pro) | $0.102 |
| Linux 4-core GPU | $0.052 |
| Windows 4-core GPU | $0.102 |

Source: GitHub’s [Actions runner pricing reference](https://docs.github.com/en/billing/reference/actions-runner-pricing), checked November 17, 2026.

From 4 to 64 cores, the Linux x64 rate works out to $0.002 plus $0.0025 per core, which is why doubling the cores doesn’t quite double the price. Linux arm64 follows the same pattern at $0.0015 per core and Windows x64 at $0.005. The flat $0.002 matches the platform charge that GitHub says is included in every hosted-runner rate.

## How billed minutes are calculated

GitHub rounds every job up to the next whole minute. The rounding is per job, not per workflow run, so the number of jobs matters as well as how long they take.

Take a workflow with three jobs on standard Linux runners. The durations are invented to show the arithmetic.

| Job | Runs for | Billed |
| --- | --- | --- |
| lint | 40 s | 1 min |
| unit tests | 6 min 20 s | 7 min |
| build | 3 min 5 s | 4 min |

The run used 10 minutes 5 seconds of runner time and is billed as 12 minutes.

Now split the unit tests into four parallel shards. The pull request gets its result sooner, but each shard repeats the checkout and the dependency install, and each one is rounded up separately. If the shards take 2 minutes 10 seconds each, that’s four jobs billed at 3 minutes. The tests used to cost 7 billed minutes and now cost 12.

At 30 runs a working day, the original workflow uses about 7,560 billed minutes a month (30 runs, 21 days, 12 minutes). At $0.006 per minute, that is $45.36 of compute. If the Team plan’s $18 allowance is otherwise unused, the bill is $27.36.

A job that fails is still billed for the time it ran, and so is every re-run. GitHub’s own example is a 10-minute workflow that fails after 5 minutes and then succeeds on a re-run, which comes to 15 billed minutes.

## Storage pricing

| Storage | Per GB per month, beyond the included amount |
| --- | --- |
| Artifacts and GitHub Packages (shared allowance) | $0.25 |
| Actions cache | $0.07 |
| Custom images for larger runners | $0.07 |

GitHub measures storage every hour and bills the GB-hours accumulated over the month. Deleting artifacts stops further charges, but the hours already accrued stay on the bill. Artifacts are kept for 90 days unless you say otherwise, so a shorter `retention-days` on uploads that nobody opens after the run is the simplest saving.

The cache is counted separately. Each repository gets 10 GB, and GitHub [evicts older entries](https://docs.github.com/en/actions/reference/workflows-and-actions/dependency-caching) when a repository reaches its limit. You’re charged only if an administrator has raised the limit above 10 GB, and then for the usage above 10 GB, measured at each hour’s peak.

Custom image storage has its own allowance: 75 GB on Team and 150 GB on Enterprise Cloud.

Sources: [GitHub storage billing](https://docs.github.com/en/billing/concepts/product-billing/github-actions) and [included usage](https://docs.github.com/en/billing/reference/product-usage-included), checked November 17, 2026.

## Self-hosted runner pricing

GitHub charges no Actions fee for jobs on [self-hosted runners](https://docs.github.com/en/actions/concepts/runners/self-hosted-runners), in public or private repositories. It came close to changing that.

On December 16, 2025, GitHub [announced two changes](https://github.blog/changelog/2025-12-16-coming-soon-simpler-pricing-and-a-better-experience-for-github-actions/). Hosted-runner prices would drop on January 1, 2026, and from March 1, 2026 a $0.002 per minute “cloud platform charge” would apply to self-hosted runner usage in private repositories. The next day GitHub added an update saying it was “postponing the announced billing change for self-hosted GitHub Actions”. The price cut went ahead as planned. GitHub’s [current billing documentation](https://docs.github.com/en/billing/concepts/product-billing/github-actions) still lists self-hosted runner usage as free, checked November 17, 2026. You still pay for the machines or your runner provider.

## Third-party runner pricing

Several companies run GitHub Actions jobs on their own machines. GitHub still schedules the workflow, and you pay the provider for the minutes instead. Our [guide to GitHub Actions runners](https://avrea.com/blog/github-actions-runners) covers how hosted, self-hosted and third-party runners differ. These are list prices for 2 vCPU Linux and Windows runners and each provider’s entry macOS configuration. Memory and plan requirements appear where they change the rate. Our [runner pricing comparison](https://avrea.com/github-actions-runner-pricing) puts minute rates, monthly plan fees and included usage side by side.

| Provider | Linux x64, 2 vCPU | Linux arm64, 2 vCPU | macOS | Windows | Included usage per month |
| --- | --- | --- | --- | --- | --- |
| GitHub-hosted | $0.006 | $0.005 | $0.062 (3 or 4 cores) | $0.010 (2 cores) | $12 to $300 of shared compute credit, by plan |
| Avrea | $0.004 | $0.012 (M5 Max) | $0.08 (8 vCPU, M5 Max) | $0.008 (2 vCPU) | 3,000 free minutes, counted in 2 vCPU Linux x64 minutes |
| Blacksmith | $0.004 | $0.0025 | $0.08 (6 vCPU, M4) | $0.008 (2 vCPU, public beta) | 3,000 free minutes, counted in 2 vCPU Linux x64 minutes |
| Depot | $0.006 | $0.006 | $0.08 (8 vCPU; all plans) | $0.008 (2 vCPU) | No free tier; 2,000 minutes in the $20 single-user plan, 20,000 in the $200 plan |
| Namespace | $0.002 to $0.004 prepaid, $0.003 to $0.006 overage (4 GB to 8 GB) | same as x64 | $0.04 prepaid, $0.06 overage (4 vCPU) | $0.004 prepaid, $0.006 overage (2 vCPU, 4 GB; $100 plan or higher) | No free minutes; 100,000 unit-minutes in the $100 plan |

Some of these don’t reduce to one number. Namespace bills in unit-minutes: one unit is 1 vCPU with 2 GB of memory for a minute, at $0.001 on a prepaid plan or $0.0015 in overage, so a 2 vCPU runner with 4 GB counts as two units and one with 8 GB as four. Depot has no free tier: plans start at $20 a month for one user and $200 a month for a team. RunsOn isn’t in the table because it’s software you run in your own AWS account: you pay an annual license, starting at €300 for fewer than 50,000 jobs a month, plus AWS infrastructure charges. Higher job volumes require a higher license tier.

Free minutes are not plain minutes either. Blacksmith and Avrea both count them in 2 vCPU Linux x64 minutes, so other runners use them faster: Blacksmith’s 3,000 are 1,500 minutes on Windows or 150 on macOS, and Avrea’s are 1,500 on Windows, 1,000 on ARM or 150 on macOS.

Cache storage is priced by product, so the plans don’t line up neatly. Avrea includes 25 GB per repository at no charge for its GitHub Actions, Git LFS, build and regular package caches, with more storage available to purchase. Private Swift package payloads use separate organization storage. [Avrea persistent disks](https://docs.avrea.com/persistent-disks/) are also billed separately, at $0.50 per provisioned GB per month. Blacksmith’s [GitHub Actions cache](https://docs.blacksmith.sh/blacksmith-caching/dependencies-actions) includes 25 GB per repository per week at no charge, and its Docker layer caching is an add-on at $0.50 per GB a month. Depot includes 25 GB of cache and registry storage with its $20 plan and 250 GB with its $200 plan, then charges $0.20 per GB a month. Namespace prices each cache separately: $0.20 per GB a month for its Turborepo, Gradle and Bazel caches and $0.0048 per GB a day for cache volumes plus $0.002 per GB-hour while a volume is attached, with allowances for both on its paid plans.

For a breakdown of runner rates, plan fees and caching costs, see [Avrea vs Blacksmith](https://avrea.com/avrea-vs-blacksmith) and [Avrea vs Depot](https://avrea.com/avrea-vs-depot).

The [Avrea vs WarpBuild](https://avrea.com/avrea-vs-warpbuild) and [Avrea vs Ubicloud](https://avrea.com/avrea-vs-ubicloud) comparisons cover their runner rates, included usage and cache charges in detail.

The machines behind these prices are not the same. Avrea’s ARM and macOS runners are Apple M5 Max machines, and its ARM rate reflects that. A 2 vCPU runner at one provider can finish a build in half the time it takes at another, so the price of a minute tells you less than the price of a job. Our [runner benchmark comparison](https://avrea.com/blog/fastest-github-actions-runners) shows how far apart they are.

Sources: the pricing pages and documentation of [Blacksmith](https://www.blacksmith.sh/pricing), [Depot](https://depot.dev/pricing), [Namespace](https://namespace.so/pricing) and [RunsOn](https://runs-on.com/pricing/), checked November 17, 2026.

## When GitHub-hosted runners are the cheaper choice

Standard runners are free for public repositories. For private repositories, the Team plan’s $18 allowance covers 250 runs of the 12-minute standard Linux workflow above, provided no other eligible compute uses the credit. Usage within that allowance has no additional runner charge.

A third-party runner can lower the bill when the same jobs cost less after allowances, rounding and any plan fees. Faster feedback can also be worth paying for even when GitHub’s compute allowance covers your current usage.

## How to lower your GitHub Actions bill

### Find where the minutes go

The [usage page](https://docs.github.com/en/billing/how-tos/products/view-productlicense-use) under Billing and licensing in your GitHub settings breaks usage down by SKU and by repository. Look at it before changing anything. A bill that is mostly macOS minutes needs a different fix from one where a single repository runs a long test suite on every push. Once you know which workflows cost the most, our [GitHub Actions observability guide](https://avrea.com/blog/github-actions-observability) covers how to find the slow steps inside them.

### Combine very short jobs

Three 15-second checks cost 3 billed minutes as separate jobs and 1 minute as steps in a single job.

Test shards work the same way, as the example above showed. Add shards until the wait is acceptable and stop there.

### Cut failed runs and retries

Put cheap checks in front of expensive ones. In the three-job workflow from earlier, adding `needs: lint` to the test and build jobs means a formatting error costs 1 billed minute, not 12. Tests start later on every run in exchange, so this pays off where lint failures are common.

A job that fails one run in ten for no reason costs about a tenth more, because every re-run is charged in full. When you do re-run, use [“Re-run failed jobs”](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/re-run-workflows-and-jobs), which re-runs the failed jobs and any jobs that depend on them, not the whole workflow.

Set `timeout-minutes` a little above each job’s normal duration. Without it, a hung job runs for 360 minutes before GitHub cancels it, which on a 16-core Linux runner is about $15.

Leave `fail-fast` on in matrix builds. It is the default, and it cancels the rest of the matrix when one job fails. Setting it to `false` shows you every failure and bills you for every job.

Runs that a newer push has made irrelevant are the same kind of cost. `concurrency` with `cancel-in-progress: true` [cancels them](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency).

### Use the cheapest runner that fits the job

Light jobs can run on the [1-core runner](https://docs.github.com/en/actions/reference/runners/github-hosted-runners). `ubuntu-slim` costs $0.002 a minute, a third of the standard Linux rate. It runs in a container, has a 15-minute job limit and can’t run Docker-in-Docker, so it suits labeling, triage and other short automation jobs, not builds.

Linux on arm64 is cheaper than Linux on x64. `ubuntu-24.04-arm` costs $0.005 a minute against $0.006, which is worth having for a workload that doesn’t depend on the architecture, such as a Node or Python test suite with no native x64 dependencies.

Keep macOS and Windows for the jobs that need them. A macOS minute costs about ten times a Linux minute, so linting and platform-independent tests belong on Linux.

A larger runner pays off when it cuts the billed time by more than its higher rate, or when the job needs the extra memory or disk. The 8-core Linux runner costs 3.7 times the 2-core rate, so on compute alone a job has to finish more than 3.7 times faster to cost less.

## What the same workflow costs on Avrea

The changes above remove minutes you didn’t need. The minutes that remain are the builds and tests themselves, and their cost comes down to two numbers: how long the job runs and what the runner costs per minute. A different runner can change both.

Avrea is our runner service for GitHub Actions. Jobs run on Avrea’s machines. You keep defining workflows and storing secrets in GitHub, and as on any runner, a job receives the secrets it references while it runs. You [install the GitHub App](https://docs.avrea.com/getting-started/) and change the [runner label](https://docs.avrea.com/runners/), and the [migration wizard](https://console.avrea.com/convert) can open that pull request for you:

```
jobs:
  test:
    runs-on: avrea-ubuntu-latest   # was ubuntu-latest
```

### Avrea’s rates next to GitHub’s

| Runner | GitHub-hosted | Avrea |
| --- | --- | --- |
| Linux x64, 2 vCPU | $0.006 | $0.004 |
| Linux x64, 4 vCPU | $0.012 | $0.008 |
| Linux x64, 8 vCPU | $0.022 | $0.016 |
| Linux x64, 16 vCPU | $0.042 | $0.032 |
| Linux x64, 32 vCPU | $0.082 | $0.064 |
| Linux arm64, 2 vCPU | $0.005 | $0.012 |
| Windows, 2 vCPU | $0.010 | $0.008 |
| Windows, 4 vCPU | $0.022 | $0.016 |
| macOS | $0.062 (3 or 4 cores, M1 or Intel), $0.102 (5 cores, M2 Pro) | $0.08 (8 vCPU, M5 Max) |

Sources: GitHub’s [Actions runner pricing reference](https://docs.github.com/en/billing/reference/actions-runner-pricing) and [avrea.com/pricing](https://avrea.com/pricing), checked November 17, 2026.

From 2 vCPU up, Avrea’s Linux x64 and Windows runners cost 20 to 33% less per minute than the GitHub runner of the same size. Avrea also bills each job for the seconds it ran, rounded down, with no minimum, where GitHub rounds each job up to a whole minute. The three-job workflow from earlier ran for 10 minutes 5 seconds and was billed as 12 minutes on GitHub, which is 7.2 cents. At the same durations on Avrea it costs about 4 cents.

There is no monthly base fee. Eligible organizations receive a monthly credit equivalent to 3,000 minutes on 2-vCPU Linux x64 runners. Other runner types, static IPs and persistent disks draw on the same credit; the [billing guide](https://docs.avrea.com/billing/#free-monthly-minutes) explains eligibility and usage. Each repository includes 25 GB of regular cache storage.

### Why jobs finish sooner on Avrea

Compiling, linking and running tests depend mostly on single-core speed and on how fast the runner reads and writes files. Avrea’s runners are built around those two things, and around keeping caches close.

The Linux x64 and Windows runners use dedicated bare-metal AMD EPYC processors chosen for single-thread performance. In [our Linux kernel benchmark](https://avrea.com/blog/linux-kernel-ci-benchmark), Avrea’s 2 vCPU runner scored about 6,500 in single-core sysbench and GitHub’s 2-core runner about 3,700.

The disks are local NVMe. On the same two runners, disk writes ran at about 4 GB/s on Avrea and about 220 MB/s on GitHub, which shows up in dependency installs, cache restores and any build that writes thousands of small files.

The [caches](https://docs.avrea.com/cache/overview/) run on the same infrastructure as the runners, so a restore reads from storage in the same datacenter instead of a remote storage service. `actions/cache` (v4 and later) and the setup actions work unchanged; in [our cache benchmark](https://avrea.com/blog/how-we-made-github-actions-cache-up-to-6x-faster), restoring a 1 GB cache took 14 seconds on GitHub and 2.9 seconds on Avrea. Package managers resolve through a local proxy, and build tools such as Go, Bazel and Gradle are preconfigured to use a remote build cache.

The kernel benchmark shows what that adds up to. The same build on the same 2 vCPU runner size took 27 minutes 23 seconds on GitHub and 9 minutes 3 seconds on Avrea with no cache, and 24 seconds with a warm ccache. At list prices that is 16.8 cents of runner time on GitHub, about 3.6 cents on Avrea, and about 0.2 cents with the cache. These are the build times the post reports, so treat the costs as estimates, not invoice lines.

Our case studies report what customers measured after moving their GitHub Actions jobs to Avrea. [Teamspective](https://avrea.com/case-studies/teamspective)’s median CI run went from 10 minutes to 4.5. [Luo](https://avrea.com/case-studies/luo)’s build stage went from 9 minutes 18 seconds to 3 minutes 5 seconds. [PromoRepublic](https://avrea.com/case-studies/promorepublic)’s went from about 4 minutes to 42 seconds.

Not every workflow speeds up. A build that spends most of its time waiting on an external service takes about as long on any runner. For caching on any runner, see [A guide to GitHub Actions caching](https://avrea.com/blog/github-actions-cache) and [How to speed up GitHub Actions](https://avrea.com/blog/speed-up-github-actions).

### macOS and ARM runners

On macOS, the 8 vCPU M5 Max runner costs $0.08 a minute. GitHub’s standard runner, a 3 vCPU M1 on `macos-26`, costs $0.062, and its 5-core M2 Pro runner costs $0.102. In [our iOS and macOS benchmark](https://avrea.com/blog/ios-macos-ci-benchmark), with caches turned off, the M5 Max ran eleven builds of nine open-source apps 3.6 to 6.9 times faster than the standard runner and about twice as fast as the M2 Pro. The Firefox for iOS test build took 747.6 seconds on GitHub’s standard runner and 139.6 seconds on Avrea. Prorated at list prices, that build step is about 77 cents on GitHub and 19 cents on Avrea. These are build-step times, not whole jobs, so an invoice would differ.

The ARM Linux runners use the same [M5 Max](https://avrea.com/blog/m5-max-runners-macos-arm-linux-ci-on-apple-silicon) chip, which has some of the fastest single-thread performance of any ARM processor. At 2 vCPU they cost $0.012 a minute against $0.005 for GitHub’s ARM runner, so a job that finishes about 2.4 times faster costs roughly the same on both, before rounding and free minutes, and anything beyond that is a saving. The break-even is higher on larger sizes.

### Try it on one workflow

Copy one workflow file, give it the Avrea label and push it on a branch. It runs next to your existing CI on the same commits, so you can compare job durations and cost directly. The console shows [CPU and memory for each job](https://avrea.com/observability), which also tells you whether the job needs the runner size it’s on.

Last updated 19 November 2026

## Explore other articles

- 30 Jun 2026
GitHub Actions runners: hosted, self-hosted and managed
Read
<https://avrea.com/blog/github-actions-runners>

- 22 Oct 2026
Runner right-sizing: stop paying for capacity your jobs don't use
Read
<https://avrea.com/blog/runner-right-sizing>

- 27 Aug 2026
How to Speed Up GitHub Actions
Read
<https://avrea.com/blog/speed-up-github-actions>

## Start shipping with Avrea

[Start free](https://console.avrea.com/)
[Talk to an engineer](https://avrea.com/demo)
