How GitHub Actions billing works, and how to work out your bill
GitHub Actions bills every job that runs on a GitHub-hosted runner by the minute, at a rate set by the runner's operating system and size, and rounds each job up to the next whole minute. Your plan includes a monthly amount of compute in dollars ($12 on GitHub Free, $18 on Pro and Team, $300 on Enterprise Cloud), so your bill is the minutes times each runner's rate, less that amount. Billing & Licensing → Usage shows the total, and the usage report CSV breaks it down by runner, repository and workflow.
What GitHub charges per minute
Rates for the runners most teams use, in US dollars per minute:
| Runner | Billing SKU | Per minute |
|---|---|---|
Linux 1-core x64 (ubuntu-slim) | actions_linux_slim | $0.002 |
Linux 2-core x64 (ubuntu-latest on private repositories) | actions_linux | $0.006 |
| Linux 2-core arm64 | actions_linux_arm | $0.005 |
Windows 2-core x64 (windows-latest on private repositories) | actions_windows | $0.010 |
| macOS 3-core or 4-core (M1 or Intel) | actions_macos | $0.062 |
| Linux 4-core x64 (larger runner) | linux_4_core | $0.012 |
| Linux 8-core x64 (larger runner) | linux_8_core | $0.022 |
| Linux 16-core x64 (larger runner) | linux_16_core | $0.042 |
| Linux 32-core x64 (larger runner) | linux_32_core | $0.082 |
| Linux 64-core x64 (larger runner) | linux_64_core | $0.162 |
| Windows 4-core x64 (larger runner) | windows_4_core | $0.022 |
| Windows 8-core x64 (larger runner) | windows_8_core | $0.042 |
GitHub's runner pricing page lists the rest: Linux and Windows up to 96 cores, arm64 sizes, GPU runners, and the larger macOS runners.
Three rules decide what you pay:
- Each job rounds up. "GitHub rounds the minutes and partial minutes each job uses up to the nearest whole minute." A job that runs 2 minutes 5 seconds bills 3 minutes.
- Larger runners need GitHub Team or Enterprise Cloud. Only organizations on those plans can use them, and they're billed on public repositories too.
- Some use is free. Standard runners on public repositories, self-hosted runners, GitHub Pages and Dependabot don't draw on your included compute.
What each plan includes
GitHub used to include a number of minutes. It now includes compute "expressed as a monetary amount, not a fixed number of minutes":
| Plan | Included compute a month | The same on ubuntu-latest ($0.006/min) | Artifact storage |
|---|---|---|---|
| GitHub Free (personal accounts) | $12 | 2,000 min | 500 MB |
| GitHub Pro | $18 | 3,000 min | 1 GB |
| GitHub Free for organizations | $12 | 2,000 min | 500 MB |
| GitHub Team | $18 | 3,000 min | 2 GB |
| GitHub Enterprise Cloud | $300 | 50,000 min | 50 GB |
The minutes column divides the dollars by the Linux 2-core rate; GitHub gives the same guide for Enterprise Cloud ("$300 USD covers 50,000 minutes on a standard Linux runner"). On a faster runner the same dollars buy fewer minutes. Larger runners draw on the included compute only on GitHub Team and Enterprise Cloud.
The included compute resets at the start of each billing cycle. For metered products that's 00:00 UTC on the first of the month, and unused compute doesn't carry over.
Storage is billed apart from minutes: shared artifact and Packages storage over the allowance costs $0.25 per GB a month, and Actions cache over its 10 GB per repository costs $0.07 per GB a month.
The formula
For one month:
bill = Σ (minutes on each runner × its rate) − included compute, and never below $0.
Count the minutes per job, rounded up, then add them per runner SKU. Larger runners draw on the included compute too, since only Team and Enterprise Cloud have them.
Read your bill in Billing & Licensing → Usage
- For an organization: click your profile picture, Your organizations, then Settings next to the organization, and Billing & Licensing under Access in the sidebar. For a personal account: github.com/settings/billing.
- Open the Usage (or Metered usage) view.
- Filter to Actions, set Group to SKU, and pick the Time Frame. The chart and the table below it show the same data.
The dashboard may show Actions as spend in dollars rather than minutes; that spend already reflects each runner's rate. You need to be an owner or a billing manager to see an organization's usage.
For one run, open the run's summary and click Usage under "Run details". It shows the billable minutes per job, rounded up, for GitHub-hosted runners on private repositories.
Read the usage report CSV
The usage report gives you every row behind the chart.
- On the Metered usage page, click Get usage report.
- Choose the report and the period, then click Email me the report.
- Open the link in the email within 24 hours; it expires after that.
There are two reports:
- Summarized usage report: up to one year, summed by
date,sku,repositoryandcost_center_name. - Detailed usage report: up to 31 days, and adds
usernameandworkflow_path. Only the web interface has it; the REST API returns the summary.
The columns that matter for Actions:
| Column | What it holds |
|---|---|
date | The day of use, in UTC |
product, sku | Actions, and the runner SKU (actions_linux, linux_8_core, …) |
quantity, unit_type | How much was used, and in what unit |
applied_cost_per_quantity | The rate applied |
gross_amount | The cost before anything is taken off |
discount_amount | What was taken off: your included compute, and the free use on public repositories and self-hosted runners |
net_amount | What you're billed: gross_amount − discount_amount |
repository, workflow_path | Where the use came from (workflow_path in the detailed report only) |
To find your costs, filter product to Actions, then make a pivot table: rows by sku, sums of quantity and net_amount. Group by workflow_path instead to see which workflow costs most. If the month's net_amount is zero but gross_amount isn't, the included compute covered everything; gross_amount is what the same jobs cost once it doesn't.
A worked example
An organization on GitHub Team runs these jobs on private repositories in a month:
| Runner | Minutes | Rate | Cost |
|---|---|---|---|
ubuntu-latest (Linux 2-core) | 9,000 | $0.006 | $54.00 |
| Linux 4-core larger runner | 2,500 | $0.012 | $30.00 |
| macOS | 300 | $0.062 | $18.60 |
| Total before included compute | 11,800 | $102.60 |
GitHub Team includes $18 of compute, and larger runners may draw on it, so the bill is $102.60 − $18 = $84.60.
What moves that number:
- Rounding. If the 9,000 Linux minutes come from 3,000 jobs that each ran 2 minutes 5 seconds, the real running time is about 6,250 minutes; rounding adds about 2,750 billed minutes, or $16.50.
- macOS. 300 macOS minutes cost $18.60, while 300 Linux 2-core minutes would cost $1.80.
- The plan. On GitHub Enterprise Cloud the same month draws $102.60 from $300 of included compute, so the bill is $0.
Price your own last 30 days
The GitHub Actions cost calculator does this arithmetic on your own jobs, free. Sign in with GitHub and install the Skipbox app on the repositories you choose: it reads their last 30 days of jobs and, for the Linux jobs Skipbox can run, prices the minutes by runner size at GitHub's current rates and breaks them down by repository and workflow. macOS and Windows jobs are left out. Or give it your usage report CSV: your browser reads the file, which is never uploaded, and shows the month's Actions cost by runner SKU. Either way it shows the mix of Skipbox's $39, $79, and $149 monthly plans that runs the same Linux jobs, for one fixed monthly price with unlimited minutes and no usage charges. Signed in, it also lays out a summary for your approval form.
FAQ
Are self-hosted runners free on GitHub Actions?
Yes, today. GitHub lists self-hosted runners as usage that remains free, and it doesn't reduce your included compute. In the usage report, GitHub takes their cost off in discount_amount, so you aren't billed for them.
Does unused included compute roll over to the next month?
No. It resets to the full amount at the start of each billing cycle, which for metered products is 00:00 UTC on the first of the month.
Do failed or cancelled jobs cost money?
Yes, for the minutes they ran. GitHub's example: a workflow that fails after 5 minutes uses 5 minutes, and a successful 10-minute re-run brings the total to 15.
Why does Billing & Licensing show dollars instead of minutes?
Because GitHub now measures included compute as money. The billing dashboard may show Actions usage as spend, which already reflects each runner's rate. The usage report CSV has both: quantity holds the units used, and gross_amount the dollars.
Do public repositories cost anything?
Standard GitHub-hosted runners are free in public repositories. Larger runners are billed there at the same rates as in private repositories.
Sources
All read on 2026-11-09.
- GitHub Docs, Actions runner pricing: per-minute rates by runner and SKU, rounding up per job, larger runners only on Team and Enterprise Cloud.
- GitHub Docs, GitHub Actions billing: included compute and storage by plan, what remains free, storage rates, the re-run example, spend shown in dollars.
- GitHub Docs, Billing reports reference: report types, periods and fields.
- GitHub Docs, Viewing your usage of metered products and licenses: the Usage view and downloading the report.
- GitHub Docs, Viewing job execution time: billable minutes per run.
- GitHub Docs, GitHub-hosted runners:
ubuntu-latestandwindows-latestare 2-core on private repositories. - GitHub Docs, Billing cycles: the metered billing period and when included compute resets.
Updated November 9, 2026