GitHub Actions minutes cost: when do smaller runners, caching, or self-hosted runners pay off?

GitHub Actions bills GitHub-hosted runner time per minute, rounded up to the whole minute for each job, at a rate set by the runner's operating system and core count, not by how much CPU your job uses. Larger runners cost more per minute and never draw from your plan's included minutes, per GitHub's Actions runner pricing page (https://docs.github.com/en/billing/reference/actions-runner-pricing, checked November 2026). Right-size runners, cache downloads and cancel stale runs first; self-hosted runners pay off only when your hosted bill for the workflows you'd move beats their compute plus upkeep.

Why is my GitHub Actions bill so high?

GitHub bills the full rounded-up minute whether your job saturates every core or sits idle waiting on a download. Larger-runner rates scale with core count, so a 16-core runner that spends most of a job on a single-threaded test suite costs several times what a 2-core runner would for the same work. Rounding adds up too: every job in a matrix bills at least one full minute, even if it finishes in seconds.

How do I find my GitHub Actions usage?

In GitHub, open your organization's Settings → Billing and licensing → Usage, filter to Actions, and download the usage report CSV. Each row carries a sku (for example actions_linux; larger runners and other operating systems have their own SKUs), a quantity in minutes, the cost, and the repository and workflow_path that ran it. Group by workflow to find the handful of files that drive the bill:

-- DuckDB. Run DESCRIBE SELECT * FROM 'usage_report.csv' first; header names vary slightly by report version.
SELECT repository, workflow_path, sku,
       SUM(quantity)     AS minutes,
       SUM(gross_amount) AS gross_cost
FROM read_csv_auto('usage_report.csv')
WHERE lower(product) = 'actions'
GROUP BY ALL
ORDER BY gross_cost DESC
LIMIT 20;

If you already run self-hosted runners on AWS, tag their instances and EBS volumes (for example workload=ci-runner) and activate the tag under Billing and Cost Management → Cost allocation tags. On EKS, set the tags in the node group's launch template; tags on the managed node group itself don't reach its EC2 instances. Cost Explorer only shows tagged cost for usage after the tag was applied, so tag the runners now. Then pull the runners' cost by usage type:

aws ce get-cost-and-usage \
  --time-period Start=2026-10-01,End=2026-11-01 \
  --granularity MONTHLY \
  --metrics UnblendedCost \
  --filter '{"Tags": {"Key": "workload", "Values": ["ci-runner"]}}' \
  --group-by Type=DIMENSION,Key=USAGE_TYPE

Check your own bill in 2 minutes: https://revelations.consulting/checker?utm_source=blog&utm_medium=organic&utm_content=blog-github-actions-minutes-cost

How do I cut GitHub Actions costs without breaking anything?

Start with runner size: runs-on: ubuntu-latest is the standard GitHub-hosted runner, billed at the base Linux rate. Larger Linux and Windows runners only run when a job names a custom label an org admin created under Settings → Actions → Runners, while larger macOS runners use predefined labels ending in -large or -xlarge, such as macos-latest-large and macos-latest-xlarge. List every runs-on value in your workflows that isn't a standard label, and check whether those jobs use the cores they pay for. Wrap the real build or test command, not the whole job:

- name: Test with CPU accounting
  run: |
    echo "cores: $(nproc)"
    status=0
    /usr/bin/time -v -o time.txt npm test || status=$?
    grep -E "Percent of CPU|Elapsed" time.txt
    exit $status

Percent of CPU is the command's average CPU use over the run, summed across cores: divide it by 100 to get the average number of cores it kept busy. A 16-core job that reports a few hundred percent averages a few busy cores and pays for 16.

Run the same job on the next size down and compare billed minutes times the rate. Because larger-runner rates scale with cores, the bigger runner only wins if it cuts wall-clock time at least as much as it raises the rate.

Test the smaller size on a branch before switching. Memory shrinks with cores, so memory-hungry builds can start failing with out-of-memory errors.

Next, cache what every run downloads. Use actions/cache for package caches such as ~/.m2/repository, ~/.cache/pip or ~/.gradle/caches, keyed on the lockfile, with a restore-keys fallback so a changed lockfile still gets a partial hit. Cache the package manager's download cache rather than node_modules, which can break across Node versions and operating systems:

- uses: actions/cache@v4
  with:
    path: ~/.m2/repository
    key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
    restore-keys: |
      ${{ runner.os }}-m2-

The setup-* actions do this with one input: cache: npm on actions/setup-node, cache: pip on actions/setup-python, cache: maven or cache: gradle on actions/setup-java. Check the job log for a cache hit and compare step times before and after. A cache that takes longer to restore than the install it replaces costs minutes, and caches over the repository's storage limit get evicted.

Then stop paying for runs nobody will read. A concurrency group with cancel-in-progress cancels the older run on the same branch when a new commit lands:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref == 'refs/heads/main' && github.sha || github.ref }}
  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

Include github.workflow so one workflow doesn't cancel another on the same branch. On main the group uses the commit SHA, because a shared group keeps only one pending run and drops older queued commits untested.

Give deploy workflows their own group, such as deploy-production, with cancel-in-progress: false: cancelling a deploy mid-run can leave an environment half-updated.

Add timeout-minutes to long jobs so a hung test stops billing, and paths filters so a docs change doesn't run the full suite. Don't add paths to a workflow that is a required status check: a workflow skipped by paths leaves the check pending and blocks the merge.

Self-hosted runners come last. You don't pay hosted-runner rates for them, but you pay for the compute. Check GitHub's billing page for any per-minute platform charge on self-hosted usage before you model savings. On Kubernetes, actions-runner-controller (ARC) runner scale sets start a fresh runner pod per job and can scale to zero:

helm install arc \
  --namespace arc-systems --create-namespace \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set-controller

helm install arc-runner-set \
  --namespace arc-runners --create-namespace \
  --set githubConfigUrl="https://github.com/your-org" \
  --set githubConfigSecret=arc-github-app \
  --set minRunners=0 --set maxRunners=20 \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set

Before the second install, create the arc-runners namespace and a Kubernetes secret named arc-github-app in it with your GitHub App credentials. Workflows then target the scale set with runs-on: arc-runner-set. Spot nodes cut compute cost, but an interruption kills the job mid-run, so keep deploy jobs on on-demand capacity.

To find break-even, take last month's hosted cost for the workflows you'd move. Compare it with the cost of running them yourself: the tagged instance, EBS and data transfer cost from the query above, plus NAT, plus any GitHub charge for self-hosted minutes, plus engineer hours for runner image updates, ARC and Kubernetes upgrades, autoscaling tuning and CI outages, times your loaded hourly rate. Self-hosted pays off when the first number clearly beats the second at your real job volume.

The tag filter misses NAT. NAT gateway charges (usage types ending in NatGateway-Hours and NatGateway-Bytes) are billed to the NAT gateway and carry its tags, not the runners'. Give the runner subnets their own NAT gateway tagged workload=ci-runner, or estimate the runners' share of a shared gateway from VPC Flow Logs bytes leaving the runner subnets.

The biggest risk: a self-hosted runner executes whatever code the workflow checks out. On a public repository, any fork pull request can run code on your runner, read secrets on the host and reach its network. GitHub recommends self-hosted runners only for private repositories.

Make runners ephemeral: pass --ephemeral to config.sh, or use ARC scale sets, which are ephemeral by default. Put them in a runner group limited to selected private repositories, with "Allow public repositories" left unchecked; labels route jobs but don't restrict access.

Require IMDSv2 with a metadata hop limit of 1 in the runner nodes' launch template, so job pods can't fetch the node's IAM credentials. Test on one node group first: add-ons that get AWS credentials from node metadata fail until you move them to IRSA or EKS Pod Identity.

What it usually looks like

Check your usage report and workflow files for these patterns this week:

  1. A few workflows account for most of the minutes: often a full test suite that runs on every push to every branch, or a larger-runner label that someone added once and every job copied.
  2. Install steps take a large share of job time because there is no cache: input on the setup-* action, or the cache key changes on every run.
  3. Self-hosted runners were added without cost allocation tags, so nobody can say whether they cost less than the hosted minutes they replaced.

At a former employer I cut a roughly $1M-a-year cloud bill by 26%. For CI, measure first, fix the largest workflows, and change one lever at a time so you can see what each one saved.

Book a free 30-minute consult about your cloud and AI spending: https://revelations.consulting/?utm_source=blog&utm_medium=organic&utm_content=blog-github-actions-minutes-cost#contact

Run your own numbers: CI Runner Cost Calculator.

Frequently asked questions

How much does a GitHub Actions runner cost per minute?

GitHub Actions bills GitHub-hosted runner time per minute, rounded up per job, at a rate set by operating system and core count: Linux is cheapest, then Windows, then macOS. Standard runners are free on public repositories and use your plan's included minutes on private ones; larger runners never use included minutes. Current rates are on GitHub's Actions runner pricing page (https://docs.github.com/en/billing/reference/actions-runner-pricing, checked November 2026).

Does caching reduce my GitHub Actions minutes?

Caching reduces GitHub Actions minutes when dependency installs take a meaningful share of job time. Compare the install step's duration, plus the cache restore step, in your job logs before and after enabling actions/cache or a setup-* action's cache: input. The difference times runs per month is the minutes saved, and minutes saved times the runner's per-minute rate is the dollar saving.

What’s the break-even point for self-hosted runners?

Self-hosted GitHub Actions runners pay off when the hosted-runner cost of the workflows you'd move exceeds the cost of running them yourself: instances, EBS, data transfer, NAT gateway charges, any GitHub charge for self-hosted minutes, and the engineer hours to maintain them. Compare GitHub's usage report with the runners' tagged cost in AWS Cost Explorer, plus NAT gateway cost, which carries the gateway's tags rather than the runners'; no universal minute threshold exists.

Run the numbers on your own bill: What do your CI runners cost?. Free, in your browser.

Want this kind of thing weekly? Get Cloud Bill Weekly. Want us to find it in your bill? We're taking three founding clients for a free Cost Assessment.