wan-mcp

Server Quality Checklist

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

Latest release: v0.1.9
Disambiguation4/5
Most tools have clearly distinct purposes: login, pricing, task status, and six different task creation types. The main potential confusion is between 'animate' and other creation tools, but descriptions clarify the specific task type.
Naming Consistency4/5
The naming pattern is mostly verb_noun with underscores (get_task, check_pricing, image_to_video, etc.). However, 'animate' breaks the pattern by being just a verb, and 'login' is not verb_noun either, creating minor inconsistency.
Tool Count5/5
Nine tools is well-scoped for a video/image generation server: one auth, one pricing, one status retrieval, and six creation endpoints. Each tool serves a distinct purpose without redundancy.
Completeness4/5
The core workflow is covered: login, create tasks via multiple modes, and check task status/results. Missing list/cancel/delete operations could be minor gaps, but the main task lifecycle is sufficiently covered.
Average 3.1/5 across 9 of 9 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 13 commits in the last 12 weeks
- Last stable release on July 31, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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?
With no annotations, the description must disclose behavioral traits, but it only mentions the return values ('task id, status, and output URLs'). It does not explain that this is an asynchronous task creation, how the 'wait' parameter affects execution, whether it modifies resources, or any rate limits or safety implications. This leaves significant behavioral ambiguity.
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 that gets straight to the point. It efficiently states the action and the primary return values without filler. However, given the tool's complexity, the brevity may be excessive, but as a concise statement it earns a high score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a 9-parameter task-creation tool with no output schema and no annotations, yet the description is only one sentence. It does not cover input/output details, asynchronous behavior, or any operational context. For a tool of this complexity, the description is completely inadequate, leaving the agent without essential information to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides zero information about the 9 parameters, and schema description coverage is only 22%. It does not explain the required parameters (source_image_url, reference_video_url) or options like output_resolution, model, or wait. The description fails to compensate for the low schema coverage, leaving parameter meaning largely undocumented.
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 tool's action: 'Create a Wan task on RunAPI (animate)' and specifies the return values: 'task id, status, and output URLs.' This distinguishes it from sibling tools like text_to_video or image_to_video by emphasizing the Wan model and animation focus, though it could be more explicit about the animation-specific use case.
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 provides no guidance on when to use this tool versus alternatives like image_to_video or text_to_video. It does not mention prerequisites, use cases, or situations where another tool would be more appropriate, leaving the agent to infer usage from the tool name alone.
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 provided, the description must disclose behavioral traits. It mentions task creation and return values, but omits crucial behaviors like asynchronous task processing (requiring polling via get_task), reliance on specific input parameters (e.g., source_video_url), potential side effects, or rate limits. The phrase 'Create a Wan task' hints at asynchrony but does not clarify the wait/polling mechanism.
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 concise single sentence that front-loads the purpose and key outputs. It avoids unnecessary verbosity. While it is sparse, the brevity is appropriate for this dimension, and the structure uses a clear cause-effect format: what it does and what it returns.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (20 parameters, no annotations, no output schema), the description is far from complete. It does not explain required inputs, the asynchronous workflow, output format details, or how it interacts with sibling tools like get_task. An agent cannot correctly invoke this tool based solely on the description and schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is only 10% (2 of 20 parameters have descriptions). The tool description adds no parameter explanations whatsoever, leaving critical inputs such as source_video_url, prompt, duration_seconds, and output_resolution undefined. This is inadequate for a 20-parameter tool; the description must compensate for schema gaps but does not.
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 clearly states the tool's function: 'Create a Wan task on RunAPI (edit video).' It specifies the verb ('Create'), resource ('Wan task on RunAPI'), and scope ('edit video'), differentiating it from sibling tools like text_to_video and image_to_video. The return values (task id, status, output URLs) are also explicitly mentioned.
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 description implies the tool is for editing videos via the parenthetical '(edit video)', but it does not explicitly state when to use it versus alternatives or provide exclusions. There is no mention of prerequisites, such as needing a source video, or when a different tool (e.g., text_to_video) would 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 provided, the description carries the full burden. It mentions creating a task and returning a task id, status, and output URLs, hinting at asynchronous behavior, but fails to disclose auth requirements, side effects, cost implications, or the nature of the task creation. This is minimal and leaves critical behavioral questions unanswered.
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 that efficiently communicates the tool's core action and return value. It contains no unnecessary verbiage, though its brevity comes at the cost of substance. As a concise statement, it is appropriately sized, but not particularly detailed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 23 parameters, no output schema, and no annotations, this description is grossly incomplete. It explains almost nothing about the task lifecycle, required inputs, available models, or result structure. Agents would be left guessing about how to properly invoke and interpret the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 9% (2 of 23 parameters described). The description adds no parameter details whatsoever, leaving the agent without any understanding of key parameters like prompt, seed, aspect_ratio, or output_resolution. The description fails to compensate for the sparse schema information.
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 clearly states the verb 'Create', the resource 'Wan task on RunAPI', and the specific scope '(image to video)'. It effectively distinguishes from sibling tools like text_to_video and speech_to_video through the explicit image-to-video parenthetical.
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 description implies the primary use case (image-to-video generation) but provides no explicit guidance on when to choose this tool over alternatives like text_to_video or speech_to_video. It lacks mention of exclusions or alternative tool recommendations.
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?
No annotations are provided, so the description carries the transparency burden. It reveals the async task-based nature and mentions the return fields (task id, status, output URLs). However, it omits important behavioral context such as cost implications, authentication requirements, safety checker defaults, or rate limiting.
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, efficient sentence with no filler or repetition. It clearly states purpose and return values, though it could be more expansive given the tool's complexity. As conciseness measures efficiency, it scores well despite being underspecified.
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 17 parameters, no annotations, and no output schema, the description is far from complete. It does not explain the many optional parameters, default behavior, or potential pitfalls, making it insufficient for an agent to use this tool correctly in a real scenario.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 12% (only wait and model have descriptions). The description itself adds no parameter semantics for the other 15 parameters, leaving the agent to guess the meaning and usage of fields like bbox_list, color_palette, thinking_mode, and enable_sequential.
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 action ('Create a Wan task on RunAPI') with a clear resource ('text to image') and return values (task id, status, output URLs). It distinguishes this from sibling tools like text_to_video or image_to_video by explicitly naming the text-to-image use case.
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 alternatives such as text_to_video or animate. No prerequisites, exclusions, or typical use cases are mentioned, leaving the agent to infer usage from the name alone.
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 provided, the description carries the full burden of behavioral disclosure. It mentions the return value (task id, status, output URLs) but does not disclose that this is an asynchronous operation, potential side effects like costs or rate limits, or prerequisites such as authentication. The absence of these details for a task-creating tool 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no waste, but it is under-specified for a tool with 21 parameters and complex behavior. It is concise but not appropriately sized to convey necessary information, making it borderline adequate.
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 the high complexity (21 parameters, no output schema, no annotations), the description is far from complete. It only covers the high-level purpose and return format, omitting usage context, parameter guidance, and behavioral details that are critical for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 10%, so the description must compensate by explaining key parameters. It does not mention any parameter semantics, leaving most of the 21 parameters undocumented in both the schema and description. This fails to add meaningful value beyond the bare 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 ('Create') and resource ('Wan task on RunAPI') with an explicit scope ('text to video'). It clearly distinguishes this from sibling tools like image_to_video and speech_to_video by naming the modality.
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 description implies this tool is for text-to-video generation, but it does not explicitly state when to use it over alternatives or provide exclusions. The context signals show many sibling tools, so more guidance on selection would be helpful, but the purpose is clear enough that usage is implied.
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. While 'fetch' implies a read operation, the description doesn't state that it is read-only, how errors are handled (e.g., task not found), or whether any authentication is required. This is minimal at best.
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 zero filler. It states the action and the object of the action efficiently, earning a perfect score for conciseness.
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?
With no output schema, the description should explain return values more thoroughly. It mentions status and latest result payload but doesn't address possible states like 'running' or 'failed,' nor does it clarify what happens when no payload exists. Adequate but incomplete for a status-checking tool.
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% with both parameters already described. The description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate; it does not enhance understanding of task_id or action.
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 'Fetch' and clearly names the resource: 'current status and latest result payload for a wan task.' This distinguishes it from sibling creation tools like text_to_video and animate, which are clearly not retrieval operations.
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 explicit guidance on when to use this tool vs. alternatives. The description does not mention that it should be used after creating a task or that it is the polling mechanism for async operations, leaving the usage context implied rather than stated.
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 full burden. It discloses that the tool creates a task and returns a task id, status, and output URLs, which implies an asynchronous workflow. However, it does not mention side effects, safety, permissions, or the task lifecycle beyond the return values.
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 two sentences, front-loaded with the primary action, and contains no redundant information. Every word contributes to understanding the tool's core purpose and output.
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 tool with 17 parameters, no annotations, and no output schema, the description is severely lacking. It does not explain the task-based workflow, polling behavior (wait parameter), callback_url usage, or any prerequisites. The agent would struggle to invoke this correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 12%, with only wait and model having descriptions. The tool description does not explain any parameters, including the required source_image_url, source_audio_url, and prompt. It adds minimal value beyond the schema, leaving 88% of parameters underspecified.
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 clearly states the verb 'Create' and the resource 'Wan task', and explicitly identifies it as 'speech to video'. This distinguishes it from sibling tools like image_to_video and text_to_video, making the purpose unambiguous.
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 alternatives such as image_to_video or text_to_video. No context or exclusions are provided, leaving the agent to infer usage solely from the name.
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 full burden. It only says 'look up pricing' without mentioning behavioral details such as default parameter behavior (e.g., defaults to primary model and endpoint), output format, or any constraints like rate limits or authentication needs.
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 that conveys the core purpose efficiently. However, slightly more detail could be added without losing conciseness.
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?
For a simple lookup tool, the description is adequate but lacks details about the output format and any potential edge cases. Given the absence of an output schema, the description could be more complete.
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 parameters are fully documented in the schema. The description adds no additional meaning beyond what the schema already provides, meeting the baseline expectation.
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 clearly states the specific action 'look up pricing' and the resource 'RunAPI pricing for the wan model line'. This distinguishes it from sibling tools which are focused on content generation or task retrieval.
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?
No explicit guidance on when to use this tool versus alternatives is provided. While it is the only pricing tool among siblings, the description does not clarify usage context or exclusions.
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?
No annotations are provided, so the description carries the full burden. It discloses opening a browser, performing PKCE flow, and saving a config file. However, it does not mention side effects (e.g., overwriting existing config), whether the tool blocks, or security implications. Adequate but not exhaustive.
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 sentence with no wasted words. It efficiently conveys the main action (authentication) and key detail (config file location).
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 simple tool with one optional boolean parameter and no output schema, the description covers the process (browser, PKCE, config save) and parameter behavior. It lacks mention of return value or error cases, but these are implied given the tool's nature.
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% (one parameter with description). The description does not add meaning beyond the schema; it repeats the parameter's purpose. Baseline 3 is appropriate.
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 clearly states it authenticates RunAPI via a PKCE login flow and saves the API key to a specific config file. The verb 'Authenticate' and resource 'RunAPI' are specific, and the method (browser PKCE flow) distinguishes it from sibling tools which are unrelated (animate, check_pricing, etc.).
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 description implies the tool is used for authentication before other tools, but it does not explicitly state when to use it versus alternatives, nor does it provide exclusions or prerequisites. Given no sibling overlaps, it's adequate but lacks explicit guidance.
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

Copy to your README.md:

[![wan-mcp MCP server](https://glama.ai/mcp/servers/runapi-ai/wan-mcp/badges/card.svg)](https://glama.ai/mcp/servers/runapi-ai/wan-mcp)

Score Badge

Copy to your README.md:

[![wan-mcp MCP server](https://glama.ai/mcp/servers/runapi-ai/wan-mcp/badges/score.svg)](https://glama.ai/mcp/servers/runapi-ai/wan-mcp)

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/runapi-ai/wan-mcp'

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