How use of GitHub Actions is measured
Your GitHub plan includes a monthly amount of included compute usage. Each product measures usage in its own units and applies its own rate. GitHub calculates the cost of that usage, which counts against the included compute usage. After the included amount is consumed, additional usage is billed to your account. The included amount resets at the start of each billing cycle.
The following usage can draw from the same included compute usage:
- Standard GitHub-hosted runners for private or internal repositories, and cloud sandbox compute and memory, on all plans.
- Larger runners, where available, when the billing account uses GitHub Team or GitHub Enterprise Cloud.
No eligible usage type has priority over another when drawing from the shared included compute usage.
The following usage remains free independently and does not reduce the included compute usage:
- Standard GitHub-hosted runners in public repositories. See Choosing the runner for a job.
- Self-hosted runners.
Larger runners are billed for public repositories.
For private repositories, usage is measured against two parts of your plan:
- Compute: The calculated cost of eligible runner usage draws from your monthly included compute usage. This value is also available for cloud sandbox compute and memory. Usage is charged to the repository owner, not the person who triggered the workflow runs.
- Storage: Artifact and cache storage have separate allowances. Storage charges accumulate throughout the month based on hourly usage, and your accrued storage charges reset to zero at the start of each billing cycle.
Tip
Anyone with write access to a repository can run actions. Any costs of running the actions are billed to the repository owner.
Copilot code review and GitHub Actions usage
Each Copilot code review consumes GitHub Actions compute in addition to AI credits.
- Private repositories: The runner cost draws from your account or organization's included compute usage. Additional usage is billed at standard GitHub Actions rates.
- Public repositories: This usage remains free.
Copilot code review runs on standard GitHub-hosted Ubuntu Linux runners by default. You can also configure GitHub-hosted larger runners or self-hosted runners via Actions Runner Controller (ARC), which are billed at different rates.
How storage billing works
GitHub Actions storage billing operates on an hourly accrual model:
- Continuous billing: Storage charges accrue every hour based on your actual usage throughout the month
- Monthly total: Your bill reflects the total storage used throughout the month, measured in GB-Hours
- Included amount: The free storage allowance for your plan (for example, 50 GB on the Enterprise plan) is converted to an hourly rate for billing calculations
- Shared storage: Actions artifacts and GitHub Packages storage share the same pooled allowance. See GitHub Packages billing.
- Cache storage: Actions cache storage is a separate allowance of 10 GB per repository. Cache storage is not shared with artifacts or GitHub Packages.
- Custom image storage: Storage for custom images used with GitHub-hosted larger runners has its own included allowance based on your plan.
Understanding current vs. accrued storage
It's important to understand the difference between what you see on GitHub and what appears on your bill:
- Current storage: The amount of storage you have right now
- Accrued storage: The cumulative total of storage used throughout the billing cycle (determines your bill)
When you delete artifacts:
- Current storage decreases immediately
- Future hourly charges stop accumulating
- Storage already accrued during the current billing cycle remains in your total and will appear on your bill
Example (30-day billing cycle): If you store 10 GB of artifacts for 10 days, then delete everything on day 11:
- Days 1-10: Accruing 240 GB-Hours per day (10 GB × 24 hours)
- Day 11: Delete artifacts → current storage drops to 0 GB
- Days 11-30: Accruing 0 GB-Hours (no storage)
- Your bill: Shows 2,400 GB-Hours total (10 days × 240 GB-Hours/day)
Deleting artifacts reduces your current storage and prevents future charges, but does not remove charges already recorded for the time the storage existed.
Storage measurement units
GitHub Actions measures storage in binary gigabytes (GB), where:
- 1 GB = 2^30 bytes = 1,073,741,824 bytes
- This is also known as a gibibyte (GiB)
- 1 GB = 1,024 megabytes (MB)
Billing calculations use GB-Hours:
- 1 GB-Hour = 1 GB of storage for 1 hour
- Example: Storing 3 GB for 10 days = 720 GB-Hours (3 GB × 10 days × 24 hours)
Your monthly bill converts GB-Hours to GB-Months by dividing by the hours in the month (usually 720 hours for a 30-day month).
Custom image storage
For GitHub-hosted larger runners, storage for custom images is billed through GitHub Actions storage.
Custom image storage uses the same hourly accrual model as other GitHub Actions storage. Your bill is based on the amount of image data that is stored over time, measured in GB-Hours.
Storage usage for custom images depends on:
- The size of each image version
- The number of image versions that you retain
- How long each version is stored
Each successful workflow job that includes the snapshot keyword creates a new custom image version. Each retained version contributes to your storage usage until the version is deleted or removed by a retention policy. For more information, see Using custom images and Enforcing policies for GitHub Actions in your enterprise.
Custom image storage is based on retained image data over time, not on the number of times that a runner uses or pulls an existing image.
For example:
- Storing one 150 GB custom image version for 24 hours uses 3,600 GB-Hours.
- Storing four 150 GB versions of the same image for 24 hours uses 14,400 GB-Hours.
Examples of how usage is measured
- If you run a workflow on a standard Linux runner and it takes 10 minutes to complete, $0.06 USD is deducted from the repository owner's included compute usage (10 × $0.006 USD). If the workflow generates a 10 MB artifact, then you'll also use 10 MB of the repository owner's artifact storage allowance.
- If you run a workflow that normally takes 10 minutes and it fails after 5 minutes because a dependency isn't available, the cost of 5 minutes is deducted from the included compute usage. If you fix the problem and re-run the workflow successfully, the total cost is based on 15 minutes.
- If you run a workflow that generates many log files and a long job summary, these files do not count towards the repository owner's artifact storage allowance.
- Cache storage usage is measured by the peak usage for each hour. The included allowance is 10 GB per repository. For a given hour, if a repository has a peak cache usage of 15 GB, then the repository owner will be charged for the 5 GB of usage above the 10 GB included for that repository. The repository owner will only be charged if the repository cache storage limit has been configured higher than the included usage.
Included compute usage and storage
The following included compute usage and storage amounts are included in your GitHub plan. The included compute usage resets at the start of each billing cycle.
| Plan | Artifact storage | Included compute usage (per month) | Cache storage (per repository) | Custom image storage |
|---|---|---|---|---|
| GitHub Free | 500 MB | $12 USD | 10 GB | Not applicable |
| GitHub Pro | 1 GB | $18 USD | 10 GB | Not applicable |
| GitHub Free for organizations | 500 MB | $12 USD | 10 GB | Not applicable |
| GitHub Team | 2 GB | $18 USD | 10 GB | 75 GB |
| GitHub Enterprise Cloud | 50 GB | $300 USD | 10 GB | 150 GB |
The included compute usage is expressed as a monetary amount, not a fixed number of minutes or other usage units. Products measure usage in different units, such as minutes, seconds, or GiB-seconds, and apply the corresponding rate. GitHub deducts the calculated cost from the same included compute usage. As a guide, $300 USD covers 50,000 minutes on a standard Linux runner at $0.006 USD per minute.
The use of standard GitHub-hosted runners is free:
- In public repositories
- For GitHub Pages
- For Dependabot
Note
- Where larger runners are available, their cost can draw from the included compute usage for billing accounts on GitHub Team and GitHub Enterprise Cloud. Larger runners are billed for public repositories.
- The artifact storage amounts shown are shared with GitHub Packages. This means your total storage across Actions artifacts and GitHub Packages storage cannot exceed the included amount for your plan. Cache storage and custom image storage are separate allowances.
- Copilot code review runner costs draw from the included compute usage on private repositories. For public repositories, this usage remains free.
Using more than your included compute usage
If your account does not have a valid payment method on file, usage is blocked once you consume the included compute usage. Larger runners require a valid payment method.
Paying for additional GitHub Actions use
You pay for additional use after the included compute usage is consumed using the payment method set up for your GitHub account. See Managing your payment and billing information.
For GitHub-hosted runners, storage is billed based on hourly usage of artifacts and caches throughout the month. Compute is billed based on the total processing time used by each runner type during the month.
- To estimate costs for paid usage, use the GitHub pricing calculator.
- To view your current costs, see Viewing your usage of metered products and licenses.
Note
The billing dashboard may show your Actions usage as a dollar amount ("spend") rather than raw minutes. This amount already reflects any applicable compute costs.
Baseline minute costs
Each type of runner hosted by GitHub has a per-minute rate that is determined by the operating system and processing power. The rate determines the cost deducted from the included compute usage.
For example, jobs that run on Windows and macOS runners hosted by GitHub cost more to run than jobs on Linux runners.
| Operating system | Billing SKU | Per-minute rate (USD) |
|---|---|---|
| Linux 1-core (x64) | actions_linux_ | $0.002 |
| Linux 2-core (x64) | actions_linux | $0.006 |
| Linux 2-core (arm64) | actions_linux_arm | $0.005 |
| Windows 2-core (x64) | actions_windows | $0.010 |
| Windows 2-core (arm64) | actions_windows_ | $0.010 |
| macOS 3-core or 4-core (M1 or Intel) | actions_macos | $0.062 |
For full details of minute costs for different types of runners, see Actions runner pricing.
Storage pricing
Usage beyond your included allowances is billed at the following rates:
| Storage type | Price per GB/month |
|---|---|
| Shared storage (artifacts and GitHub Packages) | $0.25 USD |
| Actions cache | $0.07 USD |
| Custom image storage | $0.07 USD |
Example additional runner cost calculation
For example, if your organization uses GitHub Team, 5,000 minutes after the included compute usage is consumed would cost $38 USD if you used baseline Linux and Windows runners.
- 5,000 (3,000 Linux and 2,000 Windows) minutes = $38 USD ($18 USD + $20 USD).
- 3,000 Linux minutes at $0.006 USD per minute = $18 USD.
- 2,000 Windows minutes at $0.010 USD per minute = $20 USD.
Example artifact storage cost calculation
If you use 3 GB of artifact storage for 10 days of March and 12 GB for 21 days of March, your artifact storage usage would be:
- 3 GB x 10 days x (24 hours per day) = 720 GB-Hours
- 12 GB x 21 days x (24 hours per day) = 6,048 GB-Hours
- 720 GB-Hours + 6,048 GB-Hours = 6,768 GB-Hours
- 6,768 GB-Hours / (744 hours per month) = 9.0967 GB-Months
At the end of the month, GitHub rounds your artifact storage to the nearest MB. Therefore, your artifact storage usage for March would be 9.097 GB.
Note
GitHub updates your artifact storage usage within 6 to 12 hours. Deleting artifacts frees up space for current storage, but does not reduce your accrued storage usage, which is used to calculate your storage billing for the current billing cycle.
Example cache storage cost calculation
If you use 3 GB of cache storage for 10 days of March and 12 GB for 21 days of March, your cache storage usage would be:
| Usage (GBs) | Billable (GB-Hours) | Non billable (GB-Hours) |
|---|---|---|
| 3 GB for the first 10 days | 0 GB-Hours | 720 GB-Hours |
| 12 GB for the next 21 days | 2*21 days*24 hours = 1008 GB-Hours | 10*21 days*24 hours=5040 GB-Hours |
For cached storage, billing charts and reports show only the cost of usage beyond the included 10 GB. At the end of the month, the Actions Cache Storage SKU would show a use of 1008 GB-Hours.
Managing your budget for GitHub Actions
If your account does not have a valid payment method on file, usage is blocked once you use up your quota.
If you have a valid payment method on file, spending may be limited by one or more budgets. Check the budgets set for your account to ensure they are appropriate for your usage needs. See Setting up budgets to control spending on metered products.
You can also receive email notifications when your included GitHub Actions usage reaches 90% and 100% during a billing period. For more information, see Budgets and alerts.