Is GitHub MCP Free to Use?

The GitHub MCP server itself costs nothing; any cost comes from GitHub API rate limits, not the connector. So, is GitHub MCP free? Mostly — the open-source server that ships from the Model Context Protocol team carries no license fee, but every tool call still spends your GitHub account's API rate limit, and how far that limit stretches depends on your plan and whether you're on a personal account or an organization.

What Does 'Free' Actually Mean Here?

Any answer to whether GitHub MCP is free has to separate two things that get bundled together. The first is the MCP server itself — the small piece of glue code that translates GitHub's API into tools an agent like Claude Code or Cursor can call, such as list_pull_requests or create_issue. The second is the GitHub API behind it, which belongs to your own GitHub account and follows GitHub's own usage rules regardless of which client — a browser, a script, or an MCP-connected agent — is making the calls.

The honest answer to "is GitHub MCP free" splits along that same line: the connector costs nothing to install or run, but it inherits whatever ceiling already applies to the token you hand it. An agent running ten GitHub MCP calls in a session uses exactly the same allowance a human would use clicking through the same ten actions in the GitHub UI — the MCP layer adds convenience, not a separate charge.

Does the GitHub MCP Server Itself Cost Anything?

The official GitHub MCP server is run by the Model Context Protocol team and ships with roughly nine tools covering the day-to-day GitHub surface: reading a repository, listing and creating issues, listing and opening pull requests, reading a file with get_file_contents, writing one with create_or_update_file, and searching code. It installs with mcpizy install github or by running npx -y @modelcontextprotocol/server-github directly — neither command carries a license fee.

There is also a more aggressive community fork that adds fuller support for Actions, projects and packages, for teams whose workflows go beyond issues and PRs. Either way, what you're installing is open connector code, not a paid product — the cost conversation only starts once the agent begins making calls against your GitHub account's API, which is where the next section picks up.

How Do GitHub API Rate Limits Vary by Plan?

GitHub's documentation on REST API rate limits explains that unauthenticated requests — the kind associated with an IP address rather than a signed-in user — are capped at 60 requests per hour. Authenticating the GitHub MCP server with a personal access token raises that ceiling substantially, since GitHub calculates your primary rate limit from your method of authentication rather than treating every caller the same.

In practice, that budget covers most day-to-day agent work comfortably: triaging 200 issues at roughly five calls each comes out to about 1,000 requests, well inside a 5,000-requests-per-hour PAT allowance. Where it gets tight is bulk work across many repositories — a repo-wide audit spanning 50 repos can hit the ceiling fast, especially if each repo needs several sequential single-item calls instead of a batched GraphQL query or paginated reads.

Search adds its own wrinkle: search_code runs against GitHub's code search index, which is eventually consistent, so recently pushed code can take five to thirty minutes to show up, and some file types — lock files, vendored dependencies — aren't indexed at all. An agent that gets fewer than three hits back should fall back to cloning the repo and grepping locally rather than burning extra API calls retrying the same search.

Personal Accounts vs Organizations: What Changes

Fine-grained personal access tokens have a scoping quirk that matters more as soon as an organization is involved: the "all repositories" toggle does not include private repositories by default. If list_pull_requests comes back empty for a repo you know has open PRs, the fix is regenerating the token with that repository explicitly selected rather than relying on the blanket toggle.

That distinction matters less for a personal account with a handful of repos, where selecting them individually is a minor step, and much more for an organization running many private repositories across teams — exactly the scale where a 50-repo audit becomes plausible and where the rate-limit math from the previous section starts to bite. The safe default either way is scoping the token to the smallest useful permission — read-only repo and issues access — and upgrading to write scopes only once a human is explicitly approving each write.

Is There a Local Alternative With No API Limit?

For work that doesn't need GitHub's hosted side at all, the Git MCP server operates entirely on your local repository — no GitHub account, token or hosted API call involved. It installs with mcpizy install git or by running uvx mcp-server-git, and its listing describes it plainly as free and open-source, with no authentication setup documented because none is needed for local operations.

Because every call stays on disk, Git MCP isn't subject to GitHub's REST rate limits the way GitHub MCP's remote calls are — there's no request budget to track when you're just reading history, diffing branches or grepping a checked-out repo. The trade-off is scope: it has no tools for issues, pull requests or anything else that lives on GitHub's servers, so it works best as a complement to GitHub MCP rather than a replacement for it — see Local vs Remote MCP Servers: What Changes for the broader trade-off.

How Do I Check My Own Rate Limits Before Automating?

Before pointing an agent at a large batch job, it's worth reading GitHub's own REST API rate-limit documentation to understand how your primary limit is calculated for the authentication method you're using, since GitHub bases it on that rather than a flat number for everyone. That's also the moment to decide whether the job genuinely needs write access, given that create_or_update_file commits through the API with no GPG signing, no pre-commit hooks and no CI run unless branch protection forces one.

For anything past a quick read, run a small test call first — an empty result where you expected data is usually a token-scope problem, not a rate-limit one, and the fix is regenerating the token with the right repository explicitly selected. For genuinely large jobs, batch requests via GraphQL or paginate instead of issuing one REST call per item, and route any write-heavy workflow, such as the Issue → Branch → PR Pipeline recipe, through a branch and pull request rather than direct commits to main.

If you're setting up GitHub MCP for the first time inside Claude Code, the general install and configuration steps — separate from the rate-limit question — are covered in How to Use GitHub MCP with Claude Code, and the general logic of scoping any MCP server's permissions safely is covered in MCP Server Permissions and Scopes Explained. Neither changes the rate-limit math above, but both are worth reading before you hand an agent write access to a real repository.

FAQ

Is GitHub MCP free to use with a private repository? Yes, the connector doesn't distinguish between public and private repos — the requirement is scope, not payment. A fine-grained personal access token needs that specific private repository selected explicitly, since the "all repositories" toggle does not include private repos by default; without that, tools like list_pull_requests will simply return empty rather than erroring.

Does the community fork with Actions, projects and packages support cost more than the official server? The official GitHub MCP listing doesn't state a price for either version, and neither page addresses pricing directly — both are installed as open connector code, so the practical cost consideration is the same GitHub API rate limit discussed above, not a separate fee tied to which fork you run.

Does Git MCP replace GitHub MCP for automation work? No — Git MCP only exposes local repository operations, so anything that needs to read or write GitHub-hosted state, such as opening a pull request, creating an issue or leaving a review comment, still needs GitHub MCP and its accompanying rate limit. The two are complementary: Git MCP for local history and diffing, GitHub MCP for everything that lives on GitHub's servers.