# GitHub Actions run not starting: queued, pending or waiting?

A GitHub Actions run that will not start has one of four waits. Which status word means which, a decision tree to your cause, and what each wait looked like in our tests.

By Grant Unwin, published 2026-11-08. Checked against GitHub's documentation on 2026-11-17. The web page: https://www.runners.io/blog/github-actions-stuck-queued-pending-waiting

A GitHub Actions run that will not start is in one of four waits, and three have a status word of their own. A job with no runner for its label stays `queued`, as it did in 5 of 5 of our runs. A run behind another in its concurrency group is `pending`. A job held by an environment’s reviewers is `waiting`. A pull request that says “Waiting for status to be reported” has a required check that never ran. Our [GitHub Actions queue](https://www.runners.io/blog/why-github-actions-jobs-wait-for-a-runner) guide explains why jobs wait.

**In short**

- A run that will not start is in one of four waits, and three have a status word of their own.
- A job whose runs-on label matches no runner stays queued: it was still queued after 75 seconds in 5 of 5 of our runs.
- A run behind another in its concurrency group is pending, and a job held by an environment's reviewer is waiting.
- A pull request that says Waiting for status to be reported has a required check that never started.
- A run no GitHub-hosted runner takes within 45 minutes is discarded; a job queued for a self-hosted runner is cancelled after 24 hours.

The word matters because each wait has a different fix, and the usual advice for one does nothing for another. Checking a runner label will not free a run held by a concurrency group, and cancelling a run will not release a job that is waiting for a reviewer. This post tells the three apart in a minute, walks you down a tree to the section that explains yours, and says what we saw when we made each one happen on purpose. The long form of the queued case, the message *Waiting for a runner to pick up this job*, is our [guide to why jobs wait for a runner](https://www.runners.io/blog/why-github-actions-jobs-wait-for-a-runner); this page does not repeat it.

## Read the status word first

Every run and every job has a status, and the REST API lists the words it may be. Three of them, `requested`, `waiting` and `pending`, are ones GitHub says only Actions itself can set. The quickest way to read one is the command line, and the run page shows the same word. These two commands list the latest runs and then each job in one run with its status and the runner that took it, if any.

```bash
gh run list --limit 5 --json databaseId,status,conclusion,displayTitle
gh api repos/OWNER/REPO/actions/runs/RUN_ID/jobs \
  --jq '.jobs[] | {name, status, runner_name}'
```

Here is what each wait looked like when we produced it deliberately, in a public repository. The three that involve a job (no runner, a reviewer, a concurrency group) were each started five times, and the status was read at 15, 45 and 75 seconds. All five gave the same word at every read, apart from the first read of the first run in a pair, which could still be starting. The fourth wait, a pull request whose required check never ran, was three pull requests, read at 20 and 90 seconds.

| Status | Waiting for | What we saw | Read on |
| --- | --- | --- | --- |
| queued | A runner to take the job | A job whose runs-on label no runner has was still queued after 15, 45 and 75 seconds, in 5 of 5 runs | Queued sections |
| pending | Another run in the same concurrency group to finish | The second run of a group was pending at 15, 45 and 75 seconds, while the first run's 90-second job ran, in 5 of 5 pairs | Pending section |
| waiting | An environment's protection rules, such as a reviewer | A job in a protected environment was waiting, with no runner assigned, after 15, 45 and 75 seconds, in 5 of 5 runs | Waiting section |
| no status word | A required check that never started | Three pull requests that changed a file outside a workflow's paths filter were blocked at 20 and 90 seconds, with no check listed and no run, in 3 of 3 | Waiting for status section |

> **One word, two meanings**
>
> GitHub’s page on reviewing deployments calls a job that waits for a reviewer “Pending”, while the API calls it `waiting` and keeps `pending` for a run held by a concurrency group. We use the API’s words, because a script can read them.

## Walk the tree

Start at the top and open the branch that matches what you see. Every question is something you can check in about a minute, and every end of a branch says what is holding the run and links to the section below that explains it.

| Step | How to check, or what to do | What it leads to |
| --- | --- | --- |
| What status does the run or the pull request show? | Look at the run's page or run gh run list. The word is next to the run. | Queued: Is GitHub reporting an Actions incident right now?; Pending: A concurrency group is holding the run; Waiting: An environment's protection rules are holding the job; The pull request says Waiting for status to be reported: A required check never started, so the pull request waits for it for ever; There is no run at all: What was supposed to start the run? |
| Is GitHub reporting an Actions incident right now? | Open githubstatus.com and look at the Actions line. | Yes: GitHub may be having an incident; No: Does every runs-on label match a runner exactly? |
| Does every runs-on label match a runner exactly? | Copy the label out of the workflow and compare it, character by character, with the runner list or the docs. A runner must carry every label. | No, or I am not sure: The label matches no runner, so none will ever take the job; Yes: What kind of runner does the job ask for? |
| What kind of runner does the job ask for? | Read runs-on in the workflow. | Self-hosted, or a larger runner: The runner may be offline, or its runner group may exclude this repository; A standard GitHub-hosted runner: Are as many jobs running as your plan allows? |
| Are as many jobs running as your plan allows? | Count the in-progress jobs across the organisation, and compare with your plan's cap of concurrent jobs. | Yes, at the cap: You are at your plan's cap of concurrent jobs; No, there is room: Nothing you can see is wrong |
| What was supposed to start the run? | Look at the on: block of the workflow, and at what you did. | A pull request from a fork: A maintainer may have to approve a run from a fork first; A schedule: GitHub disabled the schedule; Anything else: a push, a pull request, a manual run: The workflow may be disabled, filtered out, or not listening for this event |
| Cause: GitHub may be having an incident | If the status page shows Actions degraded, wait, and re-run once it is resolved. | See: Queued: you are at your plan's cap, or GitHub is slow |
| Cause: The label matches no runner, so none will ever take the job | Fix the label. The job will otherwise stay queued until GitHub gives up on it. | See: Queued: the label matches no runner |
| Cause: The runner may be offline, or its runner group may exclude this repository | Check the runner list for the runner, then its group's repository access. | See: Queued: the runner is self-hosted or larger |
| Cause: You are at your plan's cap of concurrent jobs | Wait for jobs to finish, cut the fan-out, or ask GitHub Support to raise the cap. | See: Queued: you are at your plan's cap, or GitHub is slow |
| Cause: Nothing you can see is wrong | Give it a few minutes. A queued run that no GitHub-hosted runner has taken within 45 minutes is discarded, and then you re-run it. | See: Queued: you are at your plan's cap, or GitHub is slow |
| Cause: A concurrency group is holding the run | Find the run in the same group that is in progress. Cancel it, or add queue: max so that the pending run is not replaced. | See: Pending: a concurrency group is holding the run |
| Cause: An environment's protection rules are holding the job | Open the run and review the deployment, or change the environment's protection rules. | See: Waiting: an environment is holding the job |
| Cause: A required check never started, so the pull request waits for it for ever | Find out why the workflow did not run on this pull request: a path or branch filter, the wrong event, or no merge\_group trigger. | See: Waiting for status to be reported: the check never ran |
| Cause: A maintainer may have to approve a run from a fork first | Open the pull request and approve the workflows. An approval that waits more than 30 days expires. | See: No run at all |
| Cause: GitHub disabled the schedule | Enable the workflow again. In a public repository, scheduled workflows are disabled after 60 days with no repository activity. | See: No run at all |
| Cause: The workflow may be disabled, filtered out, or not listening for this event | Check that it is enabled, then its on: block: the event, its branches and paths filters, and whether the file is on the branch you pushed. | See: No run at all |

## Queued: the label matches no runner

A job goes to a runner that carries every label in its `runs-on`. A label that no runner has does not produce an error. The job is accepted and stays `queued`. We pointed a job at a label nobody had, five times, and all five were still queued 75 seconds later with no runner assigned. This is the one to rule out first, because it costs nothing to check and nothing else will clear it.

```yaml
jobs:
  build:
    runs-on: ubuntu-24.4   # no runner has this label: the job waits
  build-fixed:
    runs-on: ubuntu-24.04
```

How long the wait lasts depends on the runner. GitHub’s description of workflow continuity says a run that was queued but not processed by a GitHub-hosted runner within 45 minutes is discarded. Its limits page lists a 24-hour limit on a job in the queue under self-hosted runners. Neither limit tells you why the job was not taken, so a wait of more than a few minutes is a reason to read the label, not to wait.

## Queued: the runner is self-hosted or larger

If the label is right and the job is on a self-hosted runner, look at the runner list in the repository or organisation settings. A runner that is offline cannot take the job, and GitHub caps the wait at 24 hours. If it is a larger runner, the group matters as much as the label: a group controls which repositories may use it, and GitHub says repositories in an organisation do not have access to enterprise-level groups by default. A repository outside the group has no runner it may use. GitHub’s page does not say what such a job shows, so go to the group’s repository access list rather than looking for a message.

## Queued: you are at your plan’s cap, or GitHub is slow

Two causes need nothing from you, and we did not produce either one. The first is GitHub’s own status: open [githubstatus.com](https://www.githubstatus.com/) and look at the Actions line before you change anything. The second is your plan’s cap on concurrent jobs. GitHub’s limits page gives 20 for Free, 40 for Pro, 60 for Team and 500 for Enterprise on standard runners, and says Support can raise them. GitHub’s page does not say what status a job over the cap shows, only that the limit exists. The fix is a smaller fan-out, or a higher cap. Our [limits table](https://www.runners.io/blog/github-actions-limits) has every figure on that page in one place, and the guide to why jobs wait goes through the cap in detail.

## Pending: a concurrency group is holding the run

A run that is `pending` has been accepted, but another run in its concurrency group is still in progress, so it is not allowed to start. We started two runs of one group a second apart, five times. The second was pending at 15, 45 and 75 seconds, while the first run’s 90-second job was still working, with no runner assigned to it. GitHub’s documentation adds that by default only one run can wait in a group, so a third run replaces the second. That is a wait you asked for in the workflow, which makes it the easiest to fix and the easiest to forget.

Find the other run of the same group, which is the one in progress. If you do not want to wait for it, cancel it. If you want every run to happen in order, add `queue: max` to the group, and read [what five pushes do under each concurrency setting](https://www.runners.io/blog/github-actions-concurrency) first, because it measures what each one does to the runs that arrive while another is running.

## Waiting: an environment is holding the job

A job that names an environment with protection rules waits until the rules pass: a required reviewer or a wait timer. We gave a job an environment with one required reviewer, five times, and every job was `waiting` after 15, 45 and 75 seconds, with no runner assigned and nothing wrong with its label. We did not try a wait timer. The fix is on the run page: the reviewer approves or rejects the deployment. GitHub’s page also describes a “Start all waiting jobs” button that bypasses the rules, unless the environment forbids it. GitHub’s limits page says a workflow may wait up to 30 days on approvals, so a forgotten review does not time out soon.

## Waiting for status to be reported: the check never ran

This one is not a run at all. A pull request into a branch that requires a check shows “Waiting for status to be reported” when that check never starts. GitHub’s troubleshooting page lists the causes: a workflow skipped by a path filter, a branch filter or a commit message leaves its checks pending and blocks the merge. We set that up: a branch that requires a check named `build`, made by a workflow with a `paths:` filter, and three pull requests that changed a file outside the filter. At 20 seconds and again at 90, each was blocked, listed no check, and had no workflow run for its branch. Nothing was queued and nothing was running at 90 seconds, and nothing in the setup would start a run later, so the wait does not end by itself. The pull request’s merge state was blocked; we read the state, not the message.

The fix GitHub gives for the filter is to avoid requiring a workflow that can be skipped. A job skipped by a conditional, by contrast, reports success, so move the decision inside the workflow: drop the `paths:` filter from `on:` and skip the steps. A check reported by `workflow_dispatch` on the pull request’s branch does not count either, and a merge queue needs the `merge_group` event, which is the subject of our post on [the GitHub merge queue and what it costs in Actions minutes](https://www.runners.io/blog/github-merge-queue-actions-minutes).

## No run at all

Sometimes nothing is queued because nothing started. Three causes are documented. A pull request from a fork may need a maintainer to approve its workflows before they run, and an approval that waits more than 30 days expires and is marked failed. A scheduled workflow in a public repository is disabled when the repository has had no activity for 60 days, and it stays off until someone enables it. And a workflow that is disabled, or whose `on:` block does not list the event or has a `branches` or `paths` filter that excludes yours, does not run for your change. The workflow list under Actions shows which workflows are disabled.

## What we ran

The waits above were made in a public repository, where standard runners are free, on 17 November 2026. The jobs that ran used GitHub-hosted `ubuntu-24.04` runners; the no-runner job asked for a label that no runner has, and the required-check wait ran no job at all. The workflow, the script that reads the statuses back, the method and the raw rows, with the run id of every one, are in the [B4 directory of runners-io/ci-measurements](https://github.com/runners-io/ci-measurements/tree/main/studies/B4-queued-states). Five repetitions are enough to show a word, not to say how often a wait happens, and we make no claim about that. Build times measured on GitHub’s runner and on ours are on our [faster GitHub Actions runners, measured](https://www.runners.io/faster-github-actions) page.

## Sources

- [GitHub's REST API for workflow runs](https://docs.github.com/en/rest/actions/workflow-runs)
- [Reviewing deployments](https://docs.github.com/en/actions/how-tos/deploy/configure-and-manage-deployments/review-deployments)
- [Using self-hosted runners in a workflow](https://docs.github.com/en/actions/how-tos/manage-runners/self-hosted-runners/use-in-a-workflow)
- [GitHub-hosted runners](https://docs.github.com/en/actions/concepts/runners/github-hosted-runners)
- [Actions limits](https://docs.github.com/en/actions/reference/limits)
- [Controlling access to larger runners](https://docs.github.com/en/actions/how-tos/manage-runners/larger-runners/control-access)
- [GitHub Status](https://www.githubstatus.com/)
- [Control the concurrency of workflows and jobs](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency)
- [Troubleshooting required status checks](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/collaborating-on-repositories-with-code-quality-features/troubleshooting-required-status-checks)
- [Disabling and enabling a workflow](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/disable-and-enable-workflows)
- [Approving workflow runs from forks](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/approve-runs-from-forks)
- [Events that trigger workflows](https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows)
- [B4: the status word of each wait (runners-io/ci-measurements)](https://github.com/runners-io/ci-measurements/tree/main/studies/B4-queued-states)

## Frequently asked questions

### What do queued, pending and waiting mean in GitHub Actions?

Queued means a job has no runner yet. Pending means another run in the same concurrency group is still in progress. Waiting means an environment's protection rules, such as a reviewer, must release the job. We produced each wait five times and read these words from the API.

### Why is my GitHub Actions job stuck in queued?

Causes include a runs-on label that no runner has, an offline self-hosted runner, a runner group that excludes the repository, and your plan's cap of concurrent jobs. Check the label first, then GitHub's status page.

### Why is my workflow run pending?

Another run in the same concurrency group is in progress. By default only one run can wait, so a newer pending run replaces it. Cancel the run in progress, or add queue: max if every run must happen in order.

### Why does a pull request say Waiting for status to be reported?

A required check never started, for example because a path or branch filter skipped its workflow. GitHub says a skipped workflow leaves its checks pending and blocks the merge, and advises against requiring workflows that can be skipped.
