GitHub Actions pricing (2026): minutes, rates and how to cut them
Zihua Li · · 12 min read
GitHub Actions pricing comes down to three numbers: a monthly allowance that depends on your plan, a per-minute rate that depends on the runner, and a storage charge for artifacts and oversized caches. The first two changed in 2026, and the habits that waste the most minutes are the same ones that make CI slow.
GitHub Actions pricing is per minute and per runner type: a standard 2-core Linux runner costs $0.006 a minute, Windows $0.010 and macOS $0.062, with each job rounded up to a whole minute. Each plan includes a monthly allowance, now stated in dollars: $12 on Free, $18 on Pro and Team, $300 on Enterprise Cloud. Standard runners on public repositories and self-hosted runners are free.
How GitHub Actions pricing works in 2026
Every job on a GitHub-hosted runner is billed for the minutes it runs, at the rate of the machine it runs on. GitHub rounds each job up to the nearest whole minute, and a job that fails after five minutes costs five minutes. Your plan’s allowance is spent first; after that, usage is billed against your payment method and any budgets you set.
Two things are free and don’t touch the allowance at all: standard GitHub-hosted runners on public repositories, and self-hosted runners anywhere. Larger runners are billed even on public repositories.
Included usage by plan: the free minutes
On October 28, 2026, GitHub restated the included allowance as a dollar amount instead of a fixed number of standard runner minutes. GitHub calls it the same value, and the Linux column below shows why: the dollar figures divide back into the minute quotas plans had before. The difference is that the pool now also pays for cloud sandboxes, including the Copilot sandboxes behind cloud sessions, and on Team and Enterprise Cloud for larger runners. Sandbox billing starts in November 2026, so a team that uses Copilot cloud sessions now shares its CI allowance with them.
| Plan | Included compute / month | Equals Linux 2-core minutes | Artifact storage |
|---|---|---|---|
| GitHub Free (personal) | $12 | 2,000 | 500 MB |
| GitHub Pro | $18 | 3,000 | 1 GB |
| GitHub Free for organizations | $12 | 2,000 | 500 MB |
| GitHub Team | $18 | 3,000 | 2 GB |
| GitHub Enterprise Cloud | $300 | 50,000 | 50 GB |
The allowance resets each billing cycle. Spent on Windows, $12 buys 1,200 minutes; spent on macOS, about 193. That gap is the single most useful fact in this article.
Per-minute rates by runner
These are the list prices on GitHub’s runner pricing page in November 2026. The first five rows are standard runners; the rest are larger runners, which only organizations on Team or Enterprise Cloud can use, billed only while a job runs on them.
| Runner | USD per minute |
|---|---|
| Linux 1-core x64 (ubuntu-slim) | $0.002 |
| Linux 2-core arm64 | $0.005 |
| Linux 2-core x64 (ubuntu-latest) | $0.006 |
| Windows 2-core, x64 or arm64 | $0.010 |
| macOS 3- or 4-core (macos-latest) | $0.062 |
| Linux 4-core x64 (larger runner) | $0.012 |
| Linux 8-core x64 (larger runner) | $0.022 |
| Linux 8-core arm64 (larger runner) | $0.014 |
| Linux 16-core x64 (larger runner) | $0.042 |
| Windows 8-core x64 (larger runner) | $0.042 |
| macOS 12-core (larger runner) | $0.077 |
| macOS 5-core M2 Pro (larger runner) | $0.102 |
| Linux 4-core GPU (larger runner) | $0.052 |
The rates come from a price cut: GitHub reduced hosted runner prices by up to 39% on January 1, 2026, depending on the machine type. The full larger-runner list, up to 96-core Linux and Windows machines, is on the pricing page.
Storage: artifacts and the cache
Artifacts share a storage pool with GitHub Packages. Usage accrues hourly in GB-hours, and anything above your plan’s allowance costs $0.25 per GB a month. Deleting an artifact stops future charges, but storage already accrued in the current cycle stays on the bill.
The Actions cache is separate: each repository gets 10 GB, measured by each hour’s peak. You pay only if an owner raises the limit above 10 GB, and then $0.07 per GB a month for the part above it. Most repositories never pay for cache at all; the cost of a bad cache shows up as minutes, not storage.
Self-hosted runners and the charge that didn’t start
In December 2025, GitHub announced a $0.002 per-minute “cloud platform charge” on self-hosted runner usage from March 1, 2026. It later updated the announcement: “We’re postponing the announced billing change for self-hosted GitHub Actions to take time to re-evaluate our approach.” As of November 2026, GitHub’s billing documentation still lists self-hosted runners as free, and no new date has been given. Articles that quote the charge as live are describing the original announcement.
GitHub Actions pricing, November 2026: Linux $0.006 a minute, Windows $0.010, macOS $0.062, each job rounded up to a whole minute. Plans include $12 (Free), $18 (Pro, Team) or $300 (Enterprise Cloud) of compute a month. Public repositories on standard runners and all self-hosted runners are free; the self-hosted platform charge announced for March 2026 is postponed.
How to see your GitHub Actions usage and billing
For a personal account, open github.com/settings/billing. For an organization, open the organization and choose Billing & Licensing in the sidebar. The Usage (or Metered usage) view lets you group Actions spending by SKU, which is where a macOS habit becomes visible: one line item for actions_macos next to a much longer bar of Linux minutes that costs less.
For anything beyond the chart, select Get usage report. GitHub emails a download link to your primary address that expires after 24 hours, with the line items behind the chart. GitHub also emails alerts when included usage reaches 90% and 100% in a billing period. Without a payment method on file, usage simply stops at 100%; with one, it continues until a budget stops it, so check that your budgets match what you expect to spend.
The billing pages tell you where the money went. They don’t tell you why. For that, open a workflow run: its summary shows each job’s duration and billable time, and the job logs show which step took the time. The rest of this article is about what you usually find there.
Where GitHub Actions minutes actually go
Bills grow in a few predictable ways, and most of them are also why a pull request waits twenty minutes for green checks.
- Runs nobody waits for. Someone pushes three commits in ten minutes and three full pipelines run to completion. Coding agents make this worse: an agent that pushes, reads the failure and pushes again pays for the whole pipeline each round.
- The same workflow twice. A workflow triggered by both
pushandpull_requestwithout a branch filter runs twice for every commit on a pull request. - Expensive operating systems on every push. A 12-minute macOS job costs what a 124-minute Linux job costs. It is easy to add one for a single bug and never check again whether it still catches anything Linux misses.
- Caches that miss silently. A job with a broken cache key still passes. It just reinstalls every dependency every time.
- Matrices that grew. Three Node versions times three operating systems is nine jobs per push, and the matrix limit is 256.
- Jobs that hang. The default
timeout-minutesis 360. A deadlocked integration test on macOS bills six hours, about $22, before GitHub cancels it. - Many tiny jobs. Because each job rounds up to a minute, thirty ten-second jobs bill thirty minutes.
How to speed up GitHub Actions and cut the bill
The changes below are ordered by how often they pay off. Each one makes CI faster and cheaper at the same time, which makes them easy to argue for.
1. Cancel superseded runs with GitHub Actions concurrency
A concurrency group lets only one run per group proceed. With cancel-in-progress, a new push cancels the run already going for the same pull request. The expression below cancels only on pull requests, so every commit that lands on main still gets a complete run, which matters if that run deploys. The branches: [main] filter on push fixes the double-trigger at the same time.
on:
push:
branches: [main]
pull_request:
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}Concurrency groups also accept queue: max, which lets up to 100 runs wait in a group instead of replacing each other. It can’t be combined with cancel-in-progress: true; it is for deploy queues, not pull request CI.
2. Skip runs that can’t matter with path filters
A README edit doesn’t need the integration suite. paths-ignore skips the workflow when every changed file matches.
on:
pull_request:
paths-ignore:
- 'docs/**'
- '**/*.md'
push:
branches: [main]
paths-ignore:
- 'docs/**'
- '**/*.md'There is one trap. If a workflow skipped by a path filter provides a required status check, GitHub leaves that check pending and the pull request can’t merge. A job skipped by an if: condition, on the other hand, reports success. So for required checks, let the workflow run and skip the expensive job inside it, using a short first job that decides from the changed files. The same rule matters for auto-merge, covered in our guide to GitHub auto-merge.
3. Make the GitHub Actions cache actually hit
The setup actions for npm, Yarn, pnpm, pip, Poetry, Gradle, Maven, Go, .NET and RubyGems cache dependencies with one input. Use those first, and reach for actions/cache only for things they don’t cover, such as build output.
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: pnpm/action-setup@v4
- uses: actions/setup-node@v7
with:
node-version: 24
cache: pnpm
- run: pnpm install --frozen-lockfile
# Anything a setup action doesn't cover: key it on what invalidates it
- uses: actions/cache@v6
with:
path: .next/cache
key: nextjs-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }}-${{ hashFiles('src/**') }}
restore-keys: |
nextjs-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }}-Three rules from GitHub’s cache docs explain most misses. A run can restore caches from its own branch and the default branch, plus the base branch for pull requests, never from sibling branches. Caches created by pull request runs are scoped to the merge ref, so only re-runs of that pull request reuse them; a warm cache on main is what feeds every new pull request, so make sure main builds save one. And entries unused for seven days are evicted, so a weekly job may always start cold. To confirm a hit, read the cache step’s log: a hit says it restored from a key, a miss says no cache was found.
4. Prune the GitHub Actions matrix
A matrix multiplies everything, including cost. Ask which combinations have caught a bug in the last few months. Usually the answer is: the oldest and newest versions you support, on Linux. Run the rest after merge or on a schedule.
jobs:
test:
timeout-minutes: 20
strategy:
fail-fast: true
matrix:
node: [22, 24]
# macOS joins the matrix only on pushes to main, not on pull requests
os: ${{ github.event_name == 'push' && fromJSON('["ubuntu-latest", "macos-latest"]') || fromJSON('["ubuntu-latest"]') }}
runs-on: ${{ matrix.os }}Leave fail-fast at its default of true for pull requests: when one leg fails, GitHub cancels the others instead of letting them finish for a result nobody needs.
5. Move macOS and Windows off every push
If a platform-specific job rarely finds anything Linux misses, run it on merges to main and on release branches. At ten times the Linux rate, this is usually the largest single saving.
jobs:
macos:
if: github.event_name == 'push' && github.ref == 'refs/heads/main'
runs-on: macos-latest
timeout-minutes: 30
steps:
- uses: actions/checkout@v7
- run: ./scripts/test-macos.sh6. Set GitHub Actions timeouts
Set timeout-minutes on every job to roughly twice its normal duration. Steps take the same key, which is useful for the one step that talks to a flaky external service. A timeout turns a six-hour hang into a short, visible failure.
7. Pick the right runner size
Size cuts both ways. Jobs that label issues, post comments or call an API belong on ubuntu-slim: a single-CPU container at $0.002 a minute with a 15-minute job limit and no Docker-in-Docker. Builds that keep every core busy can be cheaper on a larger runner, because a 4-core machine at twice the price that finishes in less than half the time costs less overall. Linux arm64 is cheaper than x64 at every size ($0.005 against $0.006 at 2 cores, $0.014 against $0.022 at 8), and test suites in interpreted languages often run on it unchanged.
jobs:
label-pr:
runs-on: ubuntu-slim # $0.002/min, 15-minute job limit
timeout-minutes: 5
steps:
- run: gh pr edit "$PR" --add-label needs-review
env:
GH_TOKEN: ${{ github.token }}
PR: ${{ github.event.pull_request.html_url }}8. Shorten artifact retention
Artifacts are kept for 90 days by default. A test report that matters for a day can be kept for five.
- uses: actions/upload-artifact@v7
with:
name: playwright-report
path: playwright-report/
retention-days: 5The repository’s retention setting now covers more than artifacts and logs: since October 1, 2026, checks, workflow runs and statuses follow the same setting, so shortening it at the repository level also clears old run history.
9. Run independent jobs in parallel
This one saves time rather than money. A needs: chain makes a pull request wait for the sum of its jobs instead of the longest one. If lint, unit tests and the type check don’t depend on each other, remove the needs between them; the minutes stay the same and the wall-clock time drops to the slowest job.
A worked example: one team’s monthly GitHub Actions bill
Assumptions, stated plainly so you can swap in your own: one private repository in an organization on GitHub Team ($18 of included compute). The team merges 160 pull requests a month with an average of five pushes each, so 800 pushes. Each push runs lint (3 minutes), four test shards (6 minutes each) and a build (5 minutes) on ubuntu-latest, plus one 12-minute macOS job. Job times are already whole minutes, so rounding doesn’t change them. Storage stays within the allowance.
The changes: docs-only pushes (assumed 15%) skip CI, a fixed cache brings each test shard from 6 to 4 minutes, and the macOS job moves to merges on main. Cancelled-run savings from concurrency are left out to keep the arithmetic honest; they only make the second column smaller.
| Line | Before | After |
|---|---|---|
| Linux jobs per push | 32 min (lint 3, tests 4 × 6, build 5) | 24 min (tests 4 × 4 with a warm cache) |
| Pushes that run Linux CI | 800 | 680 (docs-only pushes skipped) |
| Linux minutes × $0.006 | 25,600 min = $153.60 | 16,320 min = $97.92 |
| macOS job (12 min) | Every push: 800 runs | Merges to main only: 160 runs |
| macOS minutes × $0.062 | 9,600 min = $595.20 | 1,920 min = $119.04 |
| Included compute (Team plan) | −$18.00 | −$18.00 |
| Monthly bill | $730.80 | $198.96 |
The bill drops from $730.80 to $198.96 a month, and most of the difference is the macOS job: 9,600 macOS minutes cost almost four times as much as 25,600 Linux minutes. The same arithmetic run on a public repository gives $0 before and after, which is why open-source projects feel CI cost only as time.
Self-hosted runner cost: when it pays off
Self-hosted runners cost nothing on GitHub’s bill, and GitHub’s docs say plainly that you pay for maintaining the machines instead. The comparison isn’t minutes against zero; it is minutes against servers, autoscaling, image updates and someone’s time when a runner wedges at 2 a.m.
- It pays off when runners are busy most of the day, when jobs need hardware GitHub doesn’t offer, or when a warm local disk (Docker layers, a big monorepo checkout) removes minutes from every run.
- It costs more than it looks when usage is spiky, since idle machines bill around the clock, and when the team has no one who wants to own runner images.
- It is risky on public repositories. GitHub’s security guidance says self-hosted runners should almost never be used for public repositories, because anyone can open a pull request that runs code on them.
Between the two sit third-party hosted runner providers that bill per minute below GitHub’s list prices. Compare them on your own minutes per runner type, not on headline rates, and remember that the postponed platform charge could still return for self-hosted usage.
Run the audit automatically
Everything above is a manual audit: read the usage report, open the slowest runs, check cache logs, count how often macOS catches anything. HeyDeer publishes a free, MIT-licensed skill that does this from Claude Code, Codex or Cursor. ci-audit reads your last two weeks of workflow runs, prices your minutes at each runner provider’s list price, and opens with what you could save each month. It looks for the same patterns this article covers, from duplicate triggers and missed caches to flaky jobs and agents that push too many CI rounds, and turns the fixes you pick into small pull requests.
The ci-audit skill installs with npx skills@latest add heydeer/skills --skill ci-audit and runs as /ci-audit (or $ci-audit in Codex). It needs Python 3.8 or later and read access to the repository’s Actions, and it changes nothing until you choose a fix.
Sources
- GitHub Docs: Actions runner pricing
- GitHub Docs: How use of GitHub Actions is measured
- GitHub Changelog: Update to GitHub Actions pricing (December 16, 2025)
- GitHub Changelog: A new, connected Copilot cloud experience (October 28, 2026)
- GitHub Changelog: Actions retention now covers checks, runs, and statuses
- GitHub Docs: Viewing your product usage
- GitHub Docs: Dependency caching reference
- GitHub Docs: Workflow syntax for GitHub Actions
- GitHub Docs: Actions limits
- GitHub Docs: GitHub-hosted runners reference
- GitHub Docs: Troubleshooting required status checks
- GitHub Docs: Self-hosted runners
- actions/setup-node README
- actions/upload-artifact README
Frequently asked questions
How much do GitHub Actions minutes cost?
GitHub Actions minutes cost $0.006 on a standard 2-core Linux runner, $0.005 on 2-core Linux arm64, $0.010 on Windows, $0.062 on macOS and $0.002 on the 1-core ubuntu-slim runner, according to GitHub’s runner pricing page in November 2026. Larger runners range from $0.005 to $0.552 a minute. Each job is rounded up to the nearest whole minute.
How many free GitHub Actions minutes do I get?
GitHub Actions free minutes are now a dollar allowance: $12 a month on GitHub Free and Free for organizations, $18 on Pro and Team, and $300 on Enterprise Cloud. At the standard Linux rate of $0.006 that is 2,000, 3,000 and 50,000 minutes. Windows and macOS minutes use the allowance faster because they cost more per minute.
Is GitHub Actions free for public repositories?
GitHub Actions is free for public repositories on standard GitHub-hosted runners and on self-hosted runners, and that usage doesn’t reduce your included allowance. Larger runners are billed on public repositories too.
Does GitHub charge for self-hosted runners?
GitHub announced a $0.002 per-minute platform charge for self-hosted runners starting March 1, 2026, then postponed it to re-evaluate the approach. As of November 2026, GitHub’s billing documentation lists self-hosted runner usage as free and no new date has been announced. You still pay for the machines you run.
Where can I see my GitHub Actions usage?
GitHub Actions usage is under Billing and licensing: at github.com/settings/billing for a personal account, or the organization’s Billing & Licensing page. The Usage or Metered usage view groups Actions spending by SKU, and Get usage report emails a detailed CSV. Each workflow run’s summary also shows the billable time of its jobs.
Does the GitHub Actions cache cost money?
The GitHub Actions cache is free up to 10 GB per repository. GitHub charges $0.07 per GB a month only if an owner raises the limit above 10 GB and the cache actually uses more. Entries unused for seven days are evicted, and when the cache is full the least recently used entries go first.
Why is my GitHub Actions workflow so slow?
A slow GitHub Actions workflow usually comes from jobs chained with needs that could run in parallel, caches that miss, runs that duplicate each other on push and pull_request, waiting for runners, or a test suite that runs in full on every push. The run’s summary page shows each job’s duration, which is the place to start.
What is the default timeout for a GitHub Actions job?
The default GitHub Actions job timeout is 360 minutes, which is also the 6-hour execution limit on GitHub-hosted runners. A hung job runs until then and bills every minute, so setting timeout-minutes close to a job’s normal duration is one of the cheapest safeguards.



