Woodpecker CI vs GitHub Actions in 2026: Self-Hosted CI That Just Works

GitHub Actions is woven into every GitHub repo. It is free for public repos and generous for small private teams. Then your CI pipeline gets serious — multiple jobs, parallel matrix builds, frequent commits — and the minute counter starts climbing.

At $0.008 per Linux minute, 10,000 extra minutes above the free tier costs $80/month. 50,000 extra minutes costs $400/month. Windows runners cost $0.016/min and macOS runners cost $0.08/min. A cross-platform test matrix can burn through minutes fast.

Woodpecker CI is a self-hosted alternative that runs your Docker-based pipelines on your own infrastructure. Free software, Apache 2.0 license, roughly 50MB of server RAM. This comparison works through when that trade-off makes sense — and what you give up.

What Woodpecker CI Actually Is

Woodpecker was forked from Drone CI in 2021 when Harness acquired Drone and moved it toward a paid enterprise model. The fork kept the simple Docker-container-per-step pipeline model and has developed independently since, accumulating around 4,000 GitHub stars.

The architecture is straightforward: a lightweight Go server, a Vue.js UI, and agents running on any machine with Docker. Pipelines are defined in YAML. Each step runs in a Docker container image you specify. The server uses around 50MB of RAM at rest.

Woodpecker connects to GitHub, GitLab, Gitea, and Forgejo via webhooks and OAuth. Push to your repo, Woodpecker picks up the event, runs the pipeline, reports status back. The basic loop is identical to what you get with GitHub Actions.

Woodpecker pricing:

• ▸Self-Hosted: Free, Apache 2.0 license (no AGPL complications)
• ▸No hosted SaaS option exists — you run it yourself
• ▸Infrastructure cost: whatever your server costs

GitHub Actions Pricing Breakdown

GitHub Actions pricing has two components: included minutes per plan, and per-minute overage charges.

Included free minutes per month (private repos):

• ▸GitHub Free: 2,000 minutes
• ▸GitHub Pro: 3,000 minutes
• ▸GitHub Team: 3,000 minutes
• ▸GitHub Enterprise: 50,000 minutes

Overage rates (per minute):

• ▸Linux (ubuntu-latest): $0.008
• ▸Windows: $0.016 (2x Linux)
• ▸macOS: $0.08 (10x Linux)
• ▸Larger runners (4-core, 8-core, etc.): 2x–10x base rate

Artifact and cache storage:

• ▸$0.25/GB/month above the free included storage
• ▸GitHub Free: 500MB included; GitHub Pro: 1GB; Team: 2GB; Enterprise: 50GB

Cost examples at 10,000 total Linux minutes/month:

• ▸GitHub Free team: 8,000 billable minutes × $0.008 = $64/month
• ▸GitHub Team: 7,000 billable minutes × $0.008 = $56/month
• ▸GitHub Enterprise: 0 billable minutes (within 50,000 included)

Cost examples at 30,000 total Linux minutes/month:

• ▸GitHub Free team: $224/month
• ▸GitHub Team: $216/month
• ▸GitHub Enterprise: 0 (still within 50,000)

Once you add Windows or macOS runners for cross-platform testing, costs multiply quickly. A matrix job running on ubuntu + windows + macos costs roughly 1 + 2 + 10 = 13 minute-equivalents per actual minute of run time.

The Break-Even Math

The question is: at what CI usage volume does paying for a VPS to run Woodpecker beat paying GitHub Actions overage?

Woodpecker server sizing:

Break-even at $0.008/min Linux (GitHub Free tier):

• ▸At $6/month VPS: break-even is ~1,750 overage minutes/month (total ~3,750 min)
• ▸At $15/month VPS: break-even is ~2,875 overage minutes/month (total ~4,875 min)
• ▸At $30/month VPS: break-even is ~5,750 overage minutes/month (total ~7,750 min)

If your team burns 20,000 Linux minutes/month on GitHub Free, that is 18,000 billable minutes × $0.008 = $144/month. A $15 VPS running Woodpecker costs $15/month. The gap is obvious.

The math changes for GitHub Enterprise users with 50,000 included minutes, self-hosting is harder to justify unless you are using Windows/macOS runners heavily or exceeding 50,000 minutes.

Feature Comparison

Pipeline Configuration

Both systems use YAML. The syntax differs.

GitHub Actions (.github/workflows/build.yml):

```yaml

jobs:

build:

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v4

- name: Run tests

run: npm test

```

Woodpecker CI (.woodpecker.yml):

```yaml

steps:

- name: build

image: node:20

commands:

- npm install

- npm test

```

Woodpecker's model is more explicit: you pick the exact Docker image for each step. No abstraction over the runner environment. This is more verbose for simple cases but eliminates the "what's inside ubuntu-latest today?" uncertainty.

Plugin Ecosystem

GitHub Actions: 20,000+ actions in the marketplace. actions/checkout, actions/setup-node, actions/cache, docker/build-push-action, almost every tool has an official or community action.

Woodpecker: smaller community plugin directory. Covers common cases (Docker build, Slack notify, SSH deploy) but lacks the breadth. If you depend on specific GitHub Actions plugins, particularly third-party SaaS integrations, check whether a Woodpecker equivalent exists before switching.

Many pipelines can substitute plugins with raw Docker commands. Instead of actions/setup-node@v4, you use image: node:20. This works for language runtimes and standard tooling. It gets harder for cloud provider integrations (AWS, GCP, Azure) or specialized services.

Caching

GitHub Actions has actions/cache with automatic path caching tied to cache keys. It integrates with GitHub's object storage and generally just works.

Woodpecker supports caching via volumes or the woodpecker-cache plugin, but it requires more configuration. Cache hits on Woodpecker are typically to local disk (faster) rather than a remote object store (more setup). For monorepos with heavy dependency caching, test the Woodpecker setup before committing.

Matrix Builds

GitHub Actions has first-class matrix support for cross-version and cross-platform testing:

```yaml

strategy:

matrix:

node: [18, 20, 22]

os: [ubuntu-latest, windows-latest]

```

Woodpecker supports matrix builds but with less flexibility. Simple version matrices work. Complex dynamic matrices or conditional inclusions/exclusions require workarounds. If cross-platform matrix testing is central to your workflow (common in open-source libraries), this is a real limitation.

Secrets and Environment Variables

GitHub Actions: repository secrets, environment secrets, organization secrets, all manageable from the GitHub UI with OIDC support for cloud provider authentication (no long-lived credentials needed for AWS/GCP/Azure).

Woodpecker: per-repo and organization-level secrets through the Woodpecker UI or API. No OIDC integration, you use long-lived service account credentials for cloud deployments. For security-sensitive workflows, this is a meaningful difference.

Scalability

GitHub Actions scales automatically. Submit 100 jobs simultaneously and GitHub queues and runs them across their fleet. You pay for what you use.

Woodpecker scales by adding agent nodes, any machine running the Woodpecker agent binary. Horizontal scaling is straightforward but requires provisioning machines. Burst capacity (unexpected CI spikes) requires either pre-provisioned slack capacity or manual intervention.

Migration: GitHub Actions to Woodpecker

If you decide to migrate, the process is:

1. Deploy Woodpecker. Docker Compose or Kubernetes Helm chart
2. Connect your Git forge. GitHub OAuth app + webhook configuration
3. Convert workflows, translate .github/workflows/*.yml to .woodpecker.yml. Steps that used marketplace actions become explicit Docker image steps.
4. Replace caching, configure Woodpecker volumes or the cache plugin
5. Migrate secrets, re-enter secrets in the Woodpecker UI
6. Run in parallel, trigger both systems for a sprint before cutting over
7. Archive old workflows, remove .github/workflows/ files

The conversion is straightforward for pipelines that lint, test, and build in Docker containers. It gets harder for pipelines that lean heavily on marketplace actions, GitHub-specific integrations (GitHub Packages, GitHub Releases API), or OIDC-based cloud authentication.

Who Should Use What

Stay on GitHub Actions when:

• ▸Your CI usage stays within the free tier
• ▸You rely on specific marketplace actions with no Woodpecker equivalent
• ▸You need cross-platform matrix builds on Windows and macOS runners
• ▸Your team uses OIDC-based cloud authentication in CI
• ▸You want zero infrastructure to manage
• ▸You are a GitHub Enterprise customer with 50,000 included minutes

Consider Woodpecker CI when:

• ▸You are paying significant monthly overage on GitHub Actions Linux runners
• ▸Your pipelines run standard Docker-based steps that translate cleanly
• ▸You use Gitea or Forgejo (where Woodpecker integration is native)
• ▸You want CI that runs entirely inside your network, no code sent to GitHub's runner fleet
• ▸You are self-hosting your entire dev stack (Forgejo + Woodpecker + MinIO + Mattermost pattern)
• ▸You want an Apache 2.0 licensed CI you can embed or customize without license constraints

The hybrid approach: Keep GitHub Actions for workflows that genuinely need marketplace actions or cross-platform matrices. Add Woodpecker for the bulk of your Linux-only build-and-test pipelines. Route jobs by trigger or workflow file, keep expensive runners reserved for what truly needs them.

What You Actually Give Up

Before switching, be honest about what Woodpecker does not have:

• ▸No Windows or macOS runners. Linux Docker only
• ▸No OIDC cloud auth, long-lived credentials for AWS/GCP/Azure
• ▸Smaller plugin ecosystem, some integrations require custom steps
• ▸No Dependabot-equivalent, dependency update PRs are a separate tool
• ▸No GitHub-native features, merge queue, branch protection rules, deploy environments all stay GitHub-side
• ▸Self-hosting operational overhead, upgrades, monitoring, disk management are yours

These are real costs. The CI minutes savings need to offset both the VPS bill and the operational time.

Bottom Line

GitHub Actions is the right default for teams that fit within the free tier or use GitHub Enterprise's included minutes. The integration with GitHub's ecosystem, the marketplace depth, and the zero-maintenance model are genuinely valuable.

Woodpecker CI earns its place when the GitHub Actions bill is noticeable and your pipelines are primarily Linux Docker builds. The Apache 2.0 license, minimal resource footprint, and clean YAML config make it a practical choice. If you are already self-hosting your git forge with Gitea or Forgejo, Woodpecker is the obvious CI companion.

Run the numbers on your own CI usage. If you are burning 20,000+ Linux minutes per month above the free tier, the economics usually favor Woodpecker. If you need macOS runners or heavy marketplace action dependencies, the calculation shifts back toward Actions.