How Much Do GitHub Actions Runners Cost?

GitHub Actions runners are billed by the minute, so the cost of a runner is its per-minute rate multiplied by the minutes your jobs actually run. On WarpBuild, that rate starts at $0.003 per minute for a 2 vCPU Linux ARM64 runner and $0.004 per minute for a 2 vCPU Linux x64 runner, and reaches $0.08 per minute for a 6 vCPU macOS runner.

Answer

A GitHub Actions bill has two parts: runner minutes and a short list of usage add-ons such as cache storage and snapshot restores. WarpBuild charges both by usage. Pricing is purely usage based. There is no base subscription fee, no platform fee, and no seat fee. Signup includes $10 free credits, so the first few thousand Linux minutes cost nothing.

Here is the entry rate on each platform, next to the nearest GitHub-hosted shape.

To turn that into a monthly figure, take the minutes your organization already burns on GitHub Actions and multiply by the rate of the runner you plan to use. A team burning 30,000 Linux minutes a month on 4 vCPU machines pays $240.00 at $0.008 per minute. The same 30,000 minutes on 2 vCPU machines pay $120.00. Nothing else is added for the account, the repository count, or the number of engineers pushing code.

The tables below compare specific runner sizes at fixed durations. Substitute your workload's measured job times and use the WarpBuild pricing page for the full rate list.

GitHub rates come from the GitHub Actions per-minute rate list and the plan overview at github.com/pricing, both checked on 2026-08-13. WarpBuild rates come from the WarpBuild pricing page and the cloud runners documentation. The four rows above cover the whole catalog.

Detail

The arithmetic behind a runner bill

Runner cost is minutes multiplied by rate. A job that takes 7 minutes on warp-ubuntu-latest-x64-4x at $0.008 per minute costs $0.056. Run it on 500 pull requests in a month and the line item is $28.00. Double the vCPU count and the rate doubles too, which means a bigger runner pays for itself only when it cuts wall-clock time by more than half.

Billing granularity matters when jobs are short. WarpBuild bills GitHub Actions runners per minute, so a 40 second job and a 60 second job land in the same billing bucket. Fleets with thousands of tiny jobs should look at job count as closely as total minutes.

Matrix builds are where that shows up first. A matrix of 12 lint jobs that each finish in 35 seconds bills as 12 minutes, while folding the same work into one job that runs for 7 minutes bills as 7. The reverse trade holds for slow suites: splitting a 40 minute test job into 8 parallel shards of 6 minutes bills 48 minutes and returns a result in 6, which is the right trade when developers are waiting on the result and the wrong one when the job runs on a nightly schedule.

Billed time and execution time are separate numbers on the invoice view, so the per-job report is the place to check how a queue of short jobs rounds up.

One comparison caveat is worth stating up front. GitHub gives public repositories a 4 vCPU, 16 GB Linux shape at no charge, so open source projects on GitHub-hosted runners pay nothing for standard Linux minutes. Every GitHub number on this page is the private-repository list price, which is what paying teams actually see on an invoice.

Linux x64 rates

GitHub list prices checked on 2026-08-13 against the GitHub Actions per-minute rate list. The same rates apply to the Ubuntu 22.04 and Ubuntu 26.04 label families, so pinning warp-ubuntu-2604-x64-4x instead of warp-ubuntu-latest-x64-4x changes the image and leaves the price at $0.008 per minute.

Linux ARM64 rates

ARM64 is the cheapest platform in the catalog at every size.

GitHub list prices checked on 2026-08-13 at docs.github.com. ARM64 runners on Ubuntu 24.04 set the working directory to /runner/_work instead of GitHub's /home/runner/work/, which matters for scripts that hardcode paths. The Ubuntu 22.04 ARM64 images were deprecated on March 31, 2025.

macOS rates

macOS is the most expensive platform on every GitHub Actions runner fleet, so it usually dominates the invoice for iOS and macOS teams.

warp-macos-latest-arm64-6x is an alias for the macOS 15 6 vCPU runner, and warp-macos-latest-arm64-12x aliases the 12 vCPU one. The macOS 26 runners ship Xcode 27.0 with the iOS, tvOS, watchOS, and visionOS 27.0 simulator runtimes.

The macOS arithmetic: warp-macos-latest-arm64-6x (6 vCPU, 22 GB) costs $0.08 per minute against $0.102 per minute for the largest GitHub-hosted macOS ARM64 runner (5 vCPU, 14 GB), which is 22 percent lower list price on a shape that carries one more vCPU and 8 GB more memory. GitHub list price checked on 2026-08-13 at docs.github.com. GitHub also publishes a smaller 3 vCPU, 7 GB macOS runner at $0.062 per minute; that is a different shape and a different comparison, so treat it separately when you model an Xcode build that needs memory. For the full macOS breakdown, see the macOS GitHub Actions runner cost guide.

Windows rates

GitHub list prices checked on 2026-08-13 at docs.github.com. Windows Server 2025 labels carry the same rates as the Windows Server 2022 labels, and the warp-windows-2025-vs2026-x64-* labels carry Visual Studio 2026 at those same rates. The 2 vCPU Windows tier was removed on June 8, 2026, so 4 vCPU at $0.016 per minute is the Windows floor. Sizes and image details live on the Windows runners page.

Everything else that appears on the bill

Runner minutes are the largest line, and these usage items sit next to them.

Remote Docker builders bill per session, measured from the moment the builder action starts until the job completes. Concurrent jobs that share a builder profile share one session, so ten parallel jobs on a 32 vCPU profile at $0.12 per minute cost the same as one job holding that builder for the same wall-clock window. Multi-architecture profiles open one session per architecture and bill them independently.

What the bill never contains

Pricing is purely usage based. There is no base subscription fee, no platform fee, and no seat fee. A team of 40 engineers and a team of 400 engineers pay the same rate for the same minute of the same runner.

Concurrency carries no price either. Run as many jobs as your workflows need. Generally available Linux and Windows runners do not have plan-level concurrency caps, so a merge queue that fans out to 200 parallel jobs pays for 200 jobs worth of minutes and nothing else.

For a finance team, the practical effect of the usage-based structure is that headcount changes and repository sprawl leave the runner bill alone. Onboarding 15 engineers adds cost only when those engineers push commits that queue jobs. Archiving a repository removes its minutes from the next invoice with no plan change and no contract amendment. The forecast reduces to one line: expected job minutes per platform, multiplied by the rate for the labels those jobs use.

Two items are worth budgeting separately. SSO is available for a flat $250 per month, whatever the user count, and it is charged monthly rather than per minute; the rest of the price list is on the WarpBuild pricing page.

A worked model on a real workflow

This workflow runs four jobs on every pull request, one per platform.

name: ci
on:
  pull_request:
    branches: [main]

jobs:
  unit-tests:
    runs-on: warp-ubuntu-latest-x64-4x
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npm test

  arm-image:
    runs-on: warp-ubuntu-latest-arm64-4x
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t app:arm64 .

  ios-build:
    runs-on: warp-macos-latest-arm64-6x
    steps:
      - uses: actions/checkout@v4
      - run: xcodebuild -scheme App -destination 'generic/platform=iOS' build

  windows-tests:
    runs-on: warp-windows-latest-x64-4x
    steps:
      - uses: actions/checkout@v4
      - run: dotnet test

Assume the jobs take 6, 5, 12, and 8 minutes.

At 300 pull request runs a month, that workflow costs $349.80.

The same minutes on the nearest GitHub-hosted shapes cost $0.072 for the 4-core Linux larger runner, $0.040 for the 4-core Linux ARM64 larger runner, $1.224 for the largest macOS ARM64 runner, and $0.176 for the 4-core Windows larger runner: $1.512 per run, or $453.60 for 300 runs. The monthly difference is $103.80 on list prices checked on 2026-08-13 at docs.github.com.

A worked model on a full month

A 40 engineer team running a mixed fleet produces an invoice like this.

Signup includes $10 free credits, so the first invoice on that usage is $457.00. Payment details are held by Stripe, and accounts are billed on the last day of the month unless usage crosses an account threshold first.

Three levers move that total. Cutting minutes through caching and better job parallelism moves the biggest line. Right-sizing each job to the smallest runner that keeps it fast moves the rate. Moving Linux jobs that have no x86 dependency to ARM64 moves both, since a 4 vCPU ARM64 runner is $0.006 per minute against $0.008 for the x64 runner of the same shape. The guide to reducing GitHub Actions costs works through each lever with configuration examples.

Seeing what you actually spend

Estimates only go so far. The WarpBuild reports documentation covers the billing view that breaks cost down per job, per repository, and per runner label, with separate tabs for CI runners, Docker builders, and cache. Each row shows execution time, billed time, and the split between runner cost and snapshot cost, and every table exports to CSV.

Label-level attribution is the fastest way to find the expensive corner of a fleet. Group the daily cost chart by runner label and the macOS line usually stands alone, since one macOS minute at $0.08 costs as much as twenty 2 vCPU Linux x64 minutes at $0.004. Group it by repository and the answer is usually one service with a matrix that grew without review.

The Jobs tab adds duration, queue time, CPU, and memory percentiles per job, which is how you find the jobs that are paying for vCPU they never use. CPU and memory columns need CI observability enabled on the runner. Alongside those reports, snapshot runners, remote Docker builders, an MCP server, and the Action Debugger round out the product surface that shapes what a job costs.

Related Questions

How much do GitHub Actions larger runners cost?

On WarpBuild, a 4 vCPU Linux x64 runner costs $0.008 per minute and an 8 vCPU runner costs $0.016 per minute. GitHub lists $0.012 per minute for its 4-core Linux larger runner and $0.022 for the 8-core, checked on 2026-08-13 at docs.github.com. The larger runners cost guide walks through every size class.

How much does a macOS GitHub Actions runner cost per minute?

A WarpBuild macOS runner with 6 vCPU and 22 GB of memory costs $0.08 per minute. The largest GitHub-hosted macOS ARM64 runner, with 5 vCPU and 14 GB, lists at $0.102 per minute, checked on 2026-08-13 at docs.github.com. See the macOS runner cost guide for Xcode image details and sizing advice.

How much do Windows GitHub Actions runners cost?

WarpBuild Windows runners start at $0.016 per minute for 4 vCPU and 16 GB and reach $0.128 per minute for 32 vCPU and 128 GB. GitHub lists $0.022 per minute for its 4-core Windows larger runner, checked on 2026-08-13 at docs.github.com. The Windows runners page lists the image variants, including the Visual Studio 2026 labels.

What is the cheapest way to run GitHub Actions?

Cut billed minutes first through caching and job parallelism, then match each job to the smallest runner that keeps it fast. Pricing is purely usage based. There is no base subscription fee, no platform fee, and no seat fee, so the only variable you control is minutes multiplied by rate. Start with the cost reduction guide and the full price list on the WarpBuild pricing page.