# How many GitHub Actions minutes does a team of 20 developers use a month?

GitHub publishes no average. A five-factor formula and three worked scenarios for 20 developers, a script for your usage report, and calculator presets by size.

By Grant Unwin, published 2026-11-06. Checked against GitHub's documentation on 2026-11-17. The web page: https://www.runners.io/blog/how-many-github-actions-minutes-does-a-team-use

There is no published average, so any single figure is a guess. Multiply five things you can count: developers, pull requests each, runs per pull request, billed minutes per run and the re-run rate. For 20 developers, three sets of assumptions give about 4,600, 47,800 and 351,000 billed minutes a month, or $27 to $2,106 on a standard Linux runner at $0.006 a minute. Our [GitHub Actions cost](https://www.runners.io/blog/github-actions-pricing-2026) guide has the rates.

**In short**

- GitHub publishes no minutes per developer; its billing documentation gives a dollar allowance for each plan.
- Billed minutes are developers, pull requests each, runs per pull request, billed minutes per run and one plus the re-run rate, multiplied.
- For 20 developers, three sets of assumptions give about 4,600, 47,800 and 351,000 billed minutes a month.
- At $0.006 a minute that is $27, $287 and $2,106 before included usage; GitHub Team includes $18.
- Measure your own from the detailed usage report and sort by gross cost, not by minutes.

## How do I estimate a team’s monthly minutes?

Billed minutes a month are the product of five numbers. We found no figure from GitHub for minutes per developer: its billing documentation gives a dollar allowance for each plan, not a typical use.

```text
billed minutes a month
  = developers
  x pull requests each a week
  x 52 / 12 weeks a month
  x (runs per pull request + 1)     the +1 is the run on the main branch after a merge
  x billed minutes per run          every job rounded up to a whole minute, matrix legs added
  x (1 + re-run rate)               a re-run bills what it runs again
```

Two of the five come from how GitHub bills. A job is rounded up to a whole minute on its own, so a run of ten short jobs bills at least ten minutes. And a re-run bills again: in GitHub’s example a workflow that takes 10 minutes and fails after 5 is re-run, and the total is based on 15 minutes. That is why a re-run rate is a factor, and why billed minutes run above the stopwatch.

## What do three sets of assumptions give for 20 developers?

These are assumptions, chosen to span a lean pipeline to a heavy one, and not a measurement of any team, ours included. The month is 52 divided by 12 weeks. The cost column is the billed minutes times GitHub’s 2-core Linux rate of $0.006 a minute, before a plan’s included usage. Jobs on Windows, macOS or larger runners cost more a minute.

| Assumption | Lean | Typical | Heavy |
| --- | ---: | ---: | ---: |
| Pull requests each a week | 2 | 4 | 6 |
| Runs per pull request, plus one on main | 3 + 1 | 5 + 1 | 8 + 1 |
| Billed minutes per run | 6 | 20 | 60 |
| Re-run rate | 10% | 15% | 25% |
| Pull requests a month | 173 | 347 | 520 |
| Runs a month | 693 | 2,080 | 4,680 |
| Billed minutes a month | 4,576 | 47,840 | 351,000 |
| At the 2-core Linux rate | $27.456 | $287.04 | $2106.00 |

The lean team runs a single six-minute job and re-runs one run in ten. The typical team has three jobs of about three, ten and seven minutes. The heavy team runs a test matrix, so one run bills sixty minutes across its legs and one in four runs is repeated. Move any one factor and the month moves in proportion: doubling the matrix legs doubles the minutes, and halving the runs per pull request halves them.

Even the lean team goes past what a plan includes. GitHub Team includes $18 a month of compute, which is 3,000 Linux 2-core minutes, so the lean team uses about one and a half times that and the typical team about sixteen times. The included amount is a dollar figure drawn down at each runner’s rate, so a workflow on Windows or macOS spends it faster. The [macOS and Windows post](https://www.runners.io/blog/why-github-actions-macos-and-windows-minutes-cost-more) gives the rates and the minutes each plan buys.

## How do I measure our own minutes?

Do not estimate what you can read. From Billing & licensing, open the metered usage page and choose “Get usage report”: GitHub emails a link to the detailed report, which covers up to 31 days and carries `repository`, `workflow_path`, `sku`, `quantity` and the amounts. The [pricing post](https://www.runners.io/blog/github-actions-pricing-2026) has the steps. This script sums it by repository, workflow and SKU, and sorts by cost, because the workflow that bills the most is often not the one that uses the most minutes. Our per-minute rate for every size, beside GitHub’s, is on the [GitHub Actions runner pricing](https://www.runners.io/pricing) page.

```text
import csv, sys
from collections import defaultdict

minutes = defaultdict(float)
gross = defaultdict(float)
with open(sys.argv[1], newline="") as f:
    for row in csv.DictReader(f):
        if row["product"].lower() != "actions":
            continue
        key = (row["repository"], row["workflow_path"], row["sku"])
        minutes[key] += float(row["quantity"])
        gross[key] += float(row["gross_amount"])

total = sum(minutes.values())
for key in sorted(minutes, key=lambda k: -gross[k]):
    repo, path, sku = key
    print(f"{repo:<14} {path:<28} {sku:<14} {minutes[key]:>8.0f} {gross[key]:>8.2f} {minutes[key]/total:>6.0%}")
print(f"total minutes: {total:.0f}")
```

We ran it on a file of three made-up rows in GitHub’s column layout, to check the commands and not to report a result. GitHub documents the column names but not example values, so check that your file’s `product` column reads actions, as the script assumes. It printed the macOS workflow at 9 per cent of the minutes and half the gross cost, which is the pattern to look for in yours. Sort by gross, not by minutes. GitHub’s own [pricing calculator](https://github.com/pricing/calculator) estimates a month from your inputs, and the [calculator](https://www.runners.io/calculator) here prices a month of minutes, with sizes for [10,000](https://www.runners.io/calculator/10000-minutes), [25,000](https://www.runners.io/calculator/25000-minutes), [50,000](https://www.runners.io/calculator/50000-minutes) and [100,000](https://www.runners.io/calculator/100000-minutes) minutes.

## Which factor changes the number most?

The matrix and the run count, because both multiply. A pull request that pushes five times and runs a five-leg matrix on every push bills twenty-five job runs before a single re-run. The cheapest changes are the ones that remove runs without removing coverage: cancel a superseded run, skip documentation-only changes, and set a timeout. The [post on running less](https://www.runners.io/blog/speed-up-github-actions-by-running-less) has the workflow, and the [pricing post](https://www.runners.io/blog/github-actions-pricing-2026) ranks the places a bill leaks.

## Sources

- [Actions runner pricing](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [GitHub Actions billing](https://docs.github.com/en/billing/concepts/product-billing/github-actions)
- [Billing reports reference](https://docs.github.com/en/billing/reference/billing-reports)
- [Viewing your usage of metered products and licenses](https://docs.github.com/en/billing/how-tos/products/view-productlicense-use)

## Frequently asked questions

### How many GitHub Actions minutes does a team of 20 developers use a month?

GitHub publishes no average. Multiply developers, pull requests each, runs per pull request, billed minutes per run and the re-run rate. Our assumptions for 20 developers give about 4,600 minutes for a lean pipeline, 47,800 for a typical one and 351,000 for a heavy one.

### How do I work out minutes per developer?

Divide your billed minutes by your active developers, using the detailed usage report summed by repository and workflow. Billed minutes run above wall-clock time because each job rounds up to a whole minute and a re-run bills what it runs again.

### What does 50,000 minutes cost on GitHub Actions?

At $0.006 for a 2-core Linux minute it is $300 before included usage, which is what GitHub's own guide says $300 covers. Windows and macOS minutes cost more, so the same count on them bills more.

### Which factor changes the monthly minutes most?

The matrix size and the runs per pull request, because they multiply. Doubling the matrix legs doubles the minutes. Cancelling superseded runs, skipping documentation-only changes and setting timeouts remove runs without removing coverage.
