# Managed GitHub Actions runners compared, by how you pay

> Managed GitHub Actions runners compared on where jobs run, what you still operate and which meters sit beside the headline rate. Every price dated.

Source: https://latchkey.dev/learn/runners/managed-github-actions-runners-compared  
Updated: 2026-09-21

Managed GitHub Actions runners compared on rate alone will tell you to pick the cheapest row, and the cheapest row is frequently not the cheapest vendor. What separates them is structural: whose cloud the job runs in, what you still have to operate, and which meters run beside the one on the pricing page.

Every vendor in this market sells the same first sentence: cheaper and faster than GitHub-hosted, attached with a label change. Most of them deliver it, which is why the sentence is useless for choosing between them.

The useful distinctions are three. Where the compute physically runs, because that decides your data path and who gets paged. What the bill is shaped like, because a licence, a meter and a prepaid pool fail differently as you grow. And what the headline rate excludes, because several vendors meter things beside minutes.

## Three shapes, not one market

Fully managed and metered is the shape most people mean: the vendor owns the fleet, you change `runs-on`, and you pay per minute. Blacksmith, Depot, Namespace, Ubicloud, WarpBuild managed and Latchkey are all this. Setup is a GitHub App connection and a label, and nothing about your cloud account changes.

Bring-your-own-cloud is the second shape. The vendor supplies the control plane and the runner image, and the machines are started in your AWS, GCP or Azure account, so the compute bill and the network boundary are yours. WarpBuild publishes this at a flat $0.002 a minute. The third shape is a licence with no meter at all: RunsOn charges from EUR 300 a year at its Starter tier and states that the compute is your AWS bill, not ours, with no markup, billed per second by AWS.

| Vendor | Shape | Where jobs run | What you still operate | Setup change |
| --- | --- | --- | --- | --- |
| Blacksmith | Managed, metered | The vendor's cloud | Nothing | GitHub App plus a `runs-on` label |
| Depot | Managed, metered | The vendor's cloud | Nothing | GitHub App plus a `runs-on` label |
| Namespace | Managed, metered | The vendor's cloud | Nothing | Connection plus a runner profile label |
| Ubicloud | Managed, metered | The vendor's cloud | Nothing | GitHub App plus a `runs-on` label |
| Latchkey | Managed, metered | The vendor's cloud | Nothing | GitHub App plus a `runs-on` label |
| WarpBuild | Managed, or bring-your-own-cloud | The vendor's cloud, or yours | Your cloud account, in BYOC mode | GitHub App, plus cloud credentials for BYOC |
| RunsOn | Licence, your account | EC2 in your own AWS account | The AWS account, quotas, AMIs, spot capacity | A CloudFormation stack you own |
| GitHub-hosted | First party | GitHub's cloud | Nothing | None; it is the default |

> Shapes and setup steps read from each vendor's own documentation on 2026-09-21. The rates behind these rows, with free tiers and billing granularity, are in [GitHub Actions runner alternatives](/learn/runners/github-actions-runner-alternatives); this table deliberately compares structure instead, because two vendors at the same rate can still be different products.

## The meters beside the meter

Three vendors charge for things the minute rate does not include, and on a Docker-heavy or cache-heavy pipeline those lines can be larger than the difference between two rates. This is the part that a rate-card comparison hides, and it is published, so there is no excuse for leaving it out.

None of these are traps; they are honest unbundling, and in each case the feature is genuinely optional. They just have to be added before you compare. A pipeline with a 50 GB Docker layer cache on Blacksmith is paying $25 a month for that cache on top of its minutes, and a pipeline restoring a WarpBuild snapshot on every one of 20,000 jobs a month is paying $800 for the restores.

| Vendor | What else is metered | Published price |
| --- | --- | --- |
| Blacksmith | Docker layer caching | $0.50 per GB per month |
| Blacksmith | Sticky disks | $0.50 per GB per month |
| Blacksmith | Static IPs | $100 per IP per month |
| WarpBuild | Cache storage | $0.20 per GB-month |
| WarpBuild | Cache write or restore | $0.0001 per operation |
| WarpBuild | Snapshot restore | $0.04 per job |
| WarpBuild | Snapshot storage | $0.025 per hour per snapshot |
| Namespace | Usage past the plan pool | Exactly 50% above the prepaid rate |

> Read from blacksmith.sh/pricing, warpbuild.com/pricing and namespace.so/pricing on 2026-09-21. Depot bundles cache with its plan, at 25 GB on the $20 Developer plan and 250 GB on Startup, so its equivalent line is a plan fee rather than a per-gigabyte meter.

## The row most comparisons leave out

GitHub sells a 1-core Linux x64 runner. Its published per-minute rate table lists the SKU `actions_linux_slim` at $0.002 a minute, against $0.006 for the 2-core `actions_linux`. That is cheaper than every managed vendor in this comparison except Ubicloud, from the first party, with no connection to set up and no third party in the data path.

It is not a universal answer, because one core is one core: anything that compiles, bundles or runs a browser will be slower than the wall-clock saving is worth, and slower minutes at a third of the price can still cost more. But a lint job, a formatting check, a small unit suite or a deploy step often does not care, and moving those jobs is a rate cut nobody has to be sold. Try it on the cheapest third of your jobs before you evaluate a vendor for them.

```.github/workflows/ci.yml
jobs:
  lint:
    runs-on: ubuntu-slim      # actions_linux_slim, $0.002/min published
    steps:
      - uses: actions/checkout@v5
      - run: npx prettier --check .

  build:
    runs-on: latchkey-small   # 2 vCPU, 8 GB, $0.0025/min published
    steps:
      - uses: actions/checkout@v5
      - run: npm ci && npm run build
```

> Rates and SKU names quoted from the GitHub Docs Actions runner pricing reference, read 2026-09-21. That same page records the rounding rule that applies to all of them: GitHub rounds the minutes and partial minutes each job uses up to the nearest whole minute, which is what makes a short job on any per-minute vendor cost more than its seconds.

## BuildJet is no longer one of the options

Older roundups of this market, including an earlier version of this page, list BuildJet as a cheap drop-in swap. It stopped running jobs on 31 March 2026, which its own shutdown announcement states, and the corpus fact file here records the same date. A comparison that still ranks it is not out of date by a little; it is recommending a service that will not pick up your jobs.

The practical residue is a `runs-on` label in old workflow files. If you inherit a repository with `buildjet-4vcpu-ubuntu-2204` in it, that job is queuing for a runner that will never arrive, which looks identical to a concurrency problem. [Migrating off BuildJet](/learn/runners/migrate-from-buildjet) is the label map for that case.

## Where each one actually wins

Short version, and on price and terms rather than on anybody's performance marketing. Ubicloud publishes the lowest Linux x64 rate in this comparison and sells Linux x64 only. Blacksmith bundles 3,000 free minutes a month and prices arm64 below its x64 rate, sitting at the median for x64. Depot charges GitHub list price a minute and bundles cache by plan, 25 GB on Developer and 250 GB on Startup, alongside remote BuildKit builders.

Namespace sells the smallest machine in this comparison, 1 vCPU with 2 GB, where every fixed-size vendor here floors at two cores, and the widest platform range, including macOS and Linux on Apple Silicon. The price of that is a unit-minute model that surprises people on the invoice. WarpBuild is the answer when the compute has to stay in your own cloud account. Latchkey is a $0.0025 Linux x86_64 minute with 25 GB of cache per repository, and it has no arm64, no Windows and no macOS at any price.

## How to choose without a spreadsheet

Three cuts, in this order, and most teams are down to two candidates by the second one.

1. Eliminate on platform. List the jobs that are not Linux x86_64. Windows, macOS, arm64 or a GPU removes several vendors outright and usually turns this into a split rather than a switch.
2. Eliminate on shape. Decide whether the compute may leave your cloud account. If it may not, you are choosing between WarpBuild BYOC, RunsOn and self-hosting, and the per-minute table is irrelevant.
3. Then compare on total bill rather than rate: minutes times the rate, plus the add-on meters in the table above, plus any plan fee, against the same for GitHub-hosted including the minutes your plan already includes.

## What this page does not measure

No benchmark here is ours and no run backs this page. Every figure is a published price read on a stated date, and the two rates I would most want to check by hand, effective cost per useful minute and queue time under load, are exactly the two that no vendor publishes and that vary with your own pipeline more than with the vendor.

Prices in this market also move. Ubicloud raised both its tiers by 25% effective 1 September 2026, and Depot's Actions runners moved to GitHub list price during 2026, so any comparison older than a quarter should be re-read rather than trusted. That is also true of this one, which is why every row above carries the date it was read.

## FAQ

### What is a managed GitHub Actions runner?

A runner fleet somebody else operates, attached to your workflows with a label change instead of a server. In the common shape the vendor owns the machines and bills you per minute; in bring-your-own-cloud the vendor supplies the control plane and the machines start in your own cloud account; and in the licence shape, such as RunsOn, you pay a flat fee and the compute is your own AWS bill with no markup.

### Is the cheapest per-minute rate the cheapest vendor?

Often not. Three vendors meter things beside minutes: Blacksmith charges $0.50 per GB per month for Docker layer caching and for sticky disks and $100 per IP per month for static IPs, WarpBuild charges for cache storage, cache operations and snapshot restores, and Namespace bills usage past the plan pool at exactly 50% above the prepaid rate. Add those lines before comparing rates.

### Is there a cheaper GitHub-hosted runner than the standard one?

Yes. GitHub publishes a 1-core Linux x64 SKU, `actions_linux_slim`, at $0.002 a minute against $0.006 for the 2-core `actions_linux`. On lint, formatting, small unit suites and deploy steps that is a rate cut with no vendor to connect. On anything that compiles or runs a browser, one core will usually cost you more in wall clock than the rate saves.

### Is BuildJet still a managed runner option?

No. BuildJet stopped running jobs on 31 March 2026 according to its own shutdown announcement. Any comparison still listing it is stale, and any workflow still carrying a `buildjet-` label has a job waiting for a runner that will not arrive, which presents exactly like a concurrency limit until you look at the label.

## References

- [GitHub Docs: Actions runner pricing, including the actions_linux_slim SKU and the rounding rule (verified 2026-09-21)](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [Blacksmith pricing: per-minute rates by architecture, free minutes and the add-on meters (verified 2026-09-21)](https://www.blacksmith.sh/pricing)
- [WarpBuild pricing: managed and bring-your-own-cloud rates, cache and snapshot charges (verified 2026-09-21)](https://www.warpbuild.com/pricing)
- [Namespace pricing: unit minutes, prepaid and overage, plan pools and concurrency ceilings (verified 2026-09-21)](https://namespace.so/pricing)
- [RunsOn pricing: licence tiers and the statement that compute is your own AWS bill (verified 2026-09-21)](https://runs-on.com/pricing/)

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt