GitHub Actions Runners: What Faster Costs

Changing the runs-on: line in a workflow is a one-character-deep edit, which is why a whole product category now exists to sell you a different value for it. The pitch never varies: same YAML, faster hardware, smaller invoice.

Developers used 11.5 billion GitHub Actions minutes running tests in 2025, a 35 percent increase year over year, according to GitHub's Octoverse report published November 7, 2025. At GitHub's published Linux 2-core rate of $0.006 per minute, that volume is worth roughly $69 million a year in runner minutes across the platform.

What GitHub Actually Charges

GitHub's flat per-minute rates are the baseline every vendor below quotes against. As of September 29, 2026, GitHub's billing documentation lists Linux 1-core at $0.002 per minute, Linux 2-core at $0.006, arm64 2-core at $0.005, Windows 2-core at $0.010 and macOS at $0.062.

Included minutes track the plan: 2,000 a month on Free, 3,000 on Team, 50,000 on Enterprise Cloud. Self-hosted runners carry no per-minute charge, which is why the self-hosted options below undercut everyone.

The rate is identical whether a job takes four minutes or forty, so slow hardware bills you twice: once in minutes, once in waiting.

Pricing One Month Across Five Runners

This prices 100,000 Linux minutes a month on 2 vCPU using each vendor's published rate. The second column applies their own speed claim, since a runner twice as fast bills half the minutes.

js
Copy
// ci-price.mjs - node ci-price.mjs
const MINUTES = 100_000

const runners = [
  { name: 'GitHub 2-core',      rate: 0.006,  speedup: 1, base: 0,  free: 3_000 },
  { name: 'Depot 2 vCPU',       rate: 0.006,  speedup: 1, base: 20, free: 2_000 },
  { name: 'Blacksmith x64',     rate: 0.004,  speedup: 2, base: 0,  free: 3_000 },
  { name: 'Blacksmith ARM',     rate: 0.0025, speedup: 2, base: 0,  free: 3_000 },
  { name: 'Ubicloud Premium',   rate: 0.002,  speedup: 2, base: 0,  free: 1_250 },
  { name: 'Ubicloud Standard',  rate: 0.0012, speedup: 1, base: 0,  free: 1_250 },
]

const usd = (n) => '$' + n.toLocaleString('en-US', { maximumFractionDigits: 0 })
const cost = (r, fast) =>
  Math.max(0, MINUTES / (fast ? r.speedup : 1) - r.free) * r.rate + r.base

const base = cost(runners[0], false)
const pct = (v) => (v === base ? 'baseline' : `${(((v / base) - 1) * 100).toFixed(0)}%`)

console.log('runner               same minutes       at vendor speed claim')
console.log('-'.repeat(64))
for (const r of runners) {
  const flat = cost(r, false)
  const fast = cost(r, true)
  console.log(
    r.name.padEnd(20) +
      (usd(flat) + '/mo').padStart(9) + '  ' + pct(flat).padStart(8) + '    ' +
      (r.speedup > 1 ? (usd(fast) + '/mo').padStart(9) + '  ' + pct(fast).padStart(8) : '       -'),
  )
}

Real output:

text
Copy
runner               same minutes       at vendor speed claim
----------------------------------------------------------------
GitHub 2-core         $582/mo  baseline           -
Depot 2 vCPU          $608/mo        4%           -
Blacksmith x64        $388/mo      -33%      $188/mo      -68%
Blacksmith ARM        $243/mo      -58%      $118/mo      -80%
Ubicloud Premium      $198/mo      -66%       $98/mo      -83%
Ubicloud Standard     $118/mo      -80%           -

The most useful number there is the one that goes the wrong way. Depot's 2 vCPU runner costs exactly what GitHub's does, $0.006 a minute, so a straight swap still costs 4 percent more once the $20 plan fee lands, even after its 2,000 included minutes.

Blacksmith

Blacksmith is the most direct expression of the category: keep the workflow, change one line, get faster hardware for less money.

Its pricing page lists Ubuntu x64 at $0.004 per minute and Ubuntu ARM at $0.0025, both with 3,000 free minutes a month, across 2 to 32 vCPU on Ubuntu and Windows, 6 to 12 vCPU on macOS. Blacksmith claims 2x faster hardware and 33 percent lower per-minute cost, which is what the arithmetic above reproduces. Add-ons cost extra: Docker layer caching and sticky disks at $0.50 per GB per month, static IPs at $100 each. Maintained open source projects can apply to a free OSS program, separate from the Startup Program discount for companies under $50 million raised.

The homepage claims 60 percent lower cost while the pricing page's 33 percent plus 2x speed compounds to 67 percent, so price it on the per-minute rate you are billed. Pricing: 3,000 free minutes/month · $0.004/min x64 · $0.0025/min ARM.

Ubicloud

Ubicloud is the cheapest managed runner in this comparison and the only one whose control plane is itself open source, licensed AGPL v3 with about 12,300 GitHub stars.

Its published 2 vCPU rates are $0.0012 per minute on Standard and $0.0020 on Premium, against the $0.0060 GitHub charges for the same shape. That is 5x on Standard before any speed claim. Accounts get 1,250 free minutes a month, and the ladder runs to 16 vCPU at $0.0100. As of September 29, 2026 the page's headline cards say $0.0010 and $0.0016 while its per-shape table still lists $0.0012 and $0.0020; this guide prices from the table.

What you give up is polish, and the fine print: Standard is cheap because it is not the fast tier, so the "twice as fast" claim belongs to Premium at $0.0020, not the headline $0.0012. Pricing: 1,250 free minutes/month · $0.0012/min Standard · $0.0020/min Premium. AGPL v3.

Namespace

Namespace sells a development platform rather than a runner alone: managed GitHub runners, Docker builds, devboxes and Bazel remote caching.

Pricing is subscription-shaped rather than metered. Developer is free and pay-per-use, Team is $100 a month including 100,000 unit minutes and 1,000 Docker builds, Business is $250 including 250,000 unit minutes and 2,500 builds. Linux concurrency runs 32 to 64 to 160 vCPU across those tiers, macOS 12 to 48, and Bazel cache storage is $0.20 per GB-month.

Namespace meters unit minutes rather than wall-clock runner minutes, so it cannot join the table above without their calculator. Pricing: Free Developer tier · Team $100/month · Business $250/month.

Depot

Depot is the odd one out.

Depot bills per second: $0.0001 for 2 vCPU and 8 GB, the same $0.006 a minute GitHub charges, doubling to $0.0002 at 4 vCPU and reaching $0.0032 at 64 vCPU. Plans start at $20 a month including 2,000 GitHub Actions minutes and 25 GB of cache and registry storage, rising to $200 with 20,000 minutes and 250 GB, and extra cache is $0.20 per GB per month. Windows and macOS M2 runners are available.

The product is the cache: remote Docker layer caching, a shared build cache and sccache support, which attack the minutes rather than the price per minute. Pricing: $20/month Developer plan · $0.006/min for 2 vCPU · $0.20/GB/month cache.

RunsOn, actions-runner-controller and Zoomies

RunsOn inverts the model: instead of renting runners, it launches ephemeral EC2 instances in your own AWS account, one per job, gone when the job ends.

Because AWS bills you directly at spot prices with no markup, its published comparison shows 2 vCPU x64 compute at $0.0009 a minute against GitHub's $0.0060, and 16 vCPU at $0.0047 against $0.0420, at us-east-1 spot prices on September 29, 2026. You pay RunsOn a flat annual license per legal entity covering every org and AWS account you control, with no seat or minute metering, after a 15-day trial. Nonprofit, educational, open source and personal use is free in exchange for an acknowledgement link. The repository carries an MIT license file and v3.3.2 shipped September 17, 2026.

The fully do-it-yourself option is actions-runner-controller, GitHub's own Apache 2.0 Kubernetes operator with about 6,500 stars, whose current runner scale set release is 0.14.2 from May 22, 2026. It costs nothing and gives you everything, including the pager: autoscaling, image caching and cleanup become your job rather than a config change.

Zoomies covers the case in between: a free, AGPL-3.0 controller that gives every job a fresh ephemeral runner on Linux hosts you already have, cloud VMs or a home lab, with no Kubernetes cluster.

It is a single Go binary that keeps its state in one SQLite file, installed with curl -fsSL https://zoomies.sh/install.sh | sh, which creates the GitHub App for you and, per its quick start, has a fleet running jobs in five minutes. Agents dial out, so hosts behind NAT need no inbound firewall rule, and the fleet is run from a web UI, CLI, REST API or an MCP server that Claude can connect to over OAuth. The caveat is age: the repository was created September 4, 2026, v1.3.3 shipped September 28 and it had 51 stars on September 29, and its Windows agent is not yet qualified. Its own ARC comparison says ARC is very likely the right choice if you already run Kubernetes. Pricing: RunsOn flat annual license, free non-commercial · actions-runner-controller free, Apache 2.0 · Zoomies free, AGPL-3.0.

The One That Shut Down

BuildJet was one of the best known names in this category, Y Combinator backed, with Google, Amazon, Plex, Prisma and Grafbase displayed on its own homepage.

As of September 29, 2026 its homepage carries a red notice reading "BuildJet for GitHub Actions has been shut down", while its pricing page still lists live per-minute rates from $0.004 for 2 vCPU.

That is the risk the rest of this guide does not price: these are venture-funded startups in your deployment path, so weigh how fast you could reverse the change.

Side by Side

How to Choose Without Rewriting Your Pipeline

1. Read the bill by job, not in total. GitHub breaks usage down per workflow. If three matrix jobs own most of the minutes, the fix is the matrix, not the runner.
2. Decide whether you are slow or expensive. Those need different products. Expensive minutes point at Ubicloud or Blacksmith; minutes lost rebuilding identical Docker layers point at Depot.
3. Migrate one workflow first. Each option is a one-line runs-on: change, so convert your slowest non-release workflow and compare a week of real runs.
4. Check the concurrency ceiling first. Namespace publishes 32, 64 and 160 vCPU caps by tier. A cheaper rate is worthless if jobs queue behind a limit you have already hit.
5. Price the exit, not the entry. Keep the original runs-on: value in a comment and confirm you can revert in one commit.

Which One Should You Actually Use?

Lowest bill, willing to trade polish: Ubicloud Standard at $0.0012 a minute is 5x cheaper than GitHub for the same 2 vCPU shape, and the control plane being AGPL v3 means the exit is a migration rather than a negotiation.

A drop-in that just works: Blacksmith. The 3,000 free minutes cover a small team outright, the ARM tier at $0.0025 is the best price-to-effort ratio here, and the migration is genuinely one line.

Container builds dominate your pipeline: Depot, and only in that case. Per-minute it is GitHub's price plus $20 a month, so it only pays back if remote layer caching removes minutes you are currently burning.

You already run on AWS and have someone who knows it: RunsOn. Spot-priced compute with no per-minute markup is the cheapest ceiling available, and the flat license means cost stops scaling with usage entirely.

A platform team with Kubernetes and a rota: actions-runner-controller. Free, Apache 2.0, maintained by GitHub, and it hands you every operational responsibility that the managed vendors were absorbing.

A few VMs or a home lab, no Kubernetes: Zoomies. Ephemeral, autoscaled runners from one install script on hosts you already pay for. The project is weeks old, so pin a release and keep a fallback runner until it has earned your trust.

Conclusion

This category exists because GitHub charges the same rate for slow hardware as for fast, so faster machines cut the bill twice. Against GitHub's $0.006 per minute, the managed options land 33 to 80 percent cheaper before any speed claim.

Before migrating, answer one question: is your CI expensive because minutes cost too much, or because your pipeline uses too many? Only the first has a vendor-shaped solution.

Related DevToolLab Tools

• GitHub Actions Generator - scaffold a workflow with runs-on: already set to the runner you picked.
• GitLab CI Generator - build the equivalent pipeline to compare GitLab's runner pricing.
• Jenkinsfile Generator - the self-hosted baseline to price before renting runners.
• YAML Diff Checker - confirm a runner migration changed exactly one line per workflow.

Related Guides

• Best CI/CD Tools in 2026 compares the CI platforms themselves.
• GitHub Actions Best Practices 2026 cuts minutes with caching and reuse first.
• Best Monorepo Tools in 2026 covers the affected-projects problem behind growing CI minutes.
• 7 Datadog Alternatives and What They Cost applies the same pricing method to observability.