GitHub Actions Free Tier 2026: The Complete Guide to CI/CD at Zero Cost

If you write code on GitHub, you already have a CI/CD system built in. GitHub Actions is the most-used continuous integration and delivery platform in the world, and its free tier is dangerously generous — especially for open-source projects.

Here’s the kicker: public repositories get unlimited free minutes. Private repositories on the free plan get 2,000 minutes per month with 500 MB of artifact storage. That’s enough to run a substantial CI pipeline for a small team without paying a cent.

In this guide, we’ll walk through exactly what GitHub Actions does, what you get on the free plan, how to set up your first workflow, real-world use cases, how it stacks up against GitLab CI and CircleCI, and expert strategies to stay well within the free limits.

---

1. What Is GitHub Actions and Why Use It?

GitHub Actions is a CI/CD and automation platform baked directly into GitHub. It lets you define workflows that run when events happen in your repository — pushing code, opening a pull request, creating an issue, publishing a release, or even on a schedule.

Each workflow is a YAML file you commit to .github/workflows/ in your repo. When triggered, GitHub spins up a runner (a Linux, Windows, or macOS VM), checks out your code, and runs your steps: install dependencies, run tests, build artifacts, deploy to production, send notifications, or almost anything else you can script.

Why choose GitHub Actions over a standalone CI tool?

1. Zero setup for GitHub projects. If your code already lives on GitHub, you don’t need to connect a separate CI service, manage API tokens, or configure webhooks. Actions is native — every repo already has the capability.

2. Tight GitHub integration. Workflows trigger automatically on pull requests, pushes, issue comments, releases — any GitHub event. Build status appears directly in PR checks. You can add labels, comment on issues, create deployments, and update project boards from within your workflow.

3. The Marketplace. The GitHub Marketplace hosts thousands of community- and vendor-built actions. Need to set up Node.js? actions/setup-node@v4. Deploy to AWS? aws-actions/configure-aws-credentials@v4. There’s a pre-built action for nearly every common task.

4. Unlimited for open source. Public repositories (including forks) get unlimited minutes on standard GitHub-hosted Linux runners. If your project is open source, the free tier is essentially infinite.

5. No credit card required. Unlike many competitors, you can use GitHub Actions on private repos without ever entering a payment method — until you exhaust your 2,000 monthly minutes.

What real users say

“GitHub Actions is genuinely convenient and the free tier is fine for small projects. The tight integration with PRs and the Marketplace are killer features.” — Medium review, 2025

“The debugging experience when making a new workflow can be frustrating. But once it’s set up, it just works. The ecosystem of pre-built actions saves enormous time.” — Reddit r/devops, 2024

“We switched from CircleCI to GitHub Actions mainly because it was one less platform to manage. The learning curve for the YAML syntax is minimal if you’ve used any CI before.” — Reddit r/devops, 2023

On the flip side, common complaints include:

• Debugging friction: You can’t test workflows locally without third-party tools like act.
• YAML complexity: Workflows with many jobs, matrix strategies, and conditions can become unwieldy.
• No SSH access on free runners: When a build fails, you can’t SSH into the runner to inspect the state (available on larger paid runners).

---

2. Key Free Tier Features and Limits (July 2026)

GitHub Actions’ free tier is tied to your account/repo plan. Here’s the exact breakdown:

Free Plan (GitHub Free)

Resource	Free Limit	Overage Cost
Linux minutes (private repos)	2,000 min/month	$0.006/min (2-core)
Windows minutes (private repos)	Included in 2,000 pool (counts at 2x rate)	$0.010/min
macOS minutes (private repos)	Included in 2,000 pool (counts at 10x rate)	$0.062/min
Artifact storage	500 MB	$0.25/GB/month
Cache storage	10 GB	—
Concurrent jobs (private repos)	20	—
Concurrent jobs (public repos)	20	—
Public repo minutes	Unlimited (Linux, Windows, macOS)*	Free
Open source minutes	Unlimited	Free
Self-hosted runners	Unlimited (no concurrent limit)	Free (the proposed $0.002/min fee was postponed after community backlash)
Workflow run time	72 hours per job	—
Team size	Unlimited collaborators on free	—

* macOS minutes on public repos are limited. As of 2026, public repos get free Linux and Windows minutes, but macOS is metered.

Important: 2026 Pricing Changes

On January 1, 2026, GitHub cut hosted-runner rates by up to 39% across all machine sizes. A Linux 2-core runner dropped from ~$0.008/min to $0.006/min for overage. A new $0.002/min “Actions cloud platform” charge was folded into the listed rates (GitHub Actions billing).

The company also attempted to introduce a $0.002/min fee for self-hosted runners starting March 2026, but indefinitely postponed it within 48 hours after massive community backlash on Reddit, Hacker News, and social media. As of July 2026, self-hosted runners remain free.

What counts against your 2,000 minutes?

• Every minute your workflow runs on a GitHub-hosted runner counts. A 5-minute build consumes 5 minutes.
• Windows and macOS charge multipliers: Windows jobs consume 2x the minutes (1 Windows minute = 2 of your quota). macOS jobs consume 10x.
• Public repo workflows do not count against the private repo limit — they are always free.
• Copilot Code Review (if enabled) also consumes Actions minutes in addition to AI credits for private repositories.

Pro-Tip: Storage costs

The 500 MB artifact + log storage limit is separate from the minute limit. Old workflow artifacts and build logs accumulate. If you have a busy repo, set a retention policy (see Tips section) to avoid hitting the storage cap.

---

3. Best Use Cases with Real Examples

Use Case 1: CI for a Small SaaS Startup (Private Repo)

Scenario: You’re building a SaaS product in a private GitHub repo with a team of 3. You need automated testing on every PR and deployment to staging on merge.

Workflow structure:

name: CI
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - run: npm ci
      - run: npm test

  deploy-staging:
    if: github.ref == 'refs/heads/main'
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to staging
        run: ./deploy.sh staging
        env:
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}

Monthly usage estimate:

• 30 PRs/month × 6 min average run = 180 min
• 15 deploys/month × 4 min = 60 min
• Total: ~240 min/month — just 12% of your free quota. You could run 8x this volume for free (free-tier minutes).

Use Case 2: Open-Source Project (Public Repo, Unlimited)

Scenario: You maintain a popular open-source library. You want CI on every commit, PR, and release — plus automated publishing to npm.

Workflow highlights:

name: Test and Release
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  release:
    types: [published]

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [18, 20, 22]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm ci
      - run: npm test
        # Tests run across 6 combinations — all free on public repo

  publish:
    if: github.event_name == 'release'
    needs: test
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm publish --provenance
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

Cost: $0. Public repos get unlimited minutes on standard Linux runners. You could run 10,000 builds a month and never see a bill.

Use Case 3: Automated Schedule + Security Scanning

Scenario: You want nightly dependency updates and weekly security scans — without manual toil.

name: Nightly maintenance
on:
  schedule:
    - cron: '0 2 * * *'  # every night at 2 AM UTC

jobs:
  dependency-update:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npx npm-check-updates -u
      - uses: peter-evans/create-pull-request@v6
        with:
          title: "chore: daily dependency updates"

  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/dependency-review-action@v4
      - run: npm audit --audit-level=high

Monthly usage: ~60 min/month for nightly updates — negligible.

Use Case 4: Automated Deployment to Cloudflare Pages / Vercel / AWS

Scenario: Your static site or frontend app auto-deploys when you push to main.

name: Deploy to Cloudflare Pages
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      deployments: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci && npm run build
      - name: Publish to Cloudflare Pages
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          command: pages deploy dist --project-name=my-site

CI/CD + hosting for $0/month. This is the modern indie-hacker stack.

---

4. Step-by-Step Setup Guide

You can have your first workflow running in under 5 minutes. No credit card needed.

Step 1: Create (or open) a GitHub repository

If you don’t have one yet, create a new repo on GitHub (public or private — Actions works on both).

Step 2: Add your first workflow file

In your local repo or directly on GitHub.com:

Option A: Via GitHub UI (quickest)

1. Go to your repo on github.com
2. Click the Actions tab
3. Choose a template (e.g., “Node.js”, “Python”, “Docker”) or click “set up a workflow yourself”
4. GitHub opens the editor with a starter .github/workflows/main.yml file

Option B: Create locally (recommended for real projects) Create the directory and file:

mkdir -p .github/workflows
touch .github/workflows/ci.yml

Add this starter workflow:

name: CI Pipeline
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install dependencies
        run: npm ci

      - name: Run linter
        run: npm run lint

      - name: Run tests
        run: npm test

Step 3: Commit and push

git add .github/
git commit -m "Add CI workflow"
git push

Step 4: Watch it run

1. Go to your repo on GitHub → Actions tab
2. You’ll see your workflow in the list, with a yellow dot (running) that turns green (pass) or red (fail)
3. Click into the run to see live logs, step-by-step output, and timing

Step 5 (Optional): Add a status badge

Show your build status in your README:

![CI Status](https://github.com/YOUR_USER/YOUR_REPO/actions/workflows/ci.yml/badge.svg)

Pro workflow: Multi-job pipeline with caching

For a real project, here’s a more complete Python example with dependency caching and matrix testing:

name: Python CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12"]

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: 'pip'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Test with pytest
        run: pytest --cov --cov-report=xml

      - name: Upload coverage
        uses: codecov/codecov-action@v4

---

5. Comparison to Alternatives

GitHub Actions competes primarily with GitLab CI and CircleCI. Here’s how they stack up on the free tier in 2026.

Free Tier Comparison Table

Feature	GitHub Actions	GitLab CI	CircleCI
Free compute minutes	2,000/mo (private), Unlimited (public)	400/mo (per namespace)	30,000 credits/mo (~3,000 Linux medium min)
Concurrency	20 parallel jobs	Unlimited	30 build jobs
Storage	500 MB artifacts + 10 GB cache	10 GiB	200 MB workspace (no persistent storage)
macOS support	Yes (10x multiplier)	No on free tier	Yes (eat credits fast)
Windows support	Yes (2x multiplier)	Yes (Linux-only on free)	Yes
Self-hosted runners	Unlimited (free)	Unlimited (free)	Only on paid plans
Pricing model	Minutes + storage	Minutes + storage	Credits (drain faster on bigger machines)
Marketplace/ecosystem	✅ Extensive (20K+ actions)	⚠️ Smaller but growing	⚠️ Orbs marketplace
Credit card needed	❌ No (until you exceed limits)	❌ No	❌ No
Best for	GitHub-hosted projects, OSS	GitLab-hosted projects, enterprise-compliance	Performance-focused teams, advanced caching

GitHub Actions vs GitLab CI

GitLab CI offers 400 compute minutes/month on its free tier — one-fifth of GitHub’s private-repo allowance. However, GitLab’s free plan includes unlimited concurrent jobs (GitHub caps at 20), so if your builds are short and numerous, GitLab can be more efficient.

GitLab CI also has stronger built-in CI/CD security scanning (SAST, DAST, secret detection) and a mature Auto DevOps feature that detects your stack and generates a pipeline automatically.

Choose GitLab CI if: You’re already on GitLab, need built-in security scanning, or run many short parallel jobs that would benefit from unlimited concurrency.

Choose GitHub Actions if: Your code is on GitHub (the integration advantage is massive), you need Windows/macOS runners, or you want the broader ecosystem of pre-built actions.

GitHub Actions vs CircleCI

CircleCI uses a credit system: 30,000 free credits/month. A small Docker container runs at 1 credit/min (~3,000 min on small), while a medium machine runs at 2. It’s roughly comparable to 2,000 GitHub minutes for Light Linux workloads, but bigger machines drain credits faster.

CircleCI’s standout features are advanced caching (the restore_cache/save_cache system is more granular than GitHub’s actions/cache), SSH debugging on all plans (including free), and performance-focused runners that can be faster than GitHub’s standard runners.

Choose CircleCI if: Build performance is critical, you need SSH debugging on free tier, or you prefer the credit system which lets you pick machine sizes by the minute.

Choose GitHub Actions if: Integration with GitHub is important, you want unlimited public repo minutes, or you want the vast Marketplace ecosystem.

The Winner on Free Tier Breadth

GitHub Actions wins for open-source projects (unlimited minutes on public repos is unmatched) and for small teams already on GitHub. GitLab CI wins for GitLab-native projects and security scanning. CircleCI wins for performance-sensitive builds and debugging experience.

For the typical indie developer or small startup, GitHub Actions is the most cost-effective choice by a wide margin — especially if your repos are public.

---

6. Tips to Maximize the Free Tier

Here’s how to make the most of your 2,000 monthly minutes (and stay far away from overage charges).

Tip 1: Use Dependency Caching (This Is #1)

The single biggest minute-waster is re-downloading dependencies on every run. Use actions/cache or the built-in cache parameter on setup actions:

- uses: actions/setup-node@v4
  with:
    node-version: '20'
    cache: 'npm'  # auto-caches ~/.npm

For custom caching:

- name: Cache pip packages
  uses: actions/cache@v4
  with:
    path: ~/.cache/pip
    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
    restore-keys: |
      ${{ runner.os }}-pip-

Impact: A typical npm ci that takes 2 minutes drops to 10 seconds with caching. On 100 runs/month, that’s ~190 saved minutes — nearly 10% of your free quota (GitHub caching docs).

Tip 2: Optimize Your Trigger Conditions

Don’t run CI twice for the same change. Use paths and paths-ignore to skip irrelevant files:

on:
  push:
    branches: [main]
    paths-ignore:
      - '**.md'
      - 'docs/**'
      - '.gitignore'
      - 'LICENSE'

Impact: A docs-heavy repo running 200 monthly pushes might skip 40+ builds — saving ~200 minutes.

Tip 3: Use concurrency to Cancel Stale Runs

When you push a new commit to a PR, the previous workflow run is meaningless. Cancel it automatically:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

Impact: On a team that pushes frequently, this can save 30–50% of your total minutes (GitHub caching docs).

Tip 4: Keep Artifacts Clean

Artifacts (build outputs, test reports) accumulate and count against your 500 MB storage. Set a short retention period:

- uses: actions/upload-artifact@v4
  with:
    name: test-results
    path: test-results/
    retention-days: 7

Also set global retention in your repo settings: Settings → Actions → General → Artifact and log retention (default is 90 days; set to 7 or 14).

Tip 5: Use Matrix Builds Strategically

Matrix builds multiply every dimension you specify. Running on 3 OSes × 4 Node versions = 12 jobs. For private repos, this burns minutes 12× faster.

Strategies:

• Limit the matrix to what’s actually needed (e.g., skip macOS unless you specifically need it)
• Use include to add specific variants instead of cross-product:

strategy:
  matrix:
    os: [ubuntu-latest]
    node: [18, 20]
    include:
      - os: windows-latest
        node: 20
      - os: macos-latest
        node: 20

This runs 4 jobs instead of 9 (3 × 3).

Tip 6: Keep Jobs Short

• Use smaller runners when possible. Most builds don’t need the full ubuntu-latest 2-core. If you’re just running quick scripts, consider -arch=arm64 runners which are slightly cheaper.
• Split long jobs into parallel steps where possible.
• Pre-build Docker images with dependencies baked in instead of installing them in every run.
• Use timeout-minutes to cap runaway jobs:

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 10

Tip 7: Use act for Local Testing

act lets you run GitHub Actions workflows locally using Docker. You can iterate on your workflow files without pushing to GitHub and burning minutes on syntax errors.

act -j build-and-test  # run a specific job locally

Impact: Even just 5 failed pushes saved per month can reclaim 20–30 minutes.

Tip 8: Go Public When You Can

If your project isn’t business-critical, consider making it public. GitHub Actions gives unlimited free minutes for public repos — no quotas, no multipliers, no storage limits. Many developers keep their “production” code in a private monorepo but extract shared libraries as public packages with CI.

Tip 9: Set Up Billing Alerts

Go to Settings → Billing and plans → Plans and usage to monitor your minute consumption. Set a spending limit of $0 (which will simply stop workflows when you hit your free limit) or add a payment method with a small limit so you get warned rather than cut off mid-deploy.

Tip 10: Consider Self-Hosted Runners for Heavy Jobs

If you have a powerful machine on your local network or a cheap VPS, register it as a self-hosted runner. Self-hosted runners do not count against your 2,000-minute quota and have no concurrency limit. They’re perfect for:

• Long-running integration tests
• GPU-accelerated builds (model training, rendering)
• Jobs that need specific hardware or software not available on GitHub’s runners

Setup:

# On your machine, from repo Settings → Actions → Runners → Add runner
curl -O https://github.com/actions/runner/releases/download/v2.322.0/actions-runner-linux-x64-2.322.0.tar.gz
tar xzf actions-runner-linux-x64-*.tar.gz
./config.sh --url https://github.com/YOUR_USER/YOUR_REPO --token YOUR_TOKEN
./run.sh

Then reference it in your workflow:

jobs:
  build:
    runs-on: self-hosted
    # Will run on YOUR machine — free and unlimited

---

Free Tier Health Check: Is GitHub Actions Right for You?

Your Situation	Verdict
Open-source project	✅ Perfect. Unlimited minutes, unlimited contributors.
Solo dev, private repos, <50 builds/month	✅ Excellent. 2,000 min/mo is plenty for most indie projects.
Small team (3-5 devs), private repos	✅ Good. Average teams use 800–1,500 min/mo. You’ll likely stay under.
Growing team (10+ devs), heavy CI	⚠️ You may hit 2,000 min. Optimize with caching/concurrency first, then consider Team plan ($4/user/mo for 3,000 min) or self-hosted runners.
Need extensive matrix builds (Windows/macOS)	⚠️ Windows 2x and macOS 10x multipliers eat through minutes fast. Use macOS sparingly.
Enterprise compliance + security scanning	⚠️ Consider GitLab CI which offers better built-in SAST/DAST on its free tier.

---

Final Thoughts

GitHub Actions is the most accessible, well-integrated CI/CD platform available — especially if your code already lives on GitHub. The free tier is generous enough to support a small business, an open-source project, or a side project indefinitely, as long as you’re mindful of the 2,000-minute private repo ceiling.

|The 2026 pricing changes were a mixed bag: GitHub cut runner rates by up to 39% (good for overage pricing) but attempted to charge for self-hosted runners (reversed after backlash). For the vast majority of developers using the free tier, nothing meaningful changed — public repos remain unlimited, private repos keep their 2,000 minutes, and caches/artifacts continue to work. | |On the security front, GitHub published its Actions 2026 Security Roadmap in March 2026, introducing workflow dependency locking, a Layer 7 egress firewall, scoped secrets, and Actions Data Stream for CI/CD observability — all designed to harden the software supply chain. These features are rolling out gradually through late 2026 and are available on the free tier where they relate to public repository workflows.

The tl;dr: If your code is on GitHub, start with Actions. It’s already there, it’s free enough, and it only costs you time if you outgrow it.

---

Last updated: July 23, 2026. GitHub Actions pricing and free tier limits are subject to change. Always check docs.github.com/en/billing/managing-billing-for-github-actions for the latest information.

References

[1] GitHub Marketplace [2] GitHub Actions billing [3] CI Status [4] GitHub caching docs [5] act [6] docs.github.com/en/billing/managing-billing-for-github-actions