Confluence API Docs MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation2/5
The tool set contains overlapping functions, particularly create_api_doc and sync_swagger_to_confluence, which both handle Swagger/OpenAPI imports with unclear distinctions. Similarly, create_api_doc and create_api_doc_from_controller differ only by source but share the 'create' prefix, causing potential misselection. The generic page operations are distinct, but the API documentation tools blur boundaries.
Naming Consistency3/5
Most tools follow a verb_noun pattern (e.g., list_spaces, get_page, delete_page), but sync_swagger_to_confluence breaks this convention with an irregular long phrase. Additionally, create_api_doc and create_api_doc_from_controller inconsistently encode the source (one has a suffix, the other does not), reducing predictability.
Tool Count4/5
With 9 tools, the server is reasonably scoped for managing Confluence pages and API documentation. The count is not excessive, though some redundancy among Swagger/OpenAPI tools makes it feel slightly heavier than necessary.
Completeness4/5
The core CRUD operations for pages are covered (create, read, update, delete), along with search and space listing. API documentation generation supports multiple sources (Swagger, NestJS) and nested pages via sync. Missing minor features like version history or publishing workflows, but no critical gaps for the stated domain.
Average 3.1/5 across 9 of 9 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden, yet it is a single sentence. It conveys that a page is created but does not disclose whether the operation is idempotent, whether an existing page with the same title is overwritten or duplicated, or whether swaggerSource must be reachable from the server. For a mutating tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single 12-word sentence with zero filler; the verb and object are front-loaded. Every word earns its place and nothing extraneous is included.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter mutation tool with no annotations, no output schema, and a near-twin sibling, the description is too thin. It omits default filter behavior (does omitting filterTags/filterPaths import all endpoints?), the on-success result, and re-run semantics. An agent gets schema help for parameters but no decision help for tool selection or operational expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%: every parameter (swaggerSource, spaceKey, title, filterTags, filterPaths, parentPageId) already carries an inline description, including optionality and defaults. The tool description adds no parameter meaning beyond the schema, which matches the baseline-3 rule for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Create'), a concrete deliverable ('new API documentation page'), and the input source ('from a Swagger/OpenAPI specification'). The source phrase implicitly distinguishes it from the controller-based sibling create_api_doc_from_controller, but it does not explicitly differentiate it from sync_swagger_to_confluence, which also ingests Swagger specs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to choose this tool over siblings. Nothing clarifies whether to prefer this over create_api_doc_from_controller (controller source), update_api_doc (page already exists), or sync_swagger_to_confluence, nor whether re-running creates duplicates. An agent selecting between the two create variants must rely on name-guessing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears the full responsibility for behavioral disclosure. It states a creation action but does not mention side effects, whether the tool is idempotent, what happens if a page with the same title exists, or any permission requirements. This is insufficient for a mutation tool that creates a resource.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence with no filler words or redundant information. It states the action and source directly, earning its place without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With seven parameters, no output schema, and no annotations, this terse description leaves significant gaps. It omits behavioral details, return/result information, and any guidance about how controller files are processed. The schema covers parameters well, but the overall tool context is under-specified for a complex operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All seven parameters are already documented in the input schema, so the baseline for parameter semantics is met. The description's mention of 'NestJS controller files' adds a tad of context about controllerPath, but it mostly restates what the schema already conveys. No additional parameter-specific insights are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb (create), resource (new API documentation page), and source (NestJS controller files), so an agent immediately understands the action. However, it does not differentiate this from sibling create_api_doc or update_api_doc_from_controller, since the description does not state what distinguishes creation from controller files vs. other sources or updating.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus siblings like create_api_doc or update_api_doc_from_controller. The phrase 'from NestJS controller files' implies a use case but provides no explicit conditions, exclusions, or alternative routing. An agent must infer when creation is appropriate rather than an update.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the action implied by the tool name and does not mention irreversibility, cascading effects on child pages, authentication requirements, or any other side effects of deletion.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It is appropriately concise for such a simple operation, though it is arguably too spare to add much value beyond the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no annotations and no output schema, the description is too minimal. An agent cannot determine whether deletion is permanent, whether related content is affected, or what response to expect on success or failure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents pageId with 100% coverage and a clear description. The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the operation ('Delete') and the resource ('a Confluence page'), making the tool's purpose immediately understandable. It distinguishes itself from siblings like get_page, create_api_doc, and update_api_doc, though it is terse and does not clarify whether deletion is soft or permanent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives, nor any conditions or exclusions. It does not mention prerequisites like permissions, whether deletion is reversible, or when a sibling tool might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Search for existing pages.' It does not mention whether the search covers titles, bodies, or both, whether results are paginated, or what the return shape is. The read-only nature is implied but not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single six-word sentence with no redundancy or filler, and the core action is front-loaded. It could have included a brief usage note or scope clarification without becoming bloated, so it is concise but not maximally useful in structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple 2-parameter tool with no nested objects and full schema coverage, so the basic invocation is clear. However, since there is no output schema, the description does not explain what the search returns, and there is no mention of search semantics or result limits. Adequate for a basic call, but incomplete for confident use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are already documented in the schema. The tool description adds no extra meaning to query or spaceKey, but it does align with the search action. A baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Search') and resource ('existing pages in Confluence'), so an agent understands this is a lookup-by-query tool. However, it does not explicitly distinguish it from siblings like get_page or list_spaces, so it stops short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to prefer search_pages over get_page or list_spaces, and no exclusions or alternative suggestions. The schema mentions spaceKey as an optional filter, but the description does not explain when that filter matters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It states 'sync' and optional nested pages, but does not disclose whether existing pages are updated or overwritten, whether removed spec items are deleted, or what side effects a sync may have.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the core operation, and contains no filler. It could have included more behavioral detail, but as written it is compact and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 parameters, no annotations, no output schema, and several overlapping sibling tools, one sentence is not enough for an agent to safely invoke this tool. The description does not clarify sync semantics, behavior for existing pages, or page-organization outcomes sufficiently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already well documented and the baseline is 3. The description adds only the notion of nested pages, loosely tied to parentPageId/groupBy, but provides no additional parameter-level meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb (sync), a source (Swagger/OpenAPI spec), and a target (Confluence), and adds optional nested-page creation. It is clear about the core operation, though it does not explicitly differentiate it from sibling tools like create_api_doc or update_api_doc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool instead of the similarly purposed create_api_doc, update_api_doc, or controller-based siblings. Usage context is only implied by the source type, with no alternatives, exclusions, or conditions stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description carries the full burden of behavioral disclosure. It indicates the page will be modified, but it does not state whether the page content is overwritten wholesale, whether existing non-generated content is preserved, whether a new Confluence version is created, or what permissions/errors are involved.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single focused sentence with no filler or redundant wording. It puts the core action and target resource up front, making it easy for an agent to grasp quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutating tool with no annotations and no output schema, the description is incomplete: it omits the optional filtering behavior, the effect on page content, and how a successful update is communicated. Sibling differentiation is also absent, so an agent cannot confidently choose this over similar update/sync tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all four parameters, so the baseline is 3. The description adds a little meaning by tying 'existing page' to pageId and 'new spec' to swaggerSource, but it adds nothing about filterTags or filterPaths.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Update'), a clear resource ('an existing API documentation page'), and the input type ('new Swagger/OpenAPI spec'). It clearly distinguishes update-from-create by saying 'existing', but it does not distinguish this tool from sibling 'update_api_doc_from_controller' or 'sync_swagger_to_confluence'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrasing implies this tool is for refreshing an already-created Confluence API doc page when a new spec is available. However, it gives no explicit when-not-to-use guidance, no prerequisites, and does not mention alternatives like create_api_doc or update_api_doc_from_controller.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing side effects. It states the update action but does not explain whether the existing page content is replaced, merged, or preserved, nor does it mention authentication requirements or failure behavior. This is a significant gap for a mutating operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the core action and resource. Every word earns its place, with no padding or redundant restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a mutation tool with no annotations and no output schema, the description is too thin. It fails to disclose the overwrite/merge behavior of the update or provide any operational context such as whether the page must exist or what happens to unspecified content. Parameter documentation is solid, but the behavioral context is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter already has a meaningful description in the schema. The tool description adds little beyond echoing the controller-file concept already present in controllerPath. Per baseline, a 3 is appropriate when the schema carries the parameter documentation load.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Update'), a specific resource ('existing API documentation page'), and a specific input source ('NestJS controller files'). This distinguishes it clearly from the sibling create_api_doc_from_controller and from Swagger-based tools like sync_swagger_to_confluence.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to choose this tool versus alternatives such as update_api_doc or create_api_doc_from_controller. The agent must infer from the tool name and description that this is for updating existing pages from controller files, with no explicit conditions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 discloses that this is a read operation and that the page must already exist, but it does not clarify what 'content' includes (body, metadata, attachments) or how missing/invalid pages are handled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no wasted words, and the core action is front-loaded. It is concise without sacrificing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, but with no output schema and no annotations, the vague term 'content' leaves questions about return format and error behavior. It is minimally adequate but has clear gaps in routing and expected output details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the single pageId parameter. The description adds no parameter-specific meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('get') and resource ('content of an existing Confluence page'). This clearly distinguishes it from sibling create/update/delete/list/search operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied: when you need the content of an existing page. However, there is no explicit guidance on when to choose this over search_pages or list_spaces, nor any mention of how to obtain the pageId.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. 'List all available Confluence spaces' indicates a read-only operation and implies permission-based availability, but it does not disclose output shape, pagination, or ordering. This is acceptable for a simple list but not deeply informative.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. Every word contributes meaning and the core operation is immediately visible.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool, the description is nearly sufficient for an agent to invoke it correctly. It lacks details about the returned fields or limits, but the absence of parameters and the simple read-only nature keep the requirements minimal.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty with 100% coverage, so there are no parameters requiring explanation. The description appropriately handles this by focusing on the operation itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('all available Confluence spaces'), making the function unambiguous. It is clearly distinct from the sibling page- and doc-focused tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to choose list_spaces over alternatives, nor any mention of exclusions or use cases. The intended context must be inferred entirely from the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Confluence API Docs MCP Server MCP server — quality and maintenance score on Glama

Copy to your README.md:

[![Confluence API Docs MCP Server MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/saleshandy/saleshandy-confluence-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/saleshandy/saleshandy-confluence-mcp-server)

Score Badge

Copy to your README.md:

[![Confluence API Docs MCP Server MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/saleshandy/saleshandy-confluence-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/saleshandy/saleshandy-confluence-mcp-server)

shields.io Endpoint

For READMEs with an existing badge row. Append &style=flat-square (or any other shields.io style) to match the rest, and &metric=tools, &metric=maintenance or &metric=claim to badge a different dimension.

[![Confluence API Docs MCP Server MCP server — quality and maintenance score on Glama](https://img.shields.io/endpoint?url=https%3A%2F%2Fglama.ai%2Fmcp%2Fservers%2Fsaleshandy%2Fsaleshandy-confluence-mcp-server%2Fbadges%2Fshields.json)](https://glama.ai/mcp/servers/saleshandy/saleshandy-confluence-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/saleshandy/saleshandy-confluence-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server