Intermittent GitHub API Bug: Why Your CI/CD Workflows and Development Dashboards Are Failing

In the fast-paced world of software development, reliable tooling is not just a convenience—it's the backbone of efficient delivery. From automating CI/CD pipelines to populating critical development dashboard examples, APIs serve as the nervous system of our engineering ecosystems. When these foundational APIs falter, the ripple effect can be profound, impacting everything from daily developer productivity to strategic development OKRs.

Recently, a significant and recurring bug in GitHub's REST API has been causing considerable disruption for dev teams, product managers, and technical leaders alike. The issue centers around the branch query parameter for the GET /repos/{owner}/{repo}/actions/runs endpoint, which intermittently—and frustratingly—returns a total_count: 0 and an empty workflow_runs array, even when the specified branch clearly has numerous runs.

The Ghost in the Machine: Intermittent API Failures

Imagine your automated scripts, designed to fetch the latest successful build on a specific branch, suddenly failing. The logs show an empty response, suggesting no runs exist. You manually check, and lo and behold, thousands of runs are present. This is the insidious nature of the bug reported in GitHub Community Discussion #194141, actively reproducible as of April 27, 2026.

The core problem is simple: when the branch filter is applied to the /actions/runs endpoint, it sporadically fails to return any data, despite the data being readily available when the filter is removed. This isn't a new phenomenon; similar issues have plagued GitHub's API for years, as evidenced by related discussions dating back to 2021 (e.g., #24626 and #53266, concerning the status= filter).

Reproducing the Frustration

The original reporter, theyoprst, provided a clear reproduction path that highlights the discrepancy. Using a simple curl command with a valid token, one can query the same endpoint for a given repository and branch, both with and without the branch filter. The results are stark:

• Unfiltered Query: Returns a high total_count (e.g., 20,000+ runs).
• Filtered Query (with branch=main): Returns total_count: 0.

This behavior is not isolated to a single repository or branch; it's platform-wide and intermittent, making it incredibly difficult to diagnose and trust. A query that returns correct results one minute might return zero the next, without any changes on the client side.

Impact on Delivery, Productivity, and Technical Leadership

For dev teams, product managers, and CTOs, the implications of such an intermittent API bug are far-reaching:

Disrupted CI/CD Pipelines

Many modern CI/CD workflows rely on the GitHub API to fetch critical information. A common pattern is to query for the latest successful build on a branch to use as a dependency for downstream jobs (e.g., deploying to a staging environment, triggering end-to-end tests). When the branch filter fails, these upstream jobs exit with an error, causing a cascade of failures throughout the pipeline. This leads to:

• Delayed Releases: Broken pipelines mean features aren't delivered on time.
• Wasted Compute Resources: Jobs fail prematurely, but resources are still consumed.
• Erosion of Trust: Developers lose confidence in the automation system.

Loss of Developer Productivity

The intermittent nature of this bug is a major productivity drain. Engineers spend valuable time chasing "ghost failures" in their own code, only to find minutes later that the issue has seemingly resolved itself. This debugging overhead distracts from core development tasks and can significantly impact individual and team performance, potentially even influencing software engineer performance review examples if delivery metrics are tied to pipeline success rates.

Compromised Tooling and Development Dashboards

Custom tools and development dashboard examples often aggregate data from GitHub to provide visibility into project health, build statuses, and deployment progress. When the API returns incomplete or incorrect data, these dashboards become unreliable, hindering informed decision-making for product managers and delivery managers. Accurate, real-time data is crucial for tracking progress against development OKRs, and this bug directly undermines that capability.

Challenges for Technical Leadership

For CTOs and engineering leaders, intermittent infrastructure issues like this pose a significant challenge. Ensuring the reliability of core development tools is paramount. When a foundational API like GitHub's Actions API becomes unreliable, it forces teams to build complex workarounds, diverting resources from feature development and increasing technical debt. It also raises questions about the platform's stability and long-term support for critical developer workflows.

The Undocumented head_branch Parameter: A Source of Confusion

Adding to the complexity, the discussion also highlighted an undocumented head_branch= parameter on the same endpoint. While some users might attempt to use it as a workaround for the broken branch= filter, it appears to be silently ignored, returning the unfiltered total regardless of the value provided. This behavior is problematic: an API should either explicitly support a parameter or reject it with a clear error (e.g., 422 Unprocessable Entity) to prevent users from misinterpreting silent failures as correct results.

Mitigation and Moving Forward

Given the intermittent nature and the lack of an immediate fix from GitHub, teams need strategies to mitigate the impact:

• Client-Side Filtering: The most effective workaround identified is to remove the problematic branch filter from the API request and instead fetch all runs, then filter the results client-side. While this increases data transfer and processing on the client, it ensures accuracy.
• Robust Error Handling: Implement more resilient error handling in automation scripts, potentially with retries or fallback mechanisms that can detect empty responses and trigger client-side filtering.
• Advocate for a Fix: Continue to engage with GitHub support and community discussions to highlight the severity and impact of this bug. The more visibility it gets, the higher the priority for a permanent resolution.

The reliability of core developer tools directly translates to team productivity and successful delivery. Intermittent API bugs like this GitHub issue underscore the importance of robust API design, thorough testing, and responsive maintenance from platform providers. For devActivity, our commitment is to empower teams with insights and tools that are built on a foundation of trust and reliability. We urge GitHub to address this long-standing issue to ensure the seamless operation of CI/CD pipelines and the integrity of critical development data.