If your GitHub Actions bill is climbing, or your builds queue behind each other, the question is rarely which CI tool?
It is which runner?
GitHub gives you three answers: standard hosted runners, larger hosted runners, and self-hosted runners you run yourself. They differ in price, in who patches the machine, and in what happens when a job misbehaves.
This guide compares them with GitHub's published rates, shows the arithmetic for when each one wins, and covers the question most runner guides skip: how much of your pipeline needs a runner at all.
Pricing below was read from GitHub's own documentation in November 2026. GitHub has changed its Actions pricing recently, including announcing and then postponing a fee on self-hosted runners, so check the billing page before you budget.
The three runner types at a glance
| Standard hosted | Larger hosted | Self-hosted | |
|---|---|---|---|
| Who runs the machine | GitHub | GitHub | You |
| Sizes | 1–2 cores (3–4 on macOS) | 4 to 96 vCPU, plus GPU | Whatever you own |
| Billing | Per minute | Per minute | Free from GitHub; you pay for the server |
| Plans | All | Team and Enterprise Cloud only | All |
| Public repos | Free | Billed | Free |
| Clean machine every job | Yes | Yes | Only if you configure ephemeral runners |
GitHub-hosted runners: what they cost
Standard hosted runners are billed per minute. These are the rates from GitHub's runner pricing reference:
| Runner | Per minute |
|---|---|
| Linux 1-core (slim) | $0.002 |
| Linux 2-core arm64 | $0.005 |
| Linux 2-core x64 | $0.006 |
| Windows 2-core | $0.010 |
| macOS 3- or 4-core | $0.062 |
Two things stand out. First, macOS costs roughly ten times a Linux runner, so a pipeline that builds on macOS just in case
is expensive. Second, the arm64 Linux runner is a sixth cheaper than x64, which is free money if your workload runs on both.
Each plan includes a monthly allowance, and GitHub now states it in dollars, not minutes: $12 on Free, $18 on Pro and Team, and $300 on Enterprise Cloud. At the 2-core Linux rate, that works out to 2,000, 3,000 and 50,000 minutes. Standard hosted runners on public repositories are free and don't draw from the allowance.
Larger runners: paying for speed
Larger runners are hosted machines from 4 to 96 vCPU. They are only available on the Team and Enterprise Cloud plans, they require a payment method, and unlike standard runners they are billed even on public repositories.
| Linux x64 size | Per minute |
|---|---|
| 4-core | $0.012 |
| 8-core | $0.022 |
| 16-core | $0.042 |
| 32-core | $0.082 |
| 64-core | $0.162 |
| 96-core | $0.252 |
The price per core stays roughly flat, so a bigger runner costs more per minute and only saves money if the job finishes faster by at least the same factor. This is simple arithmetic, not a benchmark:
- A job takes 20 minutes on a standard 2-core runner at $0.006 a minute: $0.12.
- On a 4-core runner it costs $0.012 a minute, so it must finish in under 10 minutes to cost less.
- Test suites that parallelise well (split across cores) can clear that bar. Jobs that are mostly waiting on the network or a single-threaded compile usually cannot.
Larger runners earn their place when developer wait time is the real cost, such as a 40-minute build blocking a release. They are a poor fit for jobs that were slow for reasons other than CPU.
Larger runners also unlock features standard runners lack: static IP addresses, custom images and Azure private networking (Linux and Windows only). A static IP is the one that matters for deployments, because it lets you allow-list the runner on a server firewall.
Self-hosted runners: free from GitHub, not free
GitHub does not charge for self-hosted runner minutes. Its docs say self-hosted runners are free to use with GitHub Actions, but you are responsible for the cost of maintaining your runner machines.
That sentence hides the real calculation. You pay for the server, for the time someone spends patching it, and for the incident when it fills its disk at 2 a.m. The break-even is easy to compute:
monthly server cost ÷ $0.006 = hosted Linux minutes you would need to burn to match it
As an illustration, a server costing $20 a month equals about 3,300 hosted minutes. If your team uses fewer than that, hosted runners are cheaper before you count any maintenance time. If you burn tens of thousands of minutes, self-hosting starts to pay, but only if the machine stays busy.
Many teams self-host a runner for a different reason: the deploy target sits behind a firewall and the runner needs to reach it. If that is your only reason, the DeployHQ network agent deploys to servers in private networks without a self-hosted runner, so you can keep CI on hosted runners.
The fee that was announced and then postponed
In December 2025, GitHub announced a $0.002-per-minute platform charge on self-hosted runner usage, due March 1, 2026. GitHub then postponed it to take time to re-evaluate our approach.
At the time of writing, no new date has been published and the docs still describe self-hosted runners as free. That makes it a risk to model, not a cost to ignore: at $0.002 a minute, 30,000 self-hosted minutes would add $60 a month.
Self-hosted runner security
A self-hosted runner executes whatever your workflow tells it to, on a machine that may sit inside your network. GitHub's own guidance is to use autoscaling with ephemeral runners and not to autoscale persistent ones. An ephemeral runner registers, takes one job and is then de-registered:
./config.sh --url https://github.com/your-org --token <REGISTRATION_TOKEN> --ephemeral
GitHub's reasoning is that this limits the exposure of sensitive resources from previous jobs and reduces the risk of a compromised runner receiving new jobs. Ship the logs to external storage, because an ephemeral runner takes its logs with it when it goes away.
Read GitHub's security hardening guidance before attaching a self-hosted runner to a public repository, where pull requests from forks can run arbitrary code on your machine.
How to choose
| Situation | Best fit |
|---|---|
| Small team, a few thousand minutes a month | Standard hosted. The included allowance may cover you. |
| Slow, CPU-bound test suite blocking releases | Larger runner, if the speedup beats the price multiplier |
| Need a static IP to reach a locked-down server | Larger runner, or self-hosted inside your network |
| Heavy, steady CI load, with someone to own the machines | Self-hosted, ephemeral |
| macOS builds | Hosted, and run them only on the jobs that need it |
| Open-source project | Standard hosted. It is free on public repos. |
Does the deploy step need a runner at all?
Most runner cost discussions treat the whole pipeline as one workload. It is two: build and test, which are compute-heavy and benefit from a good runner, and deploy, which is mostly waiting on file transfers and server commands.
When the deploy step runs on a runner, you pay runner minutes for it. You also give that runner SSH access to your servers, and you inherit the failure modes of scripting deployments inside CI. We covered those in why SSH-based deploy actions break for real deployments.
The alternative is to let CI do what it is good at and hand the deploy to a dedicated tool with automatic deployments. That is how we run our own site: the pipeline builds and tests on GitHub Actions, then triggers DeployHQ for the release. The full setup is in how we deploy DeployHQ.com with GitHub Actions and Docker.
To wire it up yourself, the DeployHQ GitHub Action setup guide covers the workflow step. On other CI systems, see using the DeployHQ CLI in CI/CD pipelines. If you already script deploys inside Actions, migrating from GitHub Actions to DeployHQ walks through the move.
A deploy that takes 90 seconds of server time no longer holds a runner, and the runner no longer needs credentials for your production servers. If you are comparing the two approaches directly, see DeployHQ vs GitHub Actions.
Try it: sign up for DeployHQ and trigger your first deploy from a green GitHub Actions run.
A practical way to cut your runner bill
- Find where the minutes go. GitHub's billing and usage pages break Actions usage down so you can see which workflows spend the most. Most bills have one or two workflows doing most of the spending.
- Move work to cheaper runners first. arm64 Linux if your build supports it, the 1-core slim runner for lint and housekeeping jobs.
- Stop running macOS and Windows jobs by default. Gate them to the branches and paths that need them.
- Cache dependencies and build outputs. Cutting a 6-minute install to 1 minute saves more than any runner change. If you use DeployHQ's own build step, build caching does the same there, and our guide to what a build pipeline is and where time goes walks through the stages.
- Only then consider a bigger or self-hosted runner. Both add cost or work, so they should fix a measured problem.
For a wider look at the tools around your runners, see GitHub Actions vs GitLab CI vs Bitbucket Pipelines, the best CI/CD tools compared, our practical guide to building a CI/CD pipeline and the GitHub Actions cheatsheet for quick syntax reference.
Questions about moving your deploy step out of CI? Email support@deployhq.com or reach us on X at @deployhq.