GitHub pull request limits for open source repos

How do pull request limits work on GitHub for open source repos

GitHub does not set one universal pull request limit for open source repositories. The practical limits come from repository settings and platform thresholds, especially open pull requests against the same branch, merge rate, diff size, and any interaction limits the maintainer turns on.

The main number people quote is 1,000 open pull requests against the same branch. GitHub documents that as a recommended maximum to avoid mergeability bottlenecks and timeouts in busy repositories. It is not a public “you may only have 1,000 PRs” rule for every repo, it is a performance limit GitHub wants you to stay under.

What actually slows a large open source repo is merge checking. GitHub says each merge can trigger mergeability checks for all open pull requests, which creates load when a project has many active PRs. If maintainers keep requiring the branch to be up to date before merging, that extra checking becomes more expensive.

There is also a separate interaction control called pull request limits. Maintainers can configure the maximum number of concurrent open pull requests allowed for users without write access. When that limit is reached, the contributor must close an existing pull request or wait for a maintainer to merge one before opening another.

That interaction limit is different from the platform’s recommended 1,000-open-PR guidance. The first is a repo policy tool that a maintainer can turn on. The second is GitHub’s performance guidance for keeping a repository healthy. Open source repos often use the repo policy tool to reduce spam or contributor pileups, while still staying far below the platform ceiling.

The part people get wrong is assuming the limit is about open source status. GitHub’s documented limits do not say open source repos get a special allowance or a special penalty. The constraint is the same repository activity model, so a public project with heavy PR traffic can run into the same mergeability and queue problems as any other busy repo.

Another common mistake is confusing pull request count with pull request size. GitHub also limits diff size in a pull request: no total diff may exceed 20,000 lines that you can load or 1 MB of raw diff data, no single file’s diff may exceed 20,000 lines or 500 KB raw, and a single diff is capped at 300 files. Those limits affect reviewability and display, not the number of pull requests you can open.

Commit count matters too. GitHub limits the commits shown in the compare view and pull requests page to 250, and the Rebase and merge option is limited to 100 commits. If a contributor sends one giant PR with more than 100 commits, maintainers need to merge with a merge commit, squash it, or split the work into smaller pull requests.

For maintainers of open source repos, the useful question is not “How many PRs can GitHub hold?” It is “How many concurrent PRs can my team review without slowing down the branch?” If you have a flood of first-time contributors, a PR creation cap can reduce noise. If you have a well-organized project, letting people open more PRs and keeping the branch queue short is often cleaner.

A concrete example helps. Suppose an open source repo has 240 open PRs, all targeting main. That repo is still under GitHub’s recommended 1,000-open-PR guidance, but each new merge can still cause checks across the whole set. If maintainers turn on a pull request creation cap for non-collaborators, new external contributors will hit that repo rule before the platform limit becomes the issue.

If you are asking as a contributor, the rule to watch is usually the repository’s own interaction policy, not a hidden GitHub-wide quota. The maintainer may allow unlimited open PRs, may cap non-collaborators, or may slow down merges because the repo is already busy. Reading the repo settings and contribution guide matters more than guessing from GitHub’s public scale limits.

If you are asking as a maintainer, the best practice is to keep pull requests small, reduce cross-PR dependency, and avoid letting the queue grow so large that every merge re-checks hundreds of branches. GitHub’s own docs point to merge queues and relaxing the “require this branch to be up to date before merging” setting as ways to reduce load in busy repositories.

In short, open source repos do not get a special pull request quota from GitHub. They inherit the same platform limits as other repos, and the meaningful controls are the repo’s interaction limits, the size of each PR, and how many PRs are open against the same branch at once.

For teams that want a contributor hub and a testing exchange around their own app work, DevConnect is a separate place to organize that workflow, and it stays free to use: https://devconnectplatform.com.

What happens when you hit a limit

When a repo hits an interaction limit for pull requests, GitHub blocks additional PR creation for users without write access until space opens up. When a repo hits diff or commit display limits, GitHub may stop showing the full content in the UI even though the PR still exists. When a repo becomes too busy overall, mergeability checks and UI performance are what usually fail first.

What to do if your open source repo is growing fast

Split large changes into smaller PRs, keep the number of open PRs per branch under control, and decide whether external contributors should face a creation cap. If merges are stalling, review whether branch protection settings are forcing unnecessary rechecks. Those are the levers GitHub documents as relevant to PR load.

What is not the limit

The limit is not “open source gets fewer pull requests.” It is not a hard public cap that every repository hits at the same number. It is not the same thing as the 250-commit display limit or the 300-file diff limit. Those are separate controls, and each one fails differently.