---
title: "Should I use MCP, an API, an app or a skill for AI image and video?"
description: "For AI image and video, use MCP when an agent does the work, the REST API for your own code, an app when others run it, and a skill for a ready-made job."
updated: 2026-10-20
---

Use the MCP connector when an AI agent does the work, the REST API when your own code runs a workflow, an app when other people run your workflow with their own credits, and a skill when you want a ready-made job in Claude Code, Cursor or Codex. All four run the same image and video models on the same credits.

| Route | Use it when | How you connect | Who pays | How you get results | Start here |
| --- | --- | --- | --- | --- | --- |
| MCP connector, `https://www.wireflow.ai/api/mcp` | An agent such as Claude, Cursor, Codex or ChatGPT builds, runs and reads workflows for you | Sign in with your Wireflow account (OAuth), no key | The connected account | The agent calls `get_execution` | [Connect your agent](/docs/use-wireflow-from-your-agent) |
| Editor connector, `https://www.wireflow.ai/api/mcp/editor` | An agent edits video timelines and renders media already in your account. It generates nothing | Sign in with OAuth, no key | Renders cost 0 credits at current pricing | `render_video` saves the file as the node's output | [Editor Connector](/docs/mcp/editor) |
| REST API, `POST /api/v1/workflows/{id}/run` | Your own code runs a workflow you own | An `sk-` key with `workflows:execute` | The key owner | Polling, or a signed webhook | [Run a workflow from your app](/docs/trigger-a-workflow-from-your-app) |
| App, `POST /api/v1/apps/{slug}/execute` | Other people, or you by slug, run a workflow you published | The caller's own `sk-` key with `apps:execute` | The caller | Polling the `pollUrl` | [Let others run your workflow](/docs/publish-a-workflow-as-an-api-endpoint) |
| Skill, from `github.com/wireflowINC/skills` | A packaged job fits, such as a product clip or a set of ad images, and you want a cost quote first | It runs through the MCP connector | The connected account | Files saved to `./wireflow-outputs/` | [Claude Code Skills](/docs/skill) |

Most setups use more than one route. An agent drafts and tests a workflow over MCP, your code runs it with the REST API, and you [publish it as an app when other people need it](/docs/publish). Drafting costs nothing, and credits are spent only when something runs.

## What is the difference between MCP and an API?

MCP is how an AI agent works with Wireflow: it signs in with OAuth and calls tools such as `create_workflow_from_prompt`, `run_workflow` and `get_execution`. The REST API is how your own code does the same, with an `sk-` key and plain HTTP requests.

| | MCP connector | REST API |
| --- | --- | --- |
| Who drives it | An AI agent, from your prompt | Your code |
| Sign-in | OAuth with a consent screen, and no key to copy | An `sk-` API key as a Bearer token |
| Permissions | The scopes you approve on the consent screen; some are opt-in | The scopes you pick when you create the key |
| Starts a run with | `run_workflow` or `run_app` | `POST /run` or `POST /apps/{slug}/execute` |
| Learns the result with | `get_execution` | Polling, or a webhook on `/run` |

The two are separate. An MCP sign-in is not an API key: the video composition contract endpoint, for example, refuses an MCP token with `401`. They also resolve identities independently: check which account each one acts as with `whoami` over MCP, or `GET /api/v1/me` with a key.

Connecting an agent is one command in Claude Code:

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

Running the same workflow from code is one request:

```bash
curl -X POST https://www.wireflow.ai/api/v1/workflows/YOUR_WORKFLOW_ID/run \
  -H "Authorization: Bearer $WIREFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs": {"node-prompt": "a paper boat on a neon puddle"}}'
```

## MCP or skills: which should I use with Claude Code?

Use a skill when one of the ready-made jobs fits, and the connector on its own when you want to shape the job yourself. A skill is not a separate connection: it plans the job in Claude and runs a published Wireflow app through the same MCP connector.

| | Skill | MCP connector on its own |
| --- | --- | --- |
| What you get | A fixed job, such as a 5-second video clip, product photos or static ads in three sizes | Any workflow: build it, run it, read results, edit video timelines |
| Before it spends | Shows the plan, the credit cost and your balance, then waits for your yes | Whatever you ask, so tell the agent to quote the cost first |
| Results | Saved to `./wireflow-outputs/`, with the credits used | File URLs from `get_execution`, plus the board in your account |
| Install | `/plugin marketplace add wireflowINC/skills`, then `/plugin install wireflow-skills@wireflow` | `claude mcp add --transport http wireflow https://www.wireflow.ai/api/mcp` |

The plugin adds the connector too, so you run `/mcp` once to sign in. To install the skills in Cursor, Codex, [Gemini CLI](/docs/agents/gemini-cli) and more, use the skills CLI:

```bash
npx skills add wireflowINC/skills
```

Every retry or extra variation needs a new yes. To run boards you built yourself, the [ai-workflow-runner skill](/docs/skills/ai-workflow-runner) matches a plain request to one of your workflows and estimates its credits first. [Claude Code Skills](/docs/skill) lists every skill.

## When should I use the REST API instead of an MCP server?

Use the REST API when code runs the job with no agent in the loop: a backend, a scheduled script or a feature in your own product. It takes an `sk-` key, which suits servers, and `/run` adds two things servers need: a signed webhook when the run ends, and an `Idempotency-Key` header that replays the original run on a retry instead of billing it twice.

```javascript
const res = await fetch('https://www.wireflow.ai/api/v1/workflows/YOUR_WORKFLOW_ID/run', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.WIREFLOW_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ inputs: { 'node-prompt': 'a paper boat on a neon puddle' } }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const { data } = await res.json(); // data.executionId and data.poll
```

```python
import os
import requests

res = requests.post(
    "https://www.wireflow.ai/api/v1/workflows/YOUR_WORKFLOW_ID/run",
    headers={"Authorization": f"Bearer {os.environ['WIREFLOW_API_KEY']}"},
    json={"inputs": {"node-prompt": "a paper boat on a neon puddle"}},
)
res.raise_for_status()
data = res.json()["data"]  # data["executionId"] and data["poll"]
```

Use MCP instead when a person steers the work in chat, or when the job changes each time and an agent should pick the models, draft the workflow and read the results. For how an agent compares with a node tool that runs on a schedule, see [n8n vs MCP for video automation](https://www.wireflow.ai/blog/n8n-vs-mcp-for-video-automation).

## When do I use an app instead of the API?

Publish an app when someone other than you should run the workflow, or when you want a fixed endpoint by slug. `/run` works only on workflows you own, while an app can be called by anyone with an `apps:execute` key, and each caller pays for their own runs. Publish it as private and it becomes an endpoint that only your account can call.

An app also gets a web page with a form, for people who don't write code. Its sign-in, per-run prices and subscriptions are in [Publishing Apps](/docs/publishing-apps). To run someone else's community template without copying it, see [Execute Templates](/docs/api/templates-execute).

Last updated: 2026-10-20

---

Documentation index: fetch https://www.wireflow.ai/llms.txt for the full list of Wireflow docs.