This server enables AI agents to generate and manage videos using Runway models on RunAPI, with the following capabilities:
Generate videos from text (text_to_video): Create a Runway text-to-video task by providing a prompt, duration (5 or 10 seconds), output resolution (720p or 1080p), aspect ratio (16:9, 9:16, 1:1, 4:3, 3:4), and optionally a first frame image URL.
Extend existing videos (extend_video): Create a Runway extend-video task referencing an existing task, with configurable output resolution (720p or 1080p).
Poll task status (get_task): Fetch the current status and latest result payload (including output URLs) for a previously created task using its task ID.
Check pricing (check_pricing): Look up the current pricing snapshot for a specific endpoint (extend_video or text_to_video) — no API key required.
Flexible execution control: All creation tools support a wait flag to block until the task completes or return immediately with a task ID, plus configurable timeout_ms and poll_interval_ms for fine-tuned polling behavior.
All task creation tools require a RunAPI API key; check_pricing does not.
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., "@runway-mcp create a 5-second video of a cat dancing"
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.
@runapi.ai/runway-mcp is a focused Model Context Protocol server for the Runway model line on RunAPI.
It gives MCP-compatible assistants direct access to 2 endpoints and 1 model variant without loading the full RunAPI catalog.
Use this per-model server when an agent should stay scoped to Runway. Use @runapi.ai/mcp when one assistant should discover every RunAPI model line.
Related MCP server: kling-mcp
Add it to Claude Code:
claude mcp add runway -s user -- npx -y @runapi.ai/runway-mcpUse project scope when the server should be shared with a repository:
claude mcp add runway -s project -- npx -y @runapi.ai/runway-mcpCodex, Cursor, Windsurf, VS Code, Roo Code, and other MCP hosts can use the same stdio command:
{
"mcpServers": {
"runway": {
"command": "npx",
"args": ["-y", "@runapi.ai/runway-mcp"]
}
}
}check_pricing works before sign-in. For task creation and status polling, ask your assistant to call the login tool. It opens a browser login and saves credentials to ~/.config/runapi/config.json, the same file used by runapi login.
Headless and CI hosts can still set RUNAPI_API_KEY before starting the MCP host.
Ready-made examples are in examples/ for Claude, Cursor, Windsurf, VS Code, and Roo Code.
Tool | Auth | Purpose |
| Yes | Create a Runway extend video task and optionally wait for a terminal status. Returns the task id, status, and output URLs. |
| Yes | Create a Runway text to video task and optionally wait for a terminal status. Returns the task id, status, and output URLs. |
| Yes | Fetch the current status and latest payload for an existing task. |
| No | Look up current pricing for a Runway model and endpoint. |
Runway covers 1 model variant across 2 endpoints. Each tool accepts the models listed for it:
Tool | Models |
|
|
|
|
Model availability can change between releases. Use check_pricing or the Runway model page for the current catalog view.
Ask your assistant in natural language; it can inspect pricing, create the task, and return the task id plus output URLs.
Run a Runway extend video task with RunAPI.The assistant can call check_pricing, then extend_video, and return the task id, status, and output URLs.
Create the task but don't wait for it to finish.The assistant calls the create tool with wait: false and returns the task id. Check on it later with get_task.
Check current Runway pricing, then create the task if it matches my request.The assistant calls check_pricing and can link to the Runway model page for the canonical catalog entry.
The server resolves auth in this order:
RUNAPI_API_KEY environment variable, useful for headless and CI hosts
~/.config/runapi/config.json, created by the MCP login tool or runapi login
No key, which still allows check_pricing
The config file is normally managed by login. A pre-provisioned headless config can use:
{
"apiKey": "your_runapi_key"
}Do not commit real API keys.
Resource | URL |
Runway model page | |
npm package | |
GitHub repository | |
RunAPI MCP overview | |
RunAPI docs |
Licensed under the Apache License, Version 2.0.
Look up RunAPI pricing for the runway model line.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Model slug. Defaults to the line's primary model. | |
| action | No | Endpoint name. Defaults to the endpoint that offers the model. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries full burden but only states it's a lookup operation. It omits any behavioral traits like authentication needs, rate limits, or output format.
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 sentence with no unnecessary words. It is appropriately concise, though could incorporate more context without sacrificing brevity.
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 lookup tool with two optional parameters and no output schema, the description sufficiently explains the purpose. It could note default behaviors, but the schema handles that.
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%, so the schema fully documents both parameters. The description adds no extra meaning beyond what the schema's enum descriptions already provide.
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 ('look up RunAPI pricing') and specific resource ('runway model line'), distinguishing it from sibling tools which deal with video generation.
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 pricing lookups but provides no explicit guidance on when to use it over siblings or any exclusions/alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a Runway task on RunAPI (extend video). Returns a task id, status, and output URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| wait | No | Poll until the task reaches a terminal status. | |
| model | No | RunAPI model slug for this model line. | |
| prompt | Yes | ||
| watermark | No | ||
| timeout_ms | No | ||
| callback_url | No | ||
| source_task_id | Yes | ||
| poll_interval_ms | No | ||
| output_resolution | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It states the tool returns a task id, status, and output URLs, which hints at asynchronous behavior, but it does not disclose that the task may initially be pending, that wait/polling parameters exist, or that this is a paid/compute-consuming operation. Minimal behavioral context is provided.
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, front-loaded sentence with no wasted words. It efficiently conveys the primary action and return behavior. Excellent conciseness.
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?
Despite having 9 parameters, 3 required, no output schema, and no annotations, the description provides only the basic purpose and return format. It lacks usage guidance, parameter explanations, and asynchronous behavior details. This is inadequate for a tool of this complexity.
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 only 22% (only wait and model have descriptions). The tool description adds no explanation for required parameters such as source_task_id, prompt, or output_resolution. It fails to compensate for the low schema coverage, leaving the agent without parameter meaning.
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 it creates a Runway task on RunAPI specifically for extending a video. The parenthetical '(extend video)' distinguishes it from the sibling text_to_video tool. However, it does not explicitly name the alternative or contrast with text_to_video, so it falls short of a perfect 5.
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 provides no guidance on when to use this tool versus alternatives like text_to_video. It does not mention any preconditions, exclusions, or specific scenarios. This is a clear gap, especially given the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the current status and latest result payload for a runway task.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Asynchronous endpoint the task was created on. | |
| task_id | Yes | Task id returned when the task was created. |
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 clearly indicates a read-only operation ('Fetch'), which implies non-mutating behavior. However, it does not disclose error handling, rate limits, or any side effects, so transparency is minimal but adequate for a simple fetch.
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 sentence with zero redundancy. It concisely states the action and target resource without unnecessary detail, earning a perfect score for conciseness.
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?
Since there is no output schema, the description should clarify what the tool returns. It mentions 'latest result payload' but is vague about the structure or additional fields. For a simple read tool with well-documented parameters, this is adequate but not comprehensive.
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 provides 100% coverage for both parameters (task_id and action) with clear descriptions. The tool description does not add any further parameter-level meaning beyond what the schema already 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with the specific verb 'Fetch' and identifies the resource as 'current status and latest result payload for a runway task.' This clearly distinguishes it from sibling tools like extend_video and text_to_video, which create tasks, 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking task status after creation via context from sibling tools, but it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The guidance is implied rather than direct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Authenticate RunAPI by opening a browser PKCE login flow and saving the API key to ~/.config/runapi/config.json.
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | Re-run browser login when the current credential comes from the local config file. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It discloses key behaviors: opens a browser, uses PKCE, saves to a config file. However, it omits details like error handling or whether it checks existing credentials.
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 sentence with no unnecessary words. It is concise and front-loaded with the action and resource.
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 the tool is a simple login with one optional parameter and no output schema, the description covers the essential action and side effect. It could mention return value or behavior on already authenticated state, but overall it is sufficient.
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% for the single parameter 'force', and the schema already describes its meaning. The description adds no further parameter context, so baseline score 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?
The description clearly states 'Authenticate RunAPI by opening a browser PKCE login flow and saving the API key' which is a specific verb and resource. It distinguishes the login tool from unrelated sibling tools like check_pricing or extend_video.
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 (need to authenticate) but does not explicitly state when to use it versus alternatives, nor does it mention prerequisites or exceptions like already being logged in. The 'force' parameter is described in the schema but not in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a Runway task on RunAPI (text to video). Returns a task id, status, and output URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| wait | No | Poll until the task reaches a terminal status. | |
| model | No | RunAPI model slug for this model line. | |
| prompt | Yes | ||
| watermark | No | ||
| timeout_ms | No | ||
| aspect_ratio | No | ||
| callback_url | No | ||
| duration_seconds | Yes | ||
| poll_interval_ms | No | ||
| output_resolution | Yes | ||
| first_frame_image_url | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the return value (task id, status, output URLs) and mentions RunAPI, but it does not explain the asynchronous nature, potential costs, or any side effects. With no annotations, the description carries the full burden and only partially fulfills it.
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 sentence that front-loads the primary action and return info. It contains no filler or redundant details.
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 an 11-parameter tool with no output schema and no annotations, this description is far from complete. It leaves critical gaps around async processing, parameter usage, and interpretation of the task status, making it inadequate for effective tool selection and invocation.
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 only 18%, so the description needed to compensate by explaining parameters. It does not, though it gives a general hint that 'prompt' is the text input. Optional parameters like wait, timeout_ms, and callback_url remain unexplained.
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 ('Create') and the resource ('Runway task'), with the parenthetical 'text to video' specifying the modality. It distinguishes from siblings like extend_video and get_task by focusing on creation.
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 generating a new video from text, but provides no explicit guidance on when to use it vs. alternatives like extend_video or get_task. It does not mention exclusions or the optional waiting behavior.
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.
v0.1.7extend_video5 fields changedInput schema / properties / callback_urlAdded value: +{
+ "type": "string"
+}Input schema / properties / prompt / typeAdded value: +"string"Input schema / properties / source_task_id / typeAdded value: +"string"Input schema / properties / watermarkAdded value: +{
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "output_resolution"
-]New value: +[
+ "source_task_id",
+ "prompt",
+ "output_resolution"
+]get_task1 field changedInput schema / properties / action / descriptionPrevious value: -"Endpoint the task was created on."New value: +"Asynchronous endpoint the task was created on."text_to_video5 fields changedInput schema / properties / callback_urlAdded value: +{
+ "type": "string"
+}Input schema / properties / first_frame_image_url / typeAdded value: +"string"Input schema / properties / prompt / typeAdded value: +"string"Input schema / properties / watermarkAdded value: +{
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "duration_seconds",
- "output_resolution"
-]New value: +[
+ "prompt",
+ "duration_seconds",
+ "output_resolution"
+]v0.1.6loginv0.1.0check_pricingextend_videoget_tasktext_to_videoEach tool has a distinct, non-overlapping purpose: authentication, video generation via two different input modes, task status retrieval, and pricing lookup. No two tools could be confused for one another.
Tool names follow a consistent lowercase_with_underscores pattern, predominantly verb_noun (extend_video, text_to_video, get_task, check_pricing). 'login' is a simple verb, but it fits the imperative style without deviating from the naming schema.
With 5 tools, the server is well-scoped for its purpose: authentication, generation, status checking, and pricing. This is neither too sparse nor too heavy, covering the core workflow without unnecessary clutter.
The core lifecycle is covered: create a generation task (two types), query its status, and retrieve output. Minor gaps include lack of a task listing or cancellation tool, but these are not essential to the primary generate-and-poll workflow.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
130+ AI models for image, video, music, and audio — 18 model families, one RunAPI account.
Run multi-step AI pipelines for video, image, audio and text: upload media, run, poll results.
Create and manage cinematic AI video renders through the Future Video Studio Agent API.
Create AI images and videos, manage projects and credits, and use workspace campaign context.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/runapi-ai/runway-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
