{"id":3202,"date":"2026-10-04T11:19:10","date_gmt":"2026-10-04T11:19:10","guid":{"rendered":"https:\/\/dmarketertayeeb.com\/blog\/github-actions-checks-workflow-retention\/"},"modified":"2026-10-04T11:33:22","modified_gmt":"2026-10-04T11:33:22","slug":"github-actions-checks-workflow-retention","status":"publish","type":"post","link":"https:\/\/dmarketertayeeb.com\/blog\/github-actions-checks-workflow-retention\/","title":{"rendered":"GitHub Actions Retention: Checks, Runs, and Statuses"},"content":{"rendered":"\n

Since October 1, 2026, the GitHub Actions retention setting on github.com<\/code> also governs check data, workflow runs, and commit statuses, alongside artifacts and logs. GitHub says these records are cleaned up when they pass the period set at the enterprise, organization, or repository level. Checks and statuses from third-party apps are included, and changing the setting will not restore records already removed. GitHub’s October 1 notice confirms the change is live<\/a>; the August announcement, clarified September 15<\/a>, explains what changed.<\/p>\n\n\n\n

If a release review, incident investigation, or audit needs evidence beyond the GitHub window, check what is still available and export the pieces you need before they disappear. Raising a retention number is not the same as making an archive.<\/p>\n\n\n\n

Check the value and the limit above your repository<\/h2>\n\n\n\n

At repository level, open Settings \u2192 Actions \u2192 General \u2192 Check, workflow run, status, artifact and log retention<\/strong>. An organization or enterprise can set a maximum that the repository cannot exceed. GitHub’s documentation lists a 90-day default, a 1-to-90-day range for public repositories, and a 1-to-400-day range for private repositories, subject to the managing organization’s or enterprise’s cap. The value you can actually use may be lower than the private-repository maximum.<\/p>\n\n\n\n

You can read the configured value through GET \/repos\/{owner}\/{repo}\/actions\/permissions\/artifact-and-log-retention<\/code>. Its response has days<\/code> and maximum_allowed_days<\/code>. GitHub’s example response uses 90 and 365; those are example values, and 365 is not the universal private-repository maximum. The REST route keeps the older \u201cartifact and log\u201d wording, though the same setting now covers checks, workflow runs, and statuses. This specific settings endpoint requires authentication: a fine-grained token needs repository Administration: read<\/code>, while a classic personal access token or OAuth token needs the repo<\/code> scope. For run and artifact inventory, use Actions: read<\/code>; for check data and annotations, Checks: read<\/code>; and for commit statuses, Commit statuses: read<\/code>. Some public-data endpoints allow unauthenticated reads where their documentation says so; that exception does not apply to this settings endpoint. See the repository retention settings endpoint<\/a> and GitHub’s repository settings guide<\/a>.<\/p>\n\n\n\n

There is a date wrinkle in the documentation. The settings page still contains an \u201cStarting October 1\u201d warning, even though that date has passed; GitHub’s October 1 changelog confirms the rollout is now effective on github.com<\/code>. The same settings page says a custom retention value applies only to new objects, not existing ones. Do not assume that raising the value today will extend older records. Export any older evidence you still need, and treat a changed setting as protection for new objects. GitHub also says a setting change cannot restore data already deleted.<\/p>\n\n\n\n

The October 1 changelog names github.com<\/code>. If you use GitHub Enterprise Server or another deployment, check the documentation for that product and version rather than assuming the same rollout date.<\/p>\n\n\n\n

Map the record types before exporting<\/h2>\n\n\n\n

A workflow run page is only one part of CI history. A useful archive keeps the record that links a result to a commit, plus any logs, annotations, or artifact bytes the investigation needs.<\/p>\n\n\n

\n\n\n
\n\n\n
Record<\/th>Read-only API route<\/th>What to preserve and where coverage stops<\/th><\/tr>\n<\/thead>\n
Workflow runs and attempts<\/td>GET \/repos\/{owner}\/{repo}\/actions\/runs?per_page=100&created=START..END<\/code><\/td>Save each run ID, current run_attempt<\/code>, workflow path or ID, event, commit SHA, timestamps, conclusion, actor, and URL. The run list describes the latest attempt; it is not an archive of every rerun log. For each earlier attempt you need and have identified, download its ZIP from GET \/repos\/{owner}\/{repo}\/actions\/runs\/{run_id}\/attempts\/{attempt_number}\/logs<\/code>. The attempt-log endpoint<\/a> returns a temporary download redirect.<\/td><\/tr>\n
Check suites and check runs<\/td>GET \/repos\/{owner}\/{repo}\/commits\/{ref}\/check-suites?per_page=100<\/code>, then \/check-suites\/{check_suite_id}\/check-runs?filter=all&per_page=100<\/code>; when annotations matter, \/check-runs\/{check_run_id}\/annotations?per_page=100<\/code><\/td>Keep suite and run IDs, app, status, conclusion, output, and annotations when they matter. The check-run list for a ref defaults to filter=latest<\/code>; use filter=all<\/code> for older versions. The separate annotations endpoint<\/a> is paginated and uses Checks: read<\/code>.<\/td><\/tr>\n
Commit statuses<\/td>GET \/repos\/{owner}\/{repo}\/commits\/{ref}\/statuses?per_page=100<\/code><\/td>Save each status state, context, description, creator, timestamps, and target URL. A target URL may point to logs held by another CI provider, which needs its own export.<\/td><\/tr>\n
Artifacts<\/td>GET \/repos\/{owner}\/{repo}\/actions\/runs\/{run_id}\/artifacts?per_page=100<\/code>, then \/actions\/artifacts\/{artifact_id}\/zip<\/code><\/td>Save the ZIP bytes and the artifact ID, name, size, digest, creation time, and expires_at<\/code>. Do not keep only the download URL.<\/td><\/tr>\n
Workflow logs<\/td>GET \/repos\/{owner}\/{repo}\/actions\/runs\/{run_id}\/logs<\/code> or \/attempts\/{attempt_number}\/logs<\/code><\/td>Download the log archive itself. The API responds with a redirect URL that expires after one minute, so follow it immediately.<\/td><\/tr>\n
Actions caches<\/td>Separate cache settings and cache APIs<\/td>Caches do not use the new five-item retention setting. Their default inactivity window and storage eviction rules are separate; a dependency cache is not a durable test-evidence archive.<\/td><\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n<\/div>\n\n\n

The main run, check, status, artifact, and log endpoints are documented in GitHub’s workflow-runs API<\/a>, check-suites API<\/a>, check-runs API<\/a>, commit-statuses API<\/a>, and artifacts API<\/a>. These endpoints return different objects; there is no single run-list response that includes every check, external status, log file, and artifact byte.<\/p>\n\n\n\n

Use a read-only export plan that can show its gaps<\/h2>\n\n\n\n

Read the setting and save a bounded run inventory<\/h3>\n\n\n\n

This Bash example uses GitHub CLI for two documented read-only requests. Before using it, confirm gh<\/code> is authenticated to an account authorized for the intended repository, for example with gh auth status<\/code>. Use a fine-grained token with Administration: read<\/code> for the retention setting and Actions: read<\/code> for workflow runs. If you use a classic token, the repository settings endpoint requires repo<\/code>. Replace the owner, repository, start, and end placeholders. Use ISO 8601 UTC timestamps for the bounded created<\/code> range. The commands were not run against a repository.<\/p>\n\n\n\n

set -eu\numask 077\nOWNER='OWNER'\nREPO='REPO'\nSTART='YYYY-MM-DDTHH:MM:SSZ'\nEND='YYYY-MM-DDTHH:MM:SSZ'\nOUT=\"ci-history-export-$(date -u +%Y%m%dT%H%M%SZ)\"\nmkdir -m 700 \"$OUT\"\ncd \"$OUT\"\n\ngh api --method GET \\\n  -H \"Accept: application\/vnd.github+json\" \\\n  -H \"X-GitHub-Api-Version: 2026-03-10\" \\\n  \"\/repos\/$OWNER\/$REPO\/actions\/permissions\/artifact-and-log-retention\" \\\n  > retention.json\n\ngh api --method GET \\\n  -H \"Accept: application\/vnd.github+json\" \\\n  -H \"X-GitHub-Api-Version: 2026-03-10\" \\\n  \"\/repos\/$OWNER\/$REPO\/actions\/runs?per_page=100&created=$START..$END\" \\\n  --paginate --slurp \\\n  > workflow-run-pages.json<\/code><\/pre>\n\n\n\n
The settings response contains days<\/code> and maximum_allowed_days<\/code>; the numbers shown in GitHub’s schema example are not values from your repository. The run output is an outer JSON array of page objects, each with its own workflow_runs<\/code> results. --paginate<\/code> follows the REST pagination links, and --slurp<\/code> keeps the page objects together in that array. This gives you run metadata only. It does not fetch earlier-attempt logs, artifact ZIPs, check annotations or commit statuses; use the relevant rows above for those records. The GitHub CLI manual<\/a> documents the method, pagination, and slurp options.<\/p>\n\n\n\n
    \n
  1. Write down what the evidence is for.<\/strong> Name the consumers, the longest time they need access, and the record types they will need. For a release review that may mean the run attempt, commit SHA, check result, test report artifact, and logs. For a longer audit window, ask the owner of that requirement to set the retention rule. GitHub’s maximum is a platform limit, not proof that the period meets a legal or internal policy.<\/li>\n
  2. Record the effective setting and its cap.<\/strong> Read the repository, organization, and enterprise policy that governs the repository. Keep the date, value, and maximum allowed value with the export manifest. Avoid the matching PUT<\/code> settings route unless you are explicitly changing policy.<\/li>\n
  3. Enumerate runs in date ranges.<\/strong> Set per_page=100<\/code>; the CLI example above follows pagination automatically, while a direct REST client must follow the response’s Link<\/code> header. GitHub caps a filtered workflow-run search at 1,000 results. Check the returned total_count<\/code>, number of page objects, and date-window boundaries; reaching ten pages by itself proves neither that the window was complete nor that more results were hidden. Subdivide any window that reaches or approaches the cap and record the resulting ranges and page counts. See GitHub’s workflow-run listing reference<\/a>.<\/li>\n
  4. Walk checks by commit.<\/strong> For each relevant commit SHA, list its check suites, then list every suite’s check runs with filter=all<\/code>. The shortcut endpoint for check runs on a ref uses the latest filter by default and can stop at the 1,000 most recent suites on one ref. GitHub recommends listing suites and then the runs for each suite when broader coverage is needed. The checks API is scoped to pushes in the repository where the suite or run was created, so account for forked repositories separately.<\/li>\n
  5. Read statuses and artifacts separately.<\/strong> Statuses are returned newest first for the requested ref. Page through them, then download each unexpired artifact ZIP you need. The artifact object exposes an expiry time and digest, but its listing is not the artifact’s content.<\/li>\n
  6. Fetch expiring downloads immediately.<\/strong> Both workflow-log and artifact downloads use temporary redirects that expire after one minute. Automate the redirect and file download in one operation, then verify the saved bytes. Do not store the temporary URL as if it were a permanent archive link.<\/li>\n
  7. Bind the files to a manifest.<\/strong> Record repository URL and ID, relevant commit SHAs (including commits with third-party checks even when there is no Actions run for them), workflow path, run ID and each required attempt, check suite and run IDs, annotation pages, status context, artifact IDs and digests, request date, API route, pagination ranges, and a SHA-256 hash for every downloaded file. Store the manifest, JSON responses, log ZIPs, and artifact ZIPs in a location with the access controls and retention your organization requires. Test retrieval and compare hashes before relying on the archive.<\/li>\n<\/ol>\n\n\n\n
    When a read fails:<\/strong> Pause and inspect the endpoint’s documented permission, access policy, and any rate-limit details before changing credentials. A 403<\/code> or rate-limit response calls for diagnosis, not a broader token by default. For a 404<\/code>, verify the repository path, record ID, access, and object state; do not assume it proves deletion or that data can be restored. The artifact-download endpoint documents 410 Gone<\/code>; if returned, treat that download as unavailable through this API. Check artifact metadata such as expired<\/code> when available, and do not promise a restore. GitHub documents these responses in the artifact-download reference<\/a> and its REST rate-limit guidance<\/a>.<\/p>\n\n\n\n
    Use the least privilege needed for the read: fine-grained tokens use Actions: read<\/code> for runs, logs, and artifacts; Checks: read<\/code> for check suites and runs; and Commit statuses: read<\/code> for statuses. Classic tokens for private repositories may require the broader repo<\/code> scope. Check the endpoint’s permission table before creating a token.<\/p>\n\n\n\n
    A normal source-code mirror is not a complete Actions export. Workflow, check, status, log, and artifact records use separate API routes, so preserve the responses and file contents required for the investigation, release review, or audit. Logs and artifacts can also contain sensitive material; restrict the archive to the people who need it and follow the repository’s data-handling rules.<\/p>\n\n\n\n
    One open-source example, actions-attic<\/a>, writes workflow-run, check-run, and commit-status metadata as JSONL in a separate Git ref. Its README explicitly says that it does not store job-log text or artifacts, and its workflow example requests contents: write<\/code> to maintain that ref. That is a useful metadata-archive pattern to inspect, not a complete export or an endorsement. Review its code, permissions, backfill coverage, and the security of the destination before adopting any third-party archiver.<\/p>\n\n\n\n
    Keep cache and storage costs separate<\/h2>\n\n\n\n
    Artifact and log retention is not cache retention. GitHub’s dependency-cache reference<\/a> says entries that have not been accessed for more than seven days are removed by default, with separate size and eviction limits. Use caches to speed up builds, not to keep test evidence. For an individual artifact, the actions\/upload-artifact<\/code> documentation<\/a> says you can set retention-days<\/code>, up to the repository, organization, or enterprise limit. That changes the artifact’s expiry, not check history or workflow logs.<\/p>\n\n\n\n
    There is also a storage-cost wording difference across GitHub’s public pages. The August 27 retention announcement says artifacts and logs count toward billable Actions storage, while the current GitHub Actions billing guide<\/a> says log files and long job summaries do not count toward the repository owner’s artifact-storage allowance. The detailed billing page separates artifact and package storage from cache storage; it does not provide an account-specific estimate for your repository. Check your current plan and usage before treating a retention change as a cost-saving measure. This guide does not estimate savings.<\/p>\n\n\n\n
    Disclosure: This guide was prepared with AI assistance. The read-only API process above was checked against GitHub’s documentation but was not executed against a live repository.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
    GitHub Actions retention now covers checks, workflow runs and statuses. Check your limits, see what is deleted, and export CI evidence safely.<\/p>\n","protected":false},"author":1,"featured_media":3201,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[274],"tags":[397,315],"class_list":["post-3202","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tools-reviews","tag-developer-experience","tag-developer-tools","has-featured-image"],"_links":{"self":[{"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/posts\/3202","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/comments?post=3202"}],"version-history":[{"count":1,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/posts\/3202\/revisions"}],"predecessor-version":[{"id":3203,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/posts\/3202\/revisions\/3203"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/media\/3201"}],"wp:attachment":[{"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/media?parent=3202"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/categories?post=3202"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dmarketertayeeb.com\/blog\/wp-json\/wp\/v2\/tags?post=3202"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}