Skip to content

Home / Blog / Runners and limits

GitHub Actions limits: every quota in one table, and which can change

Every GitHub Actions limit in one place: job and workflow time, concurrency, runner memory and disk, cache, storage and API rates, and whether each can change.

GitHub Actions limits a job to 6 hours on its hosted runners and a workflow run to 35 days, a matrix to 256 jobs and a concurrency group to 100 queued runs. Standard runners run 20 jobs at once on GitHub Free and 500 on Enterprise. A repository’s cache holds 10 GB by default, and a repository’s GITHUB_TOKEN may make 1,000 API requests an hour. GitHub says support can raise some of these, and lists no increase for the rest.

In short
  • A job on a GitHub-hosted runner stops at 6 hours, a workflow run at 35 days, and a matrix may make 256 jobs.
  • Standard runners run 20 jobs at once on Free, 40 on Pro, 60 on Team and 500 on Enterprise.
  • A private-repository Linux runner has 2 vCPU, 8 GB of memory and 14 GB of SSD, and a repository's cache holds 10 GB by default.
  • GITHUB_TOKEN may make 1,000 API requests an hour per repository, and the cache accepts 200 uploads a minute.
  • GitHub says support can raise concurrency, re-runs and the trigger event rate, and that it cannot raise storage limits.

This post is every one of those limits in one place, with whether GitHub says it can change and the GitHub page each row was read from. The figures were read from GitHub’s documentation on 15 November 2026, and GitHub says on its limits page that they are subject to change. Where a row is not on GitHub’s limits page, the page it came from is named in the last column.

How long can a job, a workflow and a wait last?

LimitFigureCan it change?Where GitHub says it
Job execution time, GitHub-hosted runners6 hoursNot listed as raisableActions limits
Job execution time, ubuntu-slim (single CPU)15 minutesNot listed as raisableGitHub-hosted runners reference
Job execution time, self-hosted runners5 daysNot listed as raisableActions limits
Job queue time, self-hosted runners24 hoursNot listed as raisableActions limits
Workflow run time, including waiting and approval35 daysNot listed as raisableActions limits
Waiting on an environment approval30 daysNot listed as raisableActions limits
timeout-minutes on a step360 minutes at mostSet by you, up to the maximumWorkflow syntax
timeout-minutes on a job360 by defaultSet by you; the runner's own limit still appliesWorkflow syntax

Every job on a GitHub-hosted runner stops at 6 hours, and the job is terminated and marked failed when it gets there. The one exception is the single-CPU runner, ubuntu-slim, which stops a job at 15 minutes. A workflow run as a whole may last 35 days, and that period includes time spent waiting and on approvals, and an environment approval may hold a run for up to 30 days of that time.

You can set a lower limit yourself with timeout-minutes. It defaults to 360 on a job, and if you set it higher than the runner’s own limit, GitHub says the job is cancelled when the runner’s limit is met instead. A job that reaches its execution limit is terminated and fails, and a workflow run that reaches 35 days is cancelled; what a cancellation looks like in a log is covered in the post on “The operation was canceled”. On runners.io a job may run for 60 minutes, which is shorter than GitHub’s six hours, as the limits page says.

How many jobs can run at once?

Runner and planTotal jobs at oncemacOS jobs at onceGPU jobs at once
Standard runners, GitHub Free205Not applicable
Standard runners, GitHub Pro405Not applicable
Standard runners, GitHub Team605Not applicable
Standard runners, GitHub Enterprise50050Not applicable
Larger runners, GitHub Team1,0005100
Larger runners, GitHub Enterprise1,00050100

GitHub says Support can increase job concurrency, by a support ticket. The macOS figure is shared between standard and larger runners, so a team using both counts them together. A job that waits is not always waiting for one of these limits, and the post on why jobs wait for a runner separates the causes. The number of jobs our plan runs at once is on our limits page.

A larger runner has a concurrency of its own, set when it is created. GitHub gives 1,000 as the usual maximum for Linux CPU runners and says the figure varies by type, and ten static IP addresses per enterprise and organization, both raisable by a support ticket. Separately, a concurrency group allows one running and one pending run unless you add queue: max, which GitHub announced on 7 May 2026 and which allows up to 100 queued runs in the group. GitHub’s limits page says runs beyond that are rejected.

How much memory, CPU and disk does a hosted runner have?

RunnervCPUMemorySSD
Linux x64, private repository (ubuntu-latest)28 GB14 GB
Linux x64, public repository (ubuntu-latest)416 GB14 GB
Linux x64, ubuntu-slim, either15 GB14 GB
Windows x64, private repository28 GB14 GB
Windows x64, public repository416 GB14 GB
macOS Intel, either414 GB14 GB
macOS arm64 (M1), either37 GB14 GB

These are the standard runners, and the label decides which you get, not a setting. The same ubuntu-latest gets 2 vCPU and 8 GB in a private repository and 4 vCPU and 16 GB in a public one, with the same 14 GB of SSD in both. GitHub’s reference does not say how much of that disk is free when a job starts, and the posts on running out of disk and on running out of memory cover what to do when either is the limit. The way past a hardware limit is a larger runner, which GitHub bills at its own per-minute rates on its runner pricing page; the runner size guide says when that pays.

How big can the cache be, and how fast can it be used?

LimitFigureCan it change?Where GitHub says it
Cache size per repository10 GB by defaultYes: admins can raise it; use above 10 GB is billedDependency caching reference
Age of an entry that is not accessed7 days by default, then removedYes: admins can set a retention limitGitHub changelog, 20 November 2025
Cache uploads200 a minute per repositoryNot listed as raisableActions limits
Cache downloads1,500 a minute per repositoryNot listed as raisableActions limits
Cache deletes400 a minute per repositoryNot listed as raisableActions limits

Size and age are the two cache limits GitHub lets administrators change. An enterprise owner, an organization owner or a repository administrator can raise the size, and anything stored above 10 GB is billed to the account; GitHub’s changelog of 20 November 2025 describes a retention limit in days beside it. The three rates are not listed as raisable. When one is exceeded, GitHub says the next uploads or downloads fail until it resets, and that the time until it resets is in the Retry-After header, which is what the 429 error post is about. How scoping, eviction and keys work is in the cache limit post, and our own cache is described in the Actions cache documentation.

How much do artifacts and logs get, by plan?

PlanArtifact storageIncluded compute a monthCustom image storage
GitHub Free500 MB$12 USDNot applicable
GitHub Pro1 GB$18 USDNot applicable
GitHub Free for organizations500 MB$12 USDNot applicable
GitHub Team2 GB$18 USD75 GB
GitHub Enterprise Cloud50 GB$300 USD150 GB

GitHub states that Support cannot increase these storage limits. Included compute is a dollar amount and not a number of minutes: at the $0.006 a minute GitHub lists for a standard Linux 2-core runner, $18 is 3,000 minutes, which the pricing post works through, and the cost calculator turns into a monthly bill. Artifacts and logs are kept for 90 days unless you set another retention period, and GitHub announced on 27 August 2026 that checks, workflow runs and statuses follow the same setting from 1 October 2026, with a 90-day maximum for public repositories.

What limits does a workflow file and a run have?

LimitFigureCan it change?Where GitHub says it
Jobs a matrix can make in one run256Not listed as raisableActions limits
Re-runs of one workflow run50Yes, by support ticketActions limits
Pending runs in a concurrency group (queue: max)100Not listed as raisableActions limits
Size of one workflow file500 KBNot listed as raisableActions limits
Check runs in one check suite50,000Not listed as raisableActions limits
Events that trigger runs1,500 per 10 seconds per repositoryYes, by support ticketActions limits
Workflow runs queued500 per 10 secondsNot listed as raisableActions limits
Inputs on a workflow_dispatch workflow25Not listed as raisableGitHub changelog, 4 December 2025

Three of these arrived recently and are the ones people meet by surprise. GitHub raised the number of workflow_dispatch inputs from 10 to 25 on 4 December 2025, and capped a workflow run at 50 re-runs on 10 April 2026, after automations that tried hundreds of retries. A run past the cap gets a failed check suite with an annotation saying so. The 256-job matrix limit applies to GitHub-hosted and self-hosted runners alike, so a matrix that fans out over several axes can reach it.

What are the API rate limits a workflow meets?

CredentialLimit
Unauthenticated requests60 an hour, by IP address
A personal access token, or an app acting for a user5,000 an hour
An app owned by an Enterprise Cloud organization, for a user15,000 an hour
An app installation token, outside Enterprise Cloud5,000 an hour at least, rising by 50 an hour for each repository and each user past 20, to 12,500
An app installation token, Enterprise Cloud15,000 an hour
GITHUB_TOKEN1,000 an hour per repository; 15,000 for an Enterprise Cloud account's resources

These are primary limits, and GitHub also applies secondary rate limits to prevent abuse, which it says are not configurable on Enterprise Cloud. A workflow that calls the API in a loop with GITHUB_TOKEN spends its 1,000 an hour quickly. A “Resource not accessible” error is a permission and not a rate limit, and the post on token permissions separates the two. Docker Hub’s own rate limit does not apply to public images pulled by GitHub-hosted runners, and does apply to private images and to any image pulled by a self-hosted runner.

What happens when a workflow hits a limit?

GitHub’s page says that, unless a row states otherwise, the expected behaviour when a limit is reached is that the workflow or job is cancelled. Rows that state otherwise are the ones in this post that say a run is blocked, rejected or failed instead: runs past the queue rate are blocked and not queued, a run past a concurrency group’s queue is, on the limits page, rejected, and a cache request past its rate fails until the limit resets. Check the table for which one you hit before deciding whether to change the workflow or ask support.

The quickest way to find the limit behind a failure is to read the exact message in the log and match it to a row. A cancellation with no other explanation is a time or concurrency limit more often than a fault in your code, and the troubleshooting page lists the messages a job on our runners can show. If your bill is the thing you are trying to limit, the pricing page has the rates and the dated log of pricing changes records each time GitHub moved one.

How do the limits on runners.io differ?

A job on our runners may run for 60 minutes, where GitHub allows six hours, and the number of jobs your organisation runs at once is set by your plan and shown on the billing page. A job that is over the limit waits, queued, and nothing is billed while it waits. Those two figures, and what a job cannot do, are on the runner limits page; the sizes and the memory and disk each one gets are on the labels page. The workflow limits in this post, such as the 256-job matrix, the 50 re-runs and the workflow file size, are GitHub’s and apply whichever runner a job uses.

Sources

Frequently asked questions

How long can a GitHub Actions job run?

On GitHub-hosted runners a job is terminated and fails at 6 hours, and at 15 minutes on the single-CPU ubuntu-slim runner. A self-hosted job may run for 5 days. A workflow run as a whole is cancelled at 35 days, a period that includes waiting and approvals.

How many jobs can run at once in GitHub Actions?

For standard runners it depends on the plan: 20 on GitHub Free, 40 on Pro, 60 on Team and 500 on Enterprise, with 5 macOS jobs at once except 50 on Enterprise. GitHub says Support can increase job concurrency through a support ticket.

How big can the GitHub Actions cache be?

10 GB per repository by default. Enterprise owners, organization owners and repository administrators can raise it, and storage above 10 GB is billed. Entries not accessed for 7 days are removed, and each repository is limited to 200 uploads, 1,500 downloads and 400 deletes a minute.

Which GitHub Actions limits can support raise?

GitHub's table marks job concurrency, re-runs per workflow run, the workflow trigger event rate, larger-runner concurrency and the static IP count as raisable by a support ticket. It says Support cannot increase storage limits, and marks no increase for job time or matrix size.

Move your CI onto our runners with one line

Connect GitHub

Card required. You pay only for the minutes your jobs run.

.github/workflows/ci.yml
jobs: test:- runs-on: ubuntu-latest+ runs-on: runnersio-4vcpu-ubuntu-2404 steps: - uses: actions/checkout@v4 - run: make test+ build:+ runs-on: runnersio-32vcpu-ubuntu-2404