# Krea MCP Guide 2026: Setup, Image & Video Tools, Pricing, and Prompts

Set up Krea MCP with Claude Code, Cursor, Codex and ChatGPT. Explore image and video tools, OAuth billing, prompts, workflows and troubleshooting.

Canonical URL: https://aiidelist.com/blog/krea-mcp

Language: en

Published: 2026-10-11

Updated: 2026-10-11

## Key Takeaways

- **Krea MCP is Krea's hosted Model Context Protocol integration**, connecting compatible AI agents to image, video, enhancement, and workflow tools through `https://api.krea.ai/mcp`.
- **OAuth is the simplest connection method.** Supported clients can authorize a Krea workspace without manually entering an API key.
- **The workflow extends beyond generation.** Agents can discover models, inspect parameters, submit and track jobs, upload references, cancel jobs, and execute Krea Node Apps.
- **Billing depends on authentication.** OAuth typically uses the selected workspace's compute-unit allowance; API-token usage draws from the separate API balance.
- **The practical benefit is less context switching:** creative briefs, generated assets, revisions, and development tasks can be coordinated within one agent session.

## What Is Krea MCP? is a hosted Model Context Protocol (MCP) server that exposes Krea's creative-generation capabilities to AI assistants and coding agents. Instead of repeatedly copying prompts between an editor, chat window, and image-generation website, a compatible assistant can call Krea tools directly.

The standard server endpoint is `https://api.krea.ai/mcp`, with **Streamable HTTP** transport. This is an interface to Krea's existing services, not an entirely new image model or a requirement to run a GPU locally.

A typical workflow has four stages:

1. **Discover:** the assistant lists available models and identifies one suited to the task.
2. **Validate:** it retrieves the model's parameter schema before constructing a request.
3. **Generate:** it submits the job and receives an identifier for tracking.
4. **Review:** it retrieves the result, evaluates it against the brief, and revises if necessary.

This design is especially useful for AI-assisted web development, marketing production, prototyping, and reusable media pipelines.

## Krea MCP Tools and Capabilities

The official Krea MCP documentation describes the following tools:

| Tool | Function | Practical use |
| --- | --- | --- |
| `list_models` | Lists currently available models | Find an appropriate generator without guessing model IDs |
| `get_model_schema` | Retrieves model-specific inputs | Validate parameters and supported references |
| `generate` | Submits an image or video job | Turn a brief into generated media |
| `get_job` | Retrieves a generation's status and results | Track asynchronous jobs safely |
| `cancel_job` | Attempts to cancel an in-progress job | Stop unnecessary generation |
| `get_upload_url` | Requests an upload URL for local assets | Supply references without hosting them separately |
| `execute_node_app` | Executes a Krea Node App | Reuse a predefined multistep workflow |

### Image generation

An agent can create website illustrations, product concepts, thumbnails, editorial artwork, and marketing images. Available models and their supported parameters can vary, so an agent should call `list_models` and `get_model_schema` instead of assuming the same aspect ratios or reference-image controls apply everywhere.

### Video generation

Video-capable models support tasks such as creating short clips from prompts or generating motion from a reference image, where the selected model allows it. Clip length, audio, aspect ratio, resolution, and frame-input rules are **model-specific**.

### Upscaling, editing, and Node Apps

Krea also offers image enhancement and creative workflows. A Node App can encapsulate repeatable steps, allowing an agent to invoke an approved workflow rather than rebuild it with improvised prompts each time. Whether a particular upscaling or editing operation is callable depends on the models and apps exposed to that workspace.

## How to Install Krea MCP

### Official server settings

| Setting | Value |
| --- | --- |
| URL | `https://api.krea.ai/mcp` |
| Transport | Streamable HTTP |
| Preferred authentication | OAuth |
| Alternative authentication | API token |
| Server hosting | Remote, managed by Krea |

**Use Krea's official endpoint** rather than assuming a similarly named community npm package is the same service.

### Claude Code setup

Add the remote MCP server with the Claude Code CLI:

```bash
claude mcp add --transport http krea-ai https://api.krea.ai/mcp
```

Open Claude Code and use `/mcp` to inspect the connection and complete browser authorization when requested. Confirm the server tools are available before running a generation.

Try this first:

```text
List the image-generation models currently available through Krea.
Find a model suitable for a 16:9 website hero image.
Inspect its input schema and propose one inexpensive test render.
```

### Cursor setup

Open Cursor's MCP settings and add a server entry to the relevant `mcp.json` configuration:

```json
{
  "mcpServers": {
    "krea-ai": {
      "url": "https://api.krea.ai/mcp"
    }
  }
}
```

Restart or reload Cursor's MCP connection, then finish Krea authorization if prompted. The precise settings interface may vary by Cursor release.

### Codex setup

Open **Settings → MCP servers** in a Codex client that supports remote MCP, create a Streamable HTTP server with the Krea URL, and authorize it. Verify tool discovery before attempting generation. Client interfaces and OAuth handling may differ across releases.

### ChatGPT and Claude

Krea documents a ChatGPT integration through its plugin connection experience. In supported ChatGPT environments, connecting the official Krea integration may be easier than setting up a raw MCP endpoint.

Claude's supported connector interface can similarly connect to remote MCP services where the account and client support that feature. Authentication still determines which Krea workspace is used.

### Optional: Krea Agent Skills

Krea's official skills repository contains reusable creative instructions. A supported Skills installer can use:

```bash
npx skills add krea-ai/skills
```

**Skills and MCP solve different problems:** the skills guide agent behavior, while MCP supplies callable tools. Installing instructions alone does not establish Krea access.

## Your First Krea MCP Workflow

A 16:9 blog featured image is a useful low-complexity test because it validates the complete path from model discovery to a usable file.

**Step 1 — Choose a model.** Ask the agent to list current image models and inspect the chosen model's schema.

**Step 2 — Give a detailed brief.** State the subject, composition, ratio, number of outputs, visual constraints, and intended use.

```text
Use Krea MCP to create one 16:9 featured image for an article
about AI creative workflows. Use editorial 3D artwork with
warm coral, cream, and soft orange. Strong central focal point,
clean negative space, no words, no logos, and no watermarks.
Inspect the model schema before sending the request.
```

**Step 3 — Track the job.** If the operation is asynchronous, keep the returned `job_id` and call `get_job` as needed rather than repeatedly resubmitting the same request.

**Step 4 — Review at actual display size.** Check subject consistency, crop, contrast, small-thumbnail readability, and any unwanted text or objects.

**Step 5 — Revise intentionally.** Change one variable at a time—such as framing, lighting, or background—rather than replacing the entire prompt without diagnosing what failed.

**Step 6 — Publish.** Use the client's available download and filesystem capabilities to incorporate the output into the site. MCP access alone does not guarantee that the assistant can write to the project's repository.

## Five Practical Krea MCP Prompts

### 1. Open Graph illustration

```text
Generate one 16:9 OG illustration for a technical AI guide.
Premium sculptural 3D, coral and cream colors, bold visual
contrast, one clear subject, no typography. Return the model
used and a link to the final output.
```

### 2. Consistent ecommerce imagery

```text
Use the supplied product photograph as reference. Generate
three scenes: white studio, warm lifestyle, and close-up.
Maintain recognizable product shape and packaging details.
First choose a model supporting the necessary references.
```

### 3. Animate an approved still

```text
Convert the approved still into a short vertical product clip.
Slow forward camera movement, subtle reflections, stable
product proportions, no captions. Check supported video
duration and image-reference settings before submitting.
```

### 4. Upscale without redesigning

```text
Find an available enhancement model for this approved hero
image. Improve detail and output size while retaining the
composition, logo geometry, and any existing lettering.
Report any settings that could alter original content.
```

### 5. Execute a repeatable Node App

```text
Discover available Krea Node Apps. Identify the approved
campaign-image workflow, inspect its required inputs, and
run it once using the attached brief and product reference.
Return its job ID and finished assets.
```

These prompts are **natural-language instructions for an agent**, not guaranteed raw API request bodies. The agent must translate the brief into fields supported by the chosen tool and model.

## Choosing the Right Krea Model

| Goal | Model-selection priority | Why |
| --- | --- | --- |
| Fast concept exploration | Lower-cost or faster image models | Test multiple ideas before a final render |
| High-impact editorial illustration | Style adherence and composition | A clear concept beats maximum resolution |
| Product-image editing | Reference support and object fidelity | Reduce changes to identity and packaging |
| Short promotional video | Motion consistency and input-frame support | Minimize flicker and unintended transformations |
| Enhancement | Detail preservation and output-size options | Avoid redesigning an already approved image |
| Repeatable campaigns | A suitable Node App | Reduce manual variation between runs |

Krea's catalog may include Krea-branded image models and third-party generators, but **names, access, versions, and capabilities change**. Live discovery is more reliable than copying a fixed model list from a tutorial.

A cost-conscious production strategy is to **prototype quickly, select a direction, and use higher-quality rendering only for approved concepts**. This reduces wasted attempts without assuming that one model is universally best.

## Krea MCP Pricing and Billing

Krea's billing path depends on the authentication method, an important detail for agents that may autonomously submit several jobs.

| Authentication | Usage pool | Implication |
| --- | --- | --- |
| OAuth | Selected Krea workspace's compute units | The authorized workspace bears the usage |
| API token | Separate API balance | Consumer subscription allowances may not apply |

Krea publishes subscription details at Krea Pricing and API-specific rates at its API pricing page. Prices and allocations can change, and **API-dollar prices should not be treated as direct conversions of subscription compute units**.

Before approving a batch run, request the proposed **model, number of outputs, dimensions, expected charging pool, and available balance**. Ask the assistant to pause for approval before expensive videos or large campaigns.

A failed authorization or insufficient-balance error may indicate a different workspace was selected—not necessarily that the user's entire Krea account is out of credits.

## Krea MCP vs Krea API vs Krea Agent

| Option | Best use | Main consideration |
| --- | --- | --- |
| Krea MCP | AI assistants and coding agents invoking creative tools | Requires compatible remote-MCP support |
| Krea REST API | Backend products with deterministic requests and orchestration | Requires direct programming and API billing |
| Krea Agent | Creative work inside Krea's own experience | Less centered on an external coding-agent session |
| Krea Agent Skills | Reusable instructions and prompting practices | Does not replace an authenticated tool connection |

**Choose MCP for agent-driven, conversational workflows. Choose the REST API for application-level integrations requiring explicit control of parameters and job orchestration.** Both can coexist in the same product.

## Advanced Reliability and Security Tips

- **Inspect schemas after model changes.** Supported fields, references, and aspect ratios are not guaranteed to remain identical.
- **Preserve job IDs.** A timeout in the agent UI does not prove the remote generation failed; check `get_job` before retrying.
- **Limit batch sizes.** Require confirmation for expensive models, long video jobs, and large output counts.
- **Keep references controlled.** Avoid exposing confidential product images through public URLs when secure upload methods are available.
- **Preserve provenance.** Save model, prompt, output ID, date, and key settings for each approved asset.
- **Review output before publication.** Automated generation can introduce incorrect text, altered logos, invented product details, or rights issues.
- **Protect tokens.** Keep API credentials out of commits, logs, screenshots, and shared configuration files.
- **Review third-party implementations.** A community server and Krea's official hosted MCP service have different deployment and security considerations.

### Uploading a local reference

When `get_upload_url` returns a temporary presigned upload URL, a compatible agent can upload a local file with multipart form data:

```bash
curl -X POST "$UPLOAD_URL" -F "file=@./reference.png"
```

`UPLOAD_URL` is a placeholder for a URL returned by the tool. It should never be guessed or hardcoded. Use the resulting asset URL in the generation input only where the selected model schema permits it.

## Troubleshooting Krea MCP

| Symptom | Possible cause | Action |
| --- | --- | --- |
| MCP server does not connect | Incorrect URL or transport | Use the official endpoint with Streamable HTTP |
| Sign-in repeatedly fails | Incomplete or stale OAuth authorization | Disconnect and reconnect the workspace |
| Model request is rejected | Unsupported fields or model version | Call `list_models` and `get_model_schema` again |
| Generation reports insufficient balance | Wrong workspace or depleted usage pool | Verify authentication method and workspace billing |
| No output appears immediately | Job is queued or processing | Query `get_job` using the original job ID |
| Local reference fails to upload | Expired URL or network restriction | Obtain a fresh upload URL and check permitted egress |
| Agent creates duplicate outputs | It reissues `generate` after a timeout | Check the first job before submitting another |
| Asset differs from the reference | Model lacks sufficient editing controls | Select a reference-capable model and revise the brief |

If the requested feature is absent from the current model schema, switching models is preferable to silently dropping an important constraint.

## Frequently Asked Questions

### Is Krea MCP an official Krea product?

Yes. Krea operates the hosted endpoint and publishes official developer documentation. Community packages with similar names are separate implementations.

### Does Krea MCP require an API key?

Not for the standard OAuth path. API-token authentication is an alternative for compatible clients and uses the separate API balance.

### Is Krea MCP free?

Connecting an eligible client does not necessarily require purchasing an API token, but **generating media consumes the relevant usage allowance or API balance**. Free-tier limits and model availability still apply.

### Can Krea MCP generate videos?

Yes, through available video-capable models. Duration, audio, aspect ratios, and reference-image support depend on the specific model and its schema.

### Can Krea MCP work with Cursor and Claude Code?

Yes, both support remote MCP integrations in supported releases. The Krea endpoint can be registered and authenticated through the client's normal connection flow.

### Can a generated image be saved directly to a website repository?

Only when the agent also has the necessary file access and permissions. Krea provides the creative output; storing, optimizing, and committing files are separate client capabilities.

### Should developers use MCP or the Krea API?

Use **MCP** for interactive, agent-guided creative work. Use the **API** for deterministic application requests, custom job management, and deeper backend control.

## Conclusion

Krea MCP makes Krea's creative tools accessible inside AI assistant workflows, from model discovery and image generation to video, reference uploads, job tracking, and reusable Node Apps. Its strongest advantage is not merely generating content—it is helping an agent coordinate creative production with the task that needs the finished asset.

Start with the official Krea MCP endpoint, connect one compatible client, inspect the available models, and create a single low-cost test image. Confirm the output quality and the correct billing workspace before automating larger campaigns.