Skip to content
Beta
All articles

Copilot code review settings now have an API: what it can and can't change

GitHub opened Copilot code review settings to its REST and GraphQL APIs on 6 November. What each level can set, which tokens work, and what stays manual.

By The SpanDock team

5 min read

A diagram of three layers of Copilot code review settings, enterprise, organisation and repository, showing which settings each layer can manage through the API and which stay in the web interface

Copilot code review has grown a long list of settings: whether it runs, how deep it looks, which runner it uses, whether it reads custom instructions and MCP servers, and whether its approvals count. Until now, most of them lived only in the web interface. On 6 November 2026 GitHub announced that code review settings can be managed through the REST and GraphQL APIs, from enterprise policy down to individual repositories.

That is useful for any organisation that treats repository settings as code. It is also partial: several of the settings that matter most for governance remain manual. This article sets out what the API covers at each level, which credentials it accepts, and what to do with it.

What each level can manage

The changelog and the configuration documentation describe three layers:

LevelThrough the API
EnterpriseEnable or disable code review for all organisations, or let organisation owners decide
OrganisationEnable or disable code review when the enterprise lets organisations decide; set the default review effort; configure the runner code review uses
RepositorySet the review effort; choose whether reviews use custom instructions and MCP servers

Settings an enterprise manages can't be overridden by an organisation through the API. The REST API accepts the same effort levels as the web interface, and the organisation and repository responses list the levels available to the caller.

The documentation is explicit about what is not in the API: "Other settings on this page, such as maximum review effort, billing, and approvals, are not available through the API."

That excludes three of the settings with the most governance weight:

  • Maximum review effort, the cap that stops repositories from choosing the most expensive effort level.
  • Billing, including which organisation pays for reviews.
  • Approvals, including whether Copilot may approve pull requests and whether its approvals count toward merge requirements.

For those, the web interface remains the only route.

Which credentials work

The changelog carries a warning worth reading twice. The enterprise and organisation settings endpoints, including the organisation runner endpoint, do not support GitHub Apps or fine-grained personal access tokens. The repository settings endpoints support both, with Administration: read to read settings and Administration: write to update them. Classic personal access tokens need repository administrator access.

In practice, a platform team that has moved its automation to GitHub Apps can manage repository-level review settings with an app, but not the organisation defaults or the enterprise policy. Those still need a person's token. Teams that have retired classic tokens for admin automation will need to decide how they handle that gap rather than reintroducing a broad token by default.

Attribution in the API

The same update adds read-side fields to the existing code review API:

  • explicit attribution fields that identify Copilot's reviews and comments;
  • the review effort a review used, when that metadata is available;
  • which skills, MCP servers and custom instructions Copilot reported as sources for a comment.

The last of these is the more interesting for security teams. If a repository's custom instructions or an MCP server shaped a review comment, the API can now say so, at least as far as Copilot reports it. "Reported as sources" is the changelog's wording; treat it as Copilot's own account rather than an independent trace.

Other changes in the release

Several smaller changes in the same update affect cost and behaviour:

  • Code review agent sessions now show the AI credits consumed in a review.
  • The Automatically request Copilot code review repository rule now supports the bypass list, so exempt actors don't receive an automatic review.
  • Balanced effort reviews now use three reviewer models, with another model combining their findings.
  • Failed or timed-out reviews are retried once automatically, and Copilot can switch to another eligible model when the preferred one is unavailable.
  • Billing and preview settings are now preserved when code review is turned off and on again.
  • GitHub Actions, Dependabot and apps the organisation or enterprise owns can again request reviews on bot-authored pull requests when Block reviews requested with an external Copilot license is on, as long as the organisation pays for the review.

The changelog says these updates are available on the Copilot Pro, Pro+, Max, Business and Enterprise plans.

What it means for engineering and security leaders

The API makes it practical to answer two questions that were tedious before: which repositories have Copilot code review on, at what effort, and which repositories let reviews read custom instructions and MCP servers. Both are configuration drift questions, and an API turns them into a scheduled check rather than a manual audit.

The repository-level MCP and custom-instructions switch deserves particular attention. Custom instructions and MCP tools change what the reviewer sees and how it behaves. In repositories that accept outside contributions, or where instruction files are edited often, a team may reasonably want reviews that don't use them, and can now set and verify that per repository.

The gaps point the other way. Because maximum effort, billing and approvals stay manual, a configuration-as-code set-up for code review will be incomplete. The approval settings in particular decide whether an AI review can satisfy a merge requirement, so they need a documented owner and a periodic manual check, not an assumption that the automation covers them.

Practical takeaways

  • Inventory review settings across repositories through the API: enablement, effort, and whether reviews use custom instructions and MCP servers.
  • Decide a default for the custom-instructions and MCP switch, especially for public or outside-contribution repositories, and enforce it with a scheduled job.
  • Use a GitHub App with Administration permission for repository settings. For enterprise and organisation endpoints, plan for a person's token and keep its scope and lifetime narrow.
  • Keep maximum effort, billing and approvals on a manual checklist with a named owner, since the API can't set them.
  • If you use the automatic review rule, review its bypass list now that it applies.
  • Watch the new per-review credit figure for a few weeks after changing effort defaults, since Balanced now uses several models per review.

For how Copilot code review effort and billing work, see our article on who pays and how deep it looks. For measuring what happens to its comments, see the addressed rate in usage metrics.

Sources

  1. GitHub changelog: Copilot code review: API management and review overview updates (6 November 2026)
  2. GitHub Docs: Configuring code review by GitHub Copilot
Cookie categories

Details: Cookie Policy.