GitHub Actions Pricing 2026: What to Change Now

GitHub Actions pricing is changing, and the impact becomes real on March 1, 2026. The headline: a $0.002 per‑minute platform fee now applies to self‑hosted runner usage in private repositories. Add the January 1, 2026 price reductions for hosted runners and a March 16, 2026 minimum self‑hosted runner version block, and you’ve got both a cost model shift and an operational deadline. This guide breaks down what changed, who pays more or less, and exactly how to optimize minutes without slowing delivery.

GitHub Actions pricing: the facts you need

Here’s the summary, with dates you can take to finance and your platform team:

• January 1, 2026: GitHub reduced list prices for hosted runners (by up to ~39% depending on size). Those listed prices already include the new platform charge.
• March 1, 2026: A $0.002/min “Actions cloud platform” fee begins for self‑hosted runner usage in private repositories. Public repositories remain free for both hosted and self‑hosted usage. GitHub Enterprise Server customers are not affected.
• March 16, 2026: Self‑hosted runners must be version v2.329.0 or newer at configuration/registration time. Brownouts preceded the enforcement; after March 16, older runners won’t register.

One more clock you can’t ignore: Node.js 20 reaches end of life on April 30, 2026. If you maintain JavaScript‑based Actions pinned to node20, treat that as a security and operability deadline to move to node24 and to bump any third‑party Actions you use.

Will self‑hosted still save money?

For many workloads, yes—if you run efficiently. The new $0.002/min fee is small compared to typical cloud compute, but it changes the break‑even. Hosted runners got cheaper on January 1, so your previous “self‑hosted or hosted” math is outdated.

When self‑hosted still wins:

• You can saturate cores with parallel builds and keep average queue times near zero.
• You rely on large CPU/RAM or GPU shapes that cost less on your infra than GitHub’s large hosted tiers.
• You need specialized tooling (kernel modules, privileged Docker, non‑standard drivers) or strict network controls where hosted runners aren’t an option.

When hosted may be cheaper now:

• You rarely hit high concurrency or your self‑hosted fleet idles most of the day.
• Your pipelines are dominated by setup time (SDK/Tool installs) rather than CPU‑bound work—GitHub’s tuned images and caches can outpace bespoke hosts.
• You need burst capacity during business hours and don’t want to build autoscalers.

The practical cost model (so you can talk to finance)

Your unit cost is now: minutes × (runner compute rate + $0.002). For self‑hosted, “runner compute rate” is your internal cost per minute of the VM/bare‑metal plus anything you spend to autoscale and manage runners (storage, images, logging). For hosted, the platform charge is already baked into the listed per‑minute price.

What moves the needle most isn’t the $0.002; it’s the minutes. If a pipeline wastes 4–6 minutes per job just installing SDKs, that’s the same tax whether you’re on hosted or self‑hosted. The fastest way to cut cost is to cut time.

Deploy this 30‑day “MINUTES” plan

If you do nothing else, run this sprint‑sized plan and you’ll reduce cost and risk before the March deadlines:

M — Measure what’s real

Export last month’s Actions usage by repo and workflow. For each job, record queue time, run time, cache hits/misses, and failure rate. Tag each job “CPU‑bound,” “IO/cache‑bound,” or “setup‑bound.” This gives you a ranked list of the worst “minute burners.”

I — Improve caching first

Move any artifact under 500 MB that’s reused across jobs into the Actions cache or a blob store pulled via actions/download-artifact. Pre‑warm Docker layers. Pin tool versions so the cache is stable. For mobile, host prebuilt SDK toolchains and cached CocoaPods/Gradle directories per branch.

N — Normalize images

Standardize on a small set of hardened base images with language SDKs, package managers, and linters already installed. Refresh weekly. For ARC or the new Scale Set Client, bake the runner binary v2.329.0+ into those images to pass the March 16 registration check without last‑minute rebuilds.

U — Use concurrency controls

Throttle flaky end‑to‑end suites and run them after fast PR gates. Use concurrency: groups to auto‑cancel superseded runs. Your goal: merge feedback within 10 minutes for most PRs, push heavy suites to post‑merge or nightly.

T — Trim dependencies

Every minute you spend compiling native deps or fetching huge npm/Gradle trees is a tax. Aggressively prune unused packages, move big binaries to artifacts, and vendor critical CLI tools into your runner image.

E — Eliminate setup waste

Stop installing SDKs on every run. Preinstall Node, Java, .NET, CocoaPods, Python, Android build tools, and cache their paths. Use matrix builds but deduplicate steps that don’t need to run per target.

S — Secure the edge

Lock egress on self‑hosted runners to only what jobs need. That cuts supply‑chain risk and often speeds builds by eliminating background update checks. If you run AI agents in CI for code transforms or tests, add an egress policy now; our guide on egress firewalls for AI agents shows a proven pattern.

Self‑hosted runner governance just got stricter

By March 16, 2026, you need v2.329.0+ for runner configuration/registration. Don’t wait for the block. Bake the new runner into your images, then rotate your pools with blue‑green or canary rollouts (10%, 30%, 100%). For ARC users, update your Helm charts and confirm the image includes the new runner. If you’re using the Runner Scale Set Client instead of ARC, pin the client version in your infra code and add health probes that fail fast on registration errors.

Operational checklist you can run today:

• Inventory every runner pool and image tag. Document where the runner binary comes from.
• Rotate secrets, PATs, and OIDC trust policies while you’re touching runner config.
• Add an alert for “registration failures per minute” and “jobs queued to unregistered runners.”
• Write a 10‑minute rollback to the previous runner image if your canary fails.

Hosted vs self‑hosted in 2026: a clear decision tree

Use this quick rubric with your team:

1) Do we need GPUs, custom kernels, or privileged Docker? If yes, self‑hosted.
2) Are our average PR builds under 8 minutes with hosted runners today? If yes, stay hosted and tune cache.
3) Do we run more than 100k minutes/month and need predictable queue times under 30 seconds? If yes, evaluate self‑hosted autoscaling with ARC or the Scale Set Client.
4) Do we have staff to own images, patch runners weekly, and monitor failures? If no, prefer hosted.

People also ask

How do I estimate my new bill quickly?

Pull last month’s usage report. For each job on self‑hosted, add 0.002 to your current per‑minute compute cost and multiply by minutes. For hosted, compare the new January 1, 2026 rates to your historical spend. Sensitivity‑test with ±15% minutes to account for variability and planned test growth.

Do public repo jobs still run free?

Yes. Public repositories remain free for both GitHub‑hosted and self‑hosted runners. Your private repos are where the new platform fee applies to self‑hosted minutes.

Should we switch from ARC to the Runner Scale Set Client?

Not automatically. ARC is still the reference Kubernetes solution and great when you already run K8s. The new client is ideal if you want autoscaling on VMs or bare metal without Kubernetes, or you want tighter control of provisioning and labels across mixed environments. Many enterprises will run both.

Technical gotchas to fix before they bite

• Node 20 EOL on April 30, 2026: update any custom Actions from runs.using: node20 to node24; bump third‑party Actions to versions that ship node24 bundles. If you’re juggling Node upgrades across your stack, our Node.js EOL 2026 playbook covers safe sequencing and rollback.

• Image drift: if your runner images install tools at startup, you’ll pay that time every run. Bake tools into the image and refresh on a schedule. For macOS/iOS pipelines, keep a separate “Xcode cache” volume to avoid redownloading huge toolchains on every job.

• Label sprawl: without multi‑label discipline, jobs land on oversized machines. Define three or four canonical labels (small‑linux, large‑linux, macos‑mobile, windows‑build) and enforce them.

• Artifact bloat: cap artifact retention and compress aggressively. Move huge debug symbol sets to a short‑lived bucket, not long‑term artifact storage.

Example: cutting 40% minutes on a mobile monorepo

One client’s iOS/Android monorepo spent 6–8 minutes of every job on tool setup. We consolidated to two hardened images: one for mobile SDKs (Android + NDK, Gradle, CocoaPods) and one for test runners. With pre‑warmed caches and matrix de‑duplication, median PR time dropped from 14:20 to 8:35. After the January hosted‑runner price drop, the team moved 60% of jobs back to hosted and kept heavy release builds on self‑hosted macOS. Net: lower cost, faster merges, zero queue spikes.

Policy and security you can defend

Finance will ask why minutes are up or down; security will ask how you controlled risk. Codify both:

• SLOs: “90% of PR runs finish in under 10 minutes” and “Queue time under 45 seconds at P50.”
• Budget guardrails: “Monthly Actions spend stays within ±10% of forecast; alert at 80%.”
• Access: action allow‑listing for all orgs; signed releases pinned by SHA, not @vX tags.
• Egress: default‑deny from runners; open only the registries, mirrors, and package hosts you need. See this playbook for a simple, auditable pattern.

What to do next (this week)

1) Model cost: rerun your break‑even with the $0.002/min platform fee and the January hosted price cuts.
2) Update runners: rebuild images with v2.329.0+ and rotate pools via canary.
3) Kill minute burners: fix caches, bake tools, and cancel superseded workflows.
4) Decide your mix: keep PR gates on hosted for burst capacity; move heavy release builds or GPU jobs to self‑hosted.
5) Plan Node: schedule your Node 20 → 24 migration before April 30, 2026.

Need a second set of hands?

If you want a battle‑tested migration plan or a quick audit of your pipeline minutes, our team does this weekly. See how we approach CI/CD modernization on what we do, browse relevant case notes on the blog, and check our focused March 2026 self‑hosted runner plan. Or just start a conversation on the contacts page—we’ll reply with concrete next steps, not sales fluff.

Key takeaways

• The new GitHub Actions pricing doesn’t have to increase your bill—if you cut minutes and pick the right jobs for each runner type.
• Treat March 16, 2026 as a hard compliance date for runner registration on v2.329.0+.
• Use images, caches, and concurrency controls to shave 30–50% from typical pipeline times.
• Start your Node 20 deprecation work now and bump any Actions pinned to node20.
• Write down SLOs and budget guardrails so finance and engineering speak the same language.