# What GitLab CI costs: hosted runners vs your own runners on Hetzner

> Compare GitLab.com compute minutes ($10.00 per 1,000, ×1 to ×12 by runner size) with your own GitLab runners on Hetzner Cloud: current prices, break-even points and a calculator.

Source: https://managerunners.com/gitlab-ci-cost/ (with an interactive calculator). Prices as of 19 October 2026, net of VAT.

On GitLab.com, job minutes beyond those your plan's quota covers cost $10.00 per 1,000 on the default small Linux runner and up to $120.00 per 1,000 on 2xlarge. The cheapest always-on Hetzner server in Germany/Finland costs $10.59 a month for the small size (CX33) and $630.09 a month for the 2xlarge size (CCX53), including IPv4. With the Manage Runners Basic plan ($5.99 a month), an always-on runner with runner-matched RAM and one job per server costs less than hosted minutes from about 1,254 to 5,708 job minutes a month beyond those your quota covers, depending on size and server class.

Scope: Standard projects only. GitLab's lower cost factors for public projects in GitLab for Open Source, their public forks and community contributions are not included. Jobs are assumed to take as long on a Hetzner server as on GitLab's runner; no benchmark has been run. Prices are net, without VAT ([GitLab's project type discounts](https://docs.gitlab.com/ci/pipelines/compute_minutes/#project-type-discounts)).

## How GitLab.com bills CI

| GitLab tier | Compute minutes included per month |
| --- | --- |
| Free | 400 |
| Premium | 10,000 |
| Ultimate | 50,000 |

| Runner | vCPU | Memory | Cost factor | Per 1,000 job minutes beyond those the quota covers |
| --- | --- | --- | --- | --- |
| small (`saas-linux-small-amd64`) | 2 | 8 GB | 1 | $10.00 |
| medium (`saas-linux-medium-amd64`) | 4 | 16 GB | 2 | $20.00 |
| large (`saas-linux-large-amd64`), Premium and Ultimate only | 8 | 32 GB | 3 | $30.00 |
| xlarge (`saas-linux-xlarge-amd64`), Premium and Ultimate only | 16 | 64 GB | 6 | $60.00 |
| 2xlarge (`saas-linux-2xlarge-amd64`), Premium and Ultimate only | 32 | 128 GB | 12 | $120.00 |

- Only a job's running time counts, not the time it waits in the queue.
- Additional minutes are used after the monthly quota and carry over.
- Jobs on self-managed runners use no compute minutes.
- When the minutes are used up, hosted runners stop picking up new jobs until the next month or a purchase.

## What a Hetzner runner costs

- **Cost-Optimized (CX)**, shared vCPUs. Hetzner: "Extremely cost-effective · Low CPU usage".
- **Regular Performance (CPX)**, shared vCPUs. Hetzner: "Inexpensive due to shared resources · Low to medium CPU usage".
- **General Purpose (CCX)**, dedicated vCPUs. Hetzner: "Dedicated vCPUs · Constantly high CPU usage".

Hetzner currently has limited availability for its Cost-Optimized (CX) series. Stock changes often, so a CX server may not be available to order in every location at any given time.

### Germany/Finland

Monthly price, always on, including IPv4.

| GitLab size | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| small | CX33 (4 vCPU, 8 GB): $10.59 / €8.99 | CPX32 (4 vCPU, 8 GB): $42.59 / €35.99 | CCX13 (2 vCPU, 8 GB): $51.09 / €43.49 |
| medium | CX43 (8 vCPU, 16 GB): $19.09 / €16.49 | CPX42 (8 vCPU, 16 GB): $82.59 / €69.99 | CCX23 (4 vCPU, 16 GB): $102.09 / €86.49 |
| large | CX53 (16 vCPU, 32 GB): $35.59 / €29.99 | CPX62 (16 vCPU, 32 GB): $153.59 / €130.49 | CCX33 (8 vCPU, 32 GB): $163.59 / €138.99 |
| xlarge | — | — | CCX43 (16 vCPU, 64 GB): $326.09 / €276.49 |
| 2xlarge | — | — | CCX53 (32 vCPU, 128 GB): $630.09 / €533.99 |

### USA

Monthly price, always on, including IPv4.

| GitLab size | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| small | — | CPX31 (4 vCPU, 8 GB): $74.09 / €62.99 | CCX13 (2 vCPU, 8 GB): $51.59 / €43.99 |
| medium | — | CPX41 (8 vCPU, 16 GB): $142.09 / €120.99 | CCX23 (4 vCPU, 16 GB): $103.59 / €87.99 |
| large | — | CPX51 (16 vCPU, 32 GB): $280.09 / €238.49 | CCX33 (8 vCPU, 32 GB): $166.59 / €141.49 |
| xlarge | — | — | CCX43 (16 vCPU, 64 GB): $330.09 / €279.99 |
| 2xlarge | — | — | CCX53 (32 vCPU, 128 GB): $636.09 / €538.99 |

### Singapore

Monthly price, always on, including IPv4.

| GitLab size | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| small | — | CPX32 (4 vCPU, 8 GB): $58.59 / €49.49 | CCX13 (2 vCPU, 8 GB): $64.09 / €54.49 |
| medium | — | CPX42 (8 vCPU, 16 GB): $110.59 / €93.99 | CCX23 (4 vCPU, 16 GB): $128.59 / €108.99 |
| large | — | CPX62 (16 vCPU, 32 GB): $203.59 / €172.49 | CCX33 (8 vCPU, 32 GB): $206.59 / €174.99 |
| xlarge | — | — | CCX43 (16 vCPU, 64 GB): $402.59 / €341.49 |
| 2xlarge | — | — | CCX53 (32 vCPU, 128 GB): $770.09 / €652.49 |

## Break-even

Germany/Finland, USD, always on, with runner-matched RAM and one job per server. Additional job minutes beyond those the quota covers, per month, at which your own runner costs the same as hosted minutes.

| GitLab size | Per 1,000 job minutes | Cost-Optimized (CX): additional job minutes beyond those the quota covers | Regular Performance (CPX): additional job minutes beyond those the quota covers | General Purpose (CCX): additional job minutes beyond those the quota covers |
| --- | --- | --- | --- | --- |
| small | $10.00 | CX33: $10.59/month, 1,658 min with Basic (1,059 without) | CPX32: $42.59/month, 4,858 min with Basic (4,259 without) | CCX13: $51.09/month, 5,708 min with Basic (5,109 without) |
| medium | $20.00 | CX43: $19.09/month, 1,254 min with Basic (955 without) | CPX42: $82.59/month, 4,429 min with Basic (4,129 without) | CCX23: $102.09/month, 5,404 min with Basic (5,104 without) |
| large | $30.00 | CX53: $35.59/month, 1,386 min with Basic (1,186 without) | CPX62: $153.59/month, 5,319 min with Basic (5,120 without) | CCX33: $163.59/month, 5,653 min with Basic (5,453 without) |
| xlarge | $60.00 | — | — | CCX43: $326.09/month, 5,535 min with Basic (5,435 without) |
| 2xlarge | $120.00 | — | — | CCX53: $630.09/month, 5,301 min with Basic (5,251 without) |

The table counts job minutes beyond those your quota covers. For your total job minutes, add the quota divided by the runner's cost factor: Premium's 10,000 compute minutes cover 5,000 medium job minutes.

## Worked examples

Germany/Finland, USD. The schedule runs 5 days a week, 12 hours a day.

### Side project

GitLab Free, 1,500 job minutes a month on the small runner, one job at a time. GitLab: $11.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + Basic | 1 × CX33: $16.58 (+51%) | 1 × CPX32: $48.58 (+342%) | 1 × CCX13: $57.08 (+419%) |
| 5 days a week, 12 hours a day + Pro | 1 × CX33: $24.66 (+124%) | 1 × CPX32: $38.00 (+245%) | 1 × CCX13: $41.53 (+278%) |

GitLab hosted runners ($11.00) are cheaper than every Hetzner option; the cheapest is 1 × CX33 always on with Basic at $16.58.

### Small team

GitLab Free, 5,000 job minutes a month on the small runner, one job at a time. GitLab: $46.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + Basic | 1 × CX33: $16.58 (−64%) | 1 × CPX32: $48.58 (+5.6%) | 1 × CCX13: $57.08 (+24%) |
| 5 days a week, 12 hours a day + Pro | 1 × CX33: $24.66 (−46%) | 1 × CPX32: $38.00 (−17%) | 1 × CCX13: $41.53 (−9.7%) |

The cheapest option is 1 × CX33 always on with Basic: $16.58, 64% less than GitLab's $46.00.

### Product team

GitLab Premium, 30,000 job minutes a month on the medium runner, up to 6 jobs in parallel on one server per class, twice the RAM of GitLab's medium runner. GitLab: $500.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + Basic | 1 × CX53: $41.58 (−92%) | 1 × CPX62: $159.58 (−68%) | 1 × CCX33: $169.58 (−66%) |
| 5 days a week, 12 hours a day + Pro | 1 × CX53: $35.09 (−93%) | 1 × CPX62: $84.25 (−83%) | 1 × CCX33: $88.41 (−82%) |

When a server runs 6 jobs at once, each gets about 2.7 vCPU and 5.3 GB RAM on CX53 and CPX62, or 1.3 vCPU and 5.3 GB RAM on CCX33, compared with GitLab's dedicated 4 vCPU and 16 GB per job. The cheapest option is 1 × CX53 on a schedule with Pro: $35.09, 93% less than GitLab's $500.00.

### Heavy builds

GitLab Premium, 10,000 job minutes a month on the xlarge runner, one job at a time. GitLab: $500.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + Basic | — | — | 1 × CCX43: $332.08 (−34%) |
| 5 days a week, 12 hours a day + Pro | — | — | 1 × CCX43: $156.12 (−69%) |

The cheapest option is 1 × CCX43 on a schedule with Pro: $156.12, 69% less than GitLab's $500.00.

### Inside the quota

GitLab Premium, 8,000 job minutes a month on the small runner, one job at a time. GitLab: $0.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + Basic | 1 × CX33: $16.58 | 1 × CPX32: $48.58 | 1 × CCX13: $57.08 |
| 5 days a week, 12 hours a day + Pro | 1 × CX33: $24.66 | 1 × CPX32: $38.00 | 1 × CCX13: $41.53 |

The minutes fit in the quota, so GitLab hosted runners cost nothing extra and are cheaper than any server.

### Bursty team

GitLab Premium, 20,000 job minutes a month on the medium runner, up to 8 jobs in parallel for 3 hours a day on 5 days a week and 2 otherwise; autoscaling adds burst runners for the peak. GitLab: $300.00 a month.

| Your own runners | Cost-Optimized (CX) | Regular Performance (CPX) | General Purpose (CCX) |
| --- | --- | --- | --- |
| Always on + burst + Pro | 2 × CX43 + 6 burst: $73.90 (−75%) | 2 × CPX42 + 6 burst: $253.84 (−15%) | 2 × CCX23 + 6 burst: $309.06 (+3%) |
| 5 days a week, 12 hours a day + burst + Pro | 2 × CX43 + 6 burst: $52.31 (−83%) | 2 × CPX42 + 6 burst: $158.18 (−47%) | 2 × CCX23 + 6 burst: $190.63 (−36%) |

The cheapest option is 2 × CX43 + 6 burst with the anchor on a schedule and Pro: $52.31, 83% less than GitLab's $300.00. Sized for the peak without autoscaling, 8 × CX43 on a schedule with Pro cost $86.27.

## When GitLab hosted runners are cheaper or better

- Usage inside the included quota (400 compute minutes on Free, 10,000 on Premium, 50,000 on Ultimate): extra hosted minutes cost nothing, and any server costs more.
- Low usage with an always-on server: below about 1,658 small-runner job minutes a month beyond those the quota covers, the cheapest always-on match (CX33) with the Basic plan costs more than the minutes. A shorter schedule can lower the server cost; use the calculator to compare.
- Bursty pipelines: GitLab provisions a VM for every job, so many jobs in parallel cost the same as running them one after another. A fixed set of servers, which this calculator counts unless autoscaling is on, queues jobs beyond its job slots or has to be sized for the peak. Autoscaling on the Pro plan adds burst runners to a busy GitLab runner, but they take a few minutes to start, each is billed for at least one started hour, and the runner it is set up on always runs.
- macOS, Windows and GPU jobs: GitLab offers hosted runners for them. Hetzner Cloud has no macOS or GPU servers, and Manage Runners creates Linux runners only.
- Arm: GitLab offers Arm64 hosted runners. Hetzner's Arm servers (CAX) work with Manage Runners; this page compares x86 only.
- Nothing to operate: your own runners come with a Hetzner account, an API token, IP addresses and servers that can run out of disk. Manage Runners automates setup and updates, not the account.
- Isolation: a hosted runner is a fresh VM for every job. A persistent runner reuses its server, which keeps caches warm but separates jobs less, especially with the shell or Docker-in-Docker executors.
- Outside Europe: Cost-Optimized (CX) servers are offered only in Germany/Finland.

## When your own runners on Hetzner are cheaper or better

- Steady usage above the break-even in the table above.
- Large runners without a paid GitLab plan: GitLab offers large and bigger runners on Premium and Ultimate only; your own runners work with any GitLab tier.
- Fixed IP addresses for allow-lists: Manage Runners keeps a runner's IP addresses across pause and resume.
- Data location: servers run in your own Hetzner project in Germany, Finland, the USA or Singapore.
- Warm caches: a persistent server keeps Docker layers and build caches between jobs.
- Schedules: pausing servers outside working hours stops Hetzner's server billing for those hours.

## Assumptions and method

- Prices are net, without VAT, as of 19 October 2026. Hetzner's prices are its own USD and EUR list prices. GitLab's and Manage Runners' USD prices are converted to EUR at the ECB reference rate of 16 October 2026 (1 EUR = 1.1253 USD) and marked as converted.
- Each GitLab size is matched to the cheapest Hetzner type in each class with at least the runner's memory, or 2 or 4 times it with a larger server size; x86 only. Cost-Optimized and Regular Performance servers have shared vCPUs, General Purpose servers dedicated ones.
- Jobs are assumed to take as long on a Hetzner server as on GitLab's runner; no benchmark has been run.
- Standard projects only. GitLab's lower cost factors for public projects in GitLab for Open Source, their public forks and community contributions are not included.
- Each server runs one job at a time unless you change it. Running several jobs on a larger server is common, and the calculator supports it with Server size and Jobs per server; the jobs then share the server's CPU and RAM.
- Hetzner bills each server by the started hour, up to its monthly price. An always-on server costs its monthly price. A schedule deletes the server after every window, so each window is billed on its own, rounded up to whole hours; the monthly cap never applies across windows. The few minutes a server takes to start are ignored, and a month averages 730 hours.
- With autoscaling, the anchor, sized for the baseline jobs in parallel, always runs or runs on its schedule. Burst runners of the same server type cover the rest of the peak, at the same time on every peak day and only while the anchor runs. Autoscaling works with GitLab runners only.
- Each burst runner is a new server for every peak window. The calculator counts the peak hours plus 0.25 h, rounded up to whole hours and up to the monthly price. The 0.25 h is an allowance for the few minutes to start and for scale-in, which starts draining a burst runner near the end of a paid hour. Hetzner bills started hours, so draining a long job into a further hour costs that hour too; this is not counted.
- Every runner keeps its primary IPv4 address ($0.60 / €0.50 a month), also while paused. Burst runners are deleted with their addresses, so they pay IPv4 only for their billed hours.
- The Manage Runners plan is counted once per organisation: Basic when runners are always on, Pro when they use a schedule or autoscaling. Choose "I run GitLab Runner myself" to leave it out.
- GitLab seat prices are not counted, because your own runners don't change them. GitLab's minutes are counted at the steady-state price; packs of 1,000 carry over.
- Not counted: Hetzner traffic beyond the included volume, a cache bucket in object storage, and your own time.

```text
GitLab
  compute minutes  = job minutes × cost factor
  extra minutes    = max(0, compute minutes − quota)
  GitLab per month = extra minutes ÷ 1,000 × price per 1,000

Hetzner, per server
  server type      = cheapest in its class with RAM ≥ runner RAM × server size
  always on        = monthly price
  on a schedule    = windows × min(ceil(hours per day) × hourly price, monthly price)
  windows          = days per week × 52 ÷ 12
  per month        = servers × (server + IPv4)
  servers          = ceil(parallel jobs ÷ jobs per server)
  running hours    = 730 always on, hours per day × windows on a schedule

With autoscaling, per class
  anchor servers   = ceil(baseline jobs ÷ jobs per server)
  burst servers    = ceil(parallel jobs ÷ jobs per server) − anchor servers
  billed hours     = ceil(peak hours per day + 0.25)
  peak windows     = peak days per week × 52 ÷ 12
  burst server     = peak windows × min(billed hours × hourly price, monthly price)
  burst IPv4       = IPv4 per month ÷ 730 × billed hours × peak windows
  per month        = anchor servers × (server + IPv4)
                     + burst servers × (burst server + burst IPv4)

Your own runners   = Hetzner per month + Manage Runners plan
Break-even         = (quota + own runners ÷ price per compute minute) ÷ cost factor   [job minutes]
Job minutes the quota covers = quota ÷ cost factor
Job slots busy     = job minutes ÷ capacity minutes
  capacity minutes = servers × running hours × jobs per server × 60
  with autoscaling = (anchor servers × running hours + burst servers × peak hours per day × peak windows)
                     × jobs per server × 60
```

## FAQ

### How much do GitLab CI minutes cost?

GitLab.com includes 400 compute minutes a month on Free, 10,000 on Premium and 50,000 on Ultimate, per top-level group. Additional minutes cost $10.00 per 1,000, sold in packs of 1,000 that carry over. A job uses its running time multiplied by the runner's cost factor: 1 for small, 2 for medium, 3 for large, 6 for xlarge, 12 for 2xlarge. So 1,000 job minutes beyond those the quota covers cost $10.00 to $120.00.

### Do self-hosted runners use compute minutes?

No. Jobs on your own runners, including runners set up by Manage Runners, don't use GitLab compute minutes, and they keep running when the quota is used up.

### What happens when I run out of compute minutes?

GitLab's hosted runners stop picking up new jobs for the namespace; jobs already running continue until the namespace is 1,000 minutes over its quota. Usage resets on the 1st of each month, and purchased minutes are used once the monthly quota is used up.

### How much does a GitLab runner on Hetzner cost per month?

An always-on server matching GitLab's small runner costs $10.59 (CX33, shared vCPUs) or $42.59 (CPX32, shared vCPUs) or $51.09 (CCX13, dedicated vCPUs) a month in Germany/Finland, including the $0.60 IPv4 address. Hetzner bills each server by the hour up to that monthly price. Manage Runners adds its plan: Basic at $5.99, or Pro at $19.90 for schedules and autoscaling.

### Is a paused runner free?

The server is: Manage Runners deletes it when you pause the runner, so Hetzner stops billing it. The runner's primary IPv4 address is kept, so the runner gets the same address when it resumes, and it costs $0.60 (€0.50) a month.

### Which Hetzner server matches GitLab's medium runner?

GitLab's medium runner has 4 vCPUs and 16 GB of memory. Matching memory first, the equivalents are CX43 (Cost-Optimized, 8 shared vCPUs), CPX42 (Regular Performance, 8 shared vCPUs), CCX23 (General Purpose, 4 dedicated vCPUs), each with 16 GB. Shared vCPUs vary in speed with other tenants on the host; this page makes no performance comparison.

## Sources

- [GitLab pricing](https://about.gitlab.com/pricing/), seen 19 October 2026
- [GitLab compute minutes FAQ](https://about.gitlab.com/pricing/faq-compute-minutes/), seen 19 October 2026
- [GitLab docs: compute minutes and cost factors](https://docs.gitlab.com/ci/pipelines/compute_minutes/), seen 19 October 2026
- [GitLab docs: purchased compute minutes](https://docs.gitlab.com/subscriptions/gitlab_com/compute_minutes/), seen 19 October 2026
- [GitLab docs: hosted runners on Linux](https://docs.gitlab.com/ci/runners/hosted_runners/linux/), seen 19 October 2026
- [GitLab docs: instance runner compute minutes](https://docs.gitlab.com/ci/pipelines/instance_runner_compute_minutes/), seen 19 October 2026
- [Hetzner price list (live_data_prices.json, used by hetzner.com)](https://www.hetzner.com/_resources/app/data/app/live_data_prices.json), seen 19 October 2026
- [Hetzner docs: price adjustment of 15 June 2026](https://docs.hetzner.com/general/infrastructure-and-availability/price-adjustment/), seen 19 October 2026
- [Hetzner Cloud plans](https://www.hetzner.com/cloud/), seen 19 October 2026
- [Hetzner docs: billing FAQ](https://docs.hetzner.com/cloud/billing/faq/), seen 19 October 2026
- [Hetzner docs: IPv4 pricing](https://docs.hetzner.com/general/infrastructure-and-availability/ipv4-pricing/), seen 19 October 2026
- [ECB euro foreign exchange reference rates](https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/index.en.html), seen 19 October 2026