Provides tools for querying Codecov coverage data, including file-level, commit, repository, and pull request coverage analysis, as well as coverage comparisons between branches, commits, or tags.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Codecov MCP Server Get coverage for src/index.ts in owner/repo on main"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides tools for querying Codecov coverage data. Supports both codecov.io and self-hosted Codecov instances with configurable URL endpoints.
📦 Published on npm: @egulatee/mcp-codecov 🐳 Docker image: ghcr.io/egulatee/mcp-server-codecov
📖 Learn More: Read about building this MCP server with AI in just 2 hours.
Get started in under 2 minutes:
Create an API token (not an upload token) from your Codecov account:
Go to codecov.io (or your self-hosted URL)
Click your avatar → Settings → Access tab
Click "Generate Token" and name it "MCP Server API Access"
Copy the token value
Add to your shell profile (~/.zshrc or ~/.bashrc):
export CODECOV_TOKEN="your-api-token-here"Then reload: source ~/.zshrc
claude mcp add --transport stdio codecov \
--env CODECOV_BASE_URL=https://codecov.io \
--env CODECOV_TOKEN=${CODECOV_TOKEN} \
-- npx -y @egulatee/mcp-codecovclaude mcp get codecovExpected output: codecov: @egulatee/mcp-codecov - ✓ Connected
That's it! You can now use Codecov tools in Claude Code. See Available Tools below.
Related MCP server: simplecov-mcp
File-level coverage: Get detailed line-by-line coverage data for specific files
Commit coverage: Retrieve coverage statistics for individual commits
Repository coverage: Get overall coverage metrics for repositories
Pull request coverage: Analyze coverage changes and impact for pull requests
Coverage comparison: Compare coverage between branches, commits, or tags
Configurable URL: Point to any Codecov instance (codecov.io or self-hosted)
Token authentication: API token support for accessing coverage data
Important: Codecov has two different types of tokens:
Upload Token: Used for pushing coverage reports TO Codecov during CI/CD. Found on your repository's Settings → General page.
API Token: Used for reading coverage data FROM Codecov via the API. Created in your Codecov Settings → Access tab.
This MCP server requires an API token, not an upload token.
Get line-by-line coverage data for a specific file.
Parameters:
owner (required): Repository owner (username or organization)
repo (required): Repository name
file_path (required): Path to the file within the repository (e.g., 'src/index.ts')
ref (optional): Git reference (branch, tag, or commit SHA)
Example:
Get coverage for src/index.ts in owner/repo on main branchGet coverage data for a specific commit.
Parameters:
owner (required): Repository owner
repo (required): Repository name
commit_sha (required): Commit SHA
Example:
Get coverage for commit abc123 in owner/repoGet overall coverage statistics for a repository.
Parameters:
owner (required): Repository owner
repo (required): Repository name
branch (optional): Branch name (defaults to repository's default branch)
Example:
Get overall coverage for owner/repo on main branchGet coverage data for a specific pull request, including coverage changes and file-level impact.
Parameters:
owner (required): Repository owner (username or organization)
repo (required): Repository name
pull_number (required): Pull request number
Example:
Get coverage for pull request #123 in owner/repoUse Cases:
Check if PR meets coverage thresholds before approving
Alert when PR decreases overall coverage
Identify which files in a PR lack coverage
Implement quality gates that block merges if coverage drops
Compare coverage between two git references (branches, commits, or tags).
Parameters:
owner (required): Repository owner (username or organization)
repo (required): Repository name
base (required): Base reference (e.g., 'main', commit SHA)
head (required): Head reference to compare against base
Example:
Compare coverage between main branch and feature-branch in owner/repoUse Cases:
Compare coverage between release branches
Analyze coverage changes between any two commits
Track coverage trends across development cycles
Validate coverage improvements in feature branches
Important Note: Before a repository can receive coverage uploads, it must be activated in Codecov. This is a one-time setup step that cannot be automated via API.
To activate a repository for coverage tracking:
Log in to your Codecov instance (e.g., codecov.io)
Navigate to your organization/user account
Find the repository you want to activate
Click the "Activate" button to enable coverage tracking
Once activated, you can upload coverage reports from your CI/CD pipeline
Why manual activation is required: The Codecov API v2 does not provide a /activate endpoint. Repository activation must be done through the web UI or happens automatically on first coverage upload (depending on your Codecov configuration).
1. 401 Unauthorized Error
Check token type: Ensure you're using an API token (from Settings → Access), not an upload token
Verify the token is valid and has access to the repository
For self-hosted instances, confirm you're using the correct CODECOV_BASE_URL
2. Environment Variable Not Expanding
Make sure the variable is exported in your shell (check ~/.zshrc or ~/.bashrc)
Restart Claude Code after setting environment variables
Verify the variable exists: echo $CODECOV_TOKEN
3. Connection Failed
Restart Claude Code or Claude Desktop
Verify environment variables are set correctly: echo $CODECOV_TOKEN
Check the configuration: claude mcp get codecov
4. HTTP vs HTTPS
Always use https:// for the CODECOV_BASE_URL, not http://:
Correct: https://your-codecov-instance.com
Incorrect: http://your-codecov-instance.com
For self-hosted Codecov instances, use your instance URL:
claude mcp add --transport stdio codecov \
--env CODECOV_BASE_URL=https://codecov.your-company.com \
--env CODECOV_TOKEN=${CODECOV_TOKEN} \
-- npx -y @egulatee/mcp-codecovAdd to your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"codecov": {
"command": "npx",
"args": ["-y", "@egulatee/mcp-codecov"],
"env": {
"CODECOV_BASE_URL": "https://codecov.io",
"CODECOV_TOKEN": "your-codecov-token-here"
}
}
}
}Add to ~/.claude.json:
{
"mcpServers": {
"codecov": {
"command": "npx",
"args": ["-y", "@egulatee/mcp-codecov"],
"env": {
"CODECOV_BASE_URL": "https://codecov.io",
"CODECOV_TOKEN": "${CODECOV_TOKEN}"
}
}
}
}Notes:
Environment variable expansion is supported using ${VAR} syntax
Variables like ${CODECOV_TOKEN} will be read from your shell environment
The -y flag for npx automatically accepts the package installation prompt
Pull and run the official multi-platform image from GitHub Container Registry:
docker run --rm -i \
-e CODECOV_TOKEN=your_token \
ghcr.io/egulatee/mcp-server-codecovPlatforms: linux/amd64 and linux/arm64 (Apple Silicon, AWS Graviton)
Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"codecov": {
"command": "docker",
"args": [
"run", "--rm", "-i",
"-e", "CODECOV_TOKEN=your_token",
"ghcr.io/egulatee/mcp-server-codecov"
]
}
}
}With self-hosted Codecov:
docker run --rm -i \
-e CODECOV_TOKEN=your_token \
-e CODECOV_BASE_URL=https://codecov.your-company.com \
ghcr.io/egulatee/mcp-server-codecovAvailable tags: latest, 2, 2.1, 2.1.0 (full semver)
stdio bridge with socat:
The Docker image includes socat, which allows MCP clients that communicate over stdio to connect to the server running inside a container via a TCP socket:
# Start the server exposing a TCP port
docker run --rm -p 3000:3000 \
-e CODECOV_TOKEN=your_token \
ghcr.io/egulatee/mcp-server-codecov
# Bridge stdio ↔ TCP in a second terminal (or from your MCP client config)
socat TCP:localhost:3000 STDIONote:
socatmust also be installed on the host machine running the bridge command. Install withbrew install socat(macOS),apt install socat(Debian/Ubuntu), orapk add socat(Alpine).
npm install -g @egulatee/mcp-codecovBenefits:
Simple one-command installation
Automatic updates with npm update -g @egulatee/mcp-codecov
No manual build steps required
Works across all projects
Verify installation:
npm list -g @egulatee/mcp-codecov
which mcp-codecov
npm view @egulatee/mcp-codecov versionOnly use this method if you're contributing to the project:
git clone https://github.com/egulatee/mcp-server-codecov.git
cd mcp-server-codecov
npm install
npm run buildThen configure with the built path:
Claude Code CLI:
claude mcp add --transport stdio codecov \
--env CODECOV_BASE_URL=https://codecov.io \
--env CODECOV_TOKEN=${CODECOV_TOKEN} \
-- node /absolute/path/to/codecov-mcp/dist/index.jsManual (~/.claude.json):
{
"mcpServers": {
"codecov": {
"command": "node",
"args": ["/absolute/path/to/codecov-mcp/dist/index.js"],
"env": {
"CODECOV_BASE_URL": "https://codecov.io",
"CODECOV_TOKEN": "${CODECOV_TOKEN}"
}
}
}
}Claude Desktop:
{
"mcpServers": {
"codecov": {
"command": "node",
"args": ["/path/to/mcp-server-codecov/dist/index.js"],
"env": {
"CODECOV_BASE_URL": "https://codecov.io",
"CODECOV_TOKEN": "your-codecov-token-here"
}
}
}
}This project maintains 97%+ code coverage with comprehensive unit tests using Vitest.
For detailed testing documentation, including how to run tests, coverage requirements, CI integration, and writing tests, see TESTING.md.
# Install dependencies
npm install
# Build the project
npm run build
# Watch mode for development
npm run watchThis project uses an automated release workflow via GitHub Actions. Releases are published to npm automatically when you push a version tag.
For detailed release instructions, including prerequisites, creating releases, manual releases, and version numbering, see RELEASE.md.
This server uses Codecov's API v2. The API endpoints follow this pattern:
File coverage: /api/v2/gh/{owner}/repos/{repo}/file_report/{file_path}
Commit coverage: /api/v2/gh/{owner}/repos/{repo}/commits/{commit_sha}
Repository coverage: /api/v2/gh/{owner}/repos/{repo}
Pull request coverage: /api/v2/gh/{owner}/repos/{repo}/pulls/{pull_number}
Coverage comparison: /api/v2/gh/{owner}/repos/{repo}/compare/{base}...{head}
Currently supports GitHub repositories (gh). Support for other providers (GitLab, Bitbucket) can be added by modifying the API paths.
📝 Building the Codecov MCP Server in 2 Hours - A detailed walkthrough of developing this server using AI-augmented development techniques
MIT
Compare coverage between two git references (branches, commits, or tags).
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (username or organization) | |
| repo | Yes | Repository name | |
| base | Yes | Base reference (e.g., 'main', commit SHA) | |
| head | Yes | Head reference to compare against base |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should disclose behavioral traits. It only states what the tool does, not what the output is, whether it's a read or write operation, or any side effects. The agent is left guessing about return format and safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single 10-word sentence is highly concise and front-loaded. It could include a bit more detail (e.g., output nature) without losing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is insufficient. It does not explain what the comparison result contains (e.g., diff, summary), leaving a significant gap for a tool with 4 required parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter described in the input schema. The description does not add new parameter insights, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'compare coverage between two git references', which is a specific verb and resource. It distinguishes from siblings like get_commit_coverage (single commit) and get_repo_coverage (single repo) by focusing on comparison of two references.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for comparing two references but provides no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives or exclude cases like single reference queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get coverage data for a specific commit, including overall coverage percentage and file-level changes.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (username or organization) | |
| repo | Yes | Repository name | |
| commit_sha | Yes | Commit SHA to get coverage for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the tool returns data, but does not disclose read-only nature, authentication requirements, rate limits, or error behavior. Basic but insufficient for a tool with no other metadata.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no extraneous words. It front-loads the core purpose and instantly communicates the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with three parameters and no output schema, the description adequately covers what the tool does and what it returns. However, without output schema, more detail on the structure of 'file-level changes' could be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters. The description does not add any additional meaning beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'coverage data for a specific commit', including what is returned (overall coverage percentage and file-level changes). This effectively distinguishes from siblings like 'get_file_coverage' or 'get_repo_coverage'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for a specific commit, but does not explicitly state when to use it over siblings like 'compare_coverage' or 'get_pull_request_coverage'. No exclusions or when-not guidance provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get line-by-line coverage data for a specific file in a repository. Returns coverage percentages and line-level hit/miss information.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (username or organization) | |
| repo | Yes | Repository name | |
| file_path | Yes | Path to the file within the repository (e.g., 'src/index.ts') | |
| ref | No | Git reference (branch, tag, or commit SHA). Defaults to default branch if not specified. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only states it returns data, but doesn't disclose any behavioral traits like potential for missing ref errors, pagination, or performance. Could mention that it reads from repository and may be slow for large files.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundancy. Front-loaded with purpose, then return info. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should compensate with details on return structure. It mentions 'coverage percentages and line-level hit/miss information' but doesn't specify exact fields or format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in schema. Description adds no extra meaning beyond 'specific file'. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'Get' and resource 'line-by-line coverage data for a specific file'. It distinguishes from sibling tools like 'compare_coverage' and 'get_repo_coverage' by focusing on a single file.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied ('for a specific file'), but no explicit guidance on when to use this over alternatives (e.g., compare_coverage for comparing branches). No when-not-to-use or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get coverage data for a specific pull request, including coverage changes and file-level impact.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (username or organization) | |
| repo | Yes | Repository name | |
| pull_number | Yes | Pull request number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It implies a read operation ('get') and mentions the data included, but does not explicitly state it is non-destructive, nor does it disclose error conditions or permissions needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single well-structured sentence that is front-loaded with the core action and resource, containing no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple data retrieval tool with three well-schemaed parameters, the description conveys the key output (coverage changes and file-level impact) and scope. It could be improved by specifying return format or linking to an output schema, but it is sufficient for its simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides clear descriptions for all three parameters (100% coverage). The description adds no additional meaning to the parameters beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the verb 'Get', the resource 'coverage data for a specific pull request', and the scope 'including coverage changes and file-level impact', clearly distinguishing it from siblings like get_repo_coverage or get_commit_coverage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for pull request coverage but does not explicitly mention when to avoid it or compare to alternatives such as compare_coverage. It provides clear context for its intended use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get overall coverage statistics for a repository, optionally for a specific branch.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (username or organization) | |
| repo | Yes | Repository name | |
| branch | No | Branch name (defaults to repository's default branch) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description only states it retrieves statistics without disclosing side effects, required permissions, api limits, or performance implications. Minimal behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no redundant information. Purpose is front-loaded and every word contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, description does not specify what 'overall coverage statistics' includes (e.g., line coverage, branch coverage). Could be more complete to set agent expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with descriptions. The description adds semantic value by noting the branch parameter defaults to the repository's default branch, which is not evident from the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('get'), resource ('overall coverage statistics for a repository'), and an optional parameter (branch). It effectively distinguishes from sibling tools that focus on comparisons, commits, files, or pull requests.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like compare_coverage or get_commit_coverage. Lacks explicit context for selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v2.4.0compare_coverageget_commit_coverageget_file_coverageget_pull_request_coverageget_repo_coverageEach tool targets a distinct coverage aspect: repo, commit, file, pull request, or comparison between references. No functional overlap.
All tools follow a clear verb_noun pattern (get_<entity>_coverage, compare_coverage), with no mixing of styles.
Five tools cover the essential coverage operations for a code coverage server, neither too few nor excessive.
Covers repo, commit, file, PR, and comparison coverage queries. Minor gap: no tool for listing commits or historical trends, but core use cases are well supported.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Query your OpsLevel internal developer portal: catalog, maturity data, and tech docs.
Query Honeycomb observability data: traces, events, metrics, SLOs, triggers, and boards.
Access the GitHub API, enabling file operations, repository management, search functionality, and…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/egulatee/mcp-server-codecov'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
