# CCAPI [Health: Active]

**Category:** 🎥 Multimedia Process  
**Repository:** https://ccapi.ai/mcp  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/ccapi

## Description
Image, video, music and text generation across 100+ models through one endpoint.

## Tools
Capabilities this server exposes over MCP:

- **chat_completion** — Send a conversation to any text model available through CCAPI (Claude, GPT, Gemini, DeepSeek, GLM, MiniMax, Kimi, Qwen…) and get the reply. Useful for consulting a second model for a different perspective, running a cheap model over bulk work, or reaching a model the current client does not have configured. Responses are non-streaming.
- **edit_image** — Edit existing images according to an instruction, using the dedicated image edit endpoint. Provide at least one source image. For pure text-to-image, or for models that take references through the generation endpoint, use generate_image instead.
- **extend_music** — Continue an existing song from a given timestamp, producing a longer version. Requires the clip_id of a previously generated song, which appears in the 'raw' payload of a completed generate_music task. Asynchronous — poll with get_task.
- **generate_image** — Generate an image from a text prompt, optionally guided by reference images (image-to-image). Returns image URLs directly. Most models finish in 10-60 seconds; if your client times out, set async=true to get a task_id you can poll instead. This call costs money — do not retry speculatively.
- **generate_lyrics** — Write song lyrics from a description, without generating audio. Useful as a first step before generate_music with custom=true, so the user can approve the words before paying for audio. Asynchronous — poll with get_task.
- **generate_music** — Generate a song with vocals or instrumental. Two modes: simple (custom=false) where you describe the song and the model writes the lyrics, or custom (custom=true) where you supply lyrics, title and style tags. Asynchronous — returns a task_id you poll with get_task; generation usually takes 30-120 seconds and normally yields two variations.
- **generate_video** — Generate a video from a text prompt, optionally driven by reference images (image-to-video, first/last frame). This is asynchronous: it returns a task_id you poll with get_task(platform='video'). Generation usually takes 30-180 seconds. Pass wait_seconds to have the server poll for you. Video generation is the most expensive capability here — confirm the prompt with the user before spending on retries.
- **get_balance** — Report the remaining and used balance for this CCAPI key. Useful before starting an expensive batch of generations, or to explain a quota failure to the user.
- **get_task** — Check the status of an asynchronous generation task submitted by generate_video, generate_music, generate_lyrics, extend_music, or generate_image with async=true. Pass the platform and task_id exactly as they were returned. Status is one of queued, in_progress, completed or failed; poll every few seconds until it settles, or pass wait_seconds to have the server wait for you.
- **list_models** — List the AI models this CCAPI key can actually call, with their capability category and the MCP tool that drives them. Call this before generating anything if you are unsure a model name is valid — availability depends on the key's group and changes over time. Never guess model names.
- **upscale_image** — Increase the resolution of an existing image 2x with ccapi-upscale-v1. Input must be between 256x256 and 1024x1024 and under 5 MB; for larger inputs, regenerate with a high-resolution model instead.

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: medium). Install path inferred — verify against the README before running it. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "ccapi": {
    "url": "https://ccapi.ai/mcp"
  }
}
```

## Documentation

## What the CCAPI MCP server does

The CCAPI MCP server gives an MCP client access to CCAPI’s catalog of text, image, video, music, and lyrics models. The available model list depends on the CCAPI key, so the server can expose different options for different accounts or key groups. It also reports the key’s used and remaining balance.

Text requests use `chat_completion`, which sends a conversation to a selected text model and returns a non-streaming reply. The catalog may include providers such as Claude, GPT, Gemini, DeepSeek, GLM, MiniMax, Kimi, and Qwen, but the exact models available to a key must be checked rather than assumed.

Media tools cover several workflows. `generate_image` creates images from prompts and can use reference images. `edit_image` modifies an existing image and requires at least one source image. `upscale_image` enlarges an image by 2x with `ccapi-upscale-v1`. Music tools can create songs, generate lyrics without audio, or continue an existing song from a timestamp. Video generation accepts text prompts and optional reference images, including first- or last-frame workflows.

## How it works

Start with `list_models` when the model name or capability is uncertain. The response identifies models the current key can call and the MCP tool associated with each one. `get_balance` can be used before a batch or other costly generation to inspect remaining credit.

Some operations return results directly. Chat completion is non-streaming, and image generation normally returns image URLs after roughly 10–60 seconds. Longer media operations return a task identifier. `generate_video`, `generate_music`, and `generate_lyrics` are asynchronous by design; image generation can also be made asynchronous with `async=true`. `extend_music` likewise returns work that must be checked later.

Use `get_task` with the returned platform and task identifier to follow asynchronous work. Tasks move through `queued`, `in_progress`, `completed`, or `failed`. The server can poll for a specified wait period, or the client can poll every few seconds until the task settles. A completed music task contains the clip identifier needed by `extend_music` in its raw payload.

## Tools and capabilities

The CCAPI MCP server exposes these operations:

- `chat_completion` for non-streaming conversations with available text models.
- `list_models` for key-specific model and capability discovery.
- `get_balance` for remaining and used credit.
- `generate_image` for prompt-based or reference-guided image creation.
- `edit_image` for instruction-based changes to supplied images.
- `upscale_image` for 2x enlargement of supported images.
- `generate_video` for asynchronous text-to-video and reference-driven video jobs.
- `generate_music` for vocal or instrumental songs, with simple and custom lyric modes.
- `generate_lyrics` for text-only lyric drafting.
- `extend_music` for continuing a previously generated song.
- `get_task` for checking asynchronous generation status.

The CCAPI MCP server supports a two-stage music workflow: generate lyrics first for review, then provide approved lyrics to custom music generation. Custom music requests accept lyrics, a title, and style tags; simple mode lets the model write the lyrics.

## Limitations and notes

Generation consumes credit. Video is identified as the most expensive capability, and image generation also costs money, so clients should avoid speculative retries and confirm prompts before repeating costly requests. Video jobs commonly take about 30–180 seconds, while music generation usually takes about 30–120 seconds and normally produces two variations.

Image upscaling accepts inputs from 256×256 through 1024×1024 and below 5 MB. Larger images should instead be regenerated with a high-resolution model. `edit_image` is not the general text-to-image path; use `generate_image` for pure prompt generation or for models that accept references through generation. The supplied material does not specify installation commands, client configuration, environment-variable names, or a license.

_Full upstream README: https://allmcps.com/mcp/ccapi/readme_