August 24, 2026
Generate AI images and videos from Claude or Cursor: the complete MCP how-to
Your AI assistant can write, code, and plan. Now it can also create images and videos without leaving the conversation, thanks to the MCP protocol. Here is how to plug it into a real generation engine in two minutes, what it costs down to the cent, and the habits that separate an efficient agent from one that burns credits.
Your assistant can now create images, not just talk about them
Thanks to the MCP protocol, an assistant like Claude or Cursor can call a real image and video generator mid-conversation, and hand you the URL of a finished file instead of a description.
Ask Claude to write you a blog post, and it does. Ask it to illustrate that post, and until recently it would politely reply that it does not generate images, then offer you a prompt to copy-paste somewhere else. You know the rest: open another tool, paste the prompt, download the image, come back. The assistant that was supposed to save you time had just added three round trips to your day.
That wall is coming down. Modern AI assistants know how to use external tools: search the web, read files, call services. And now that a common standard exists for plugging those tools in, any compatible assistant can drive a real image and video generation engine. You say "illustrate this section with a photo of a fox in a misty forest", and thirty seconds later the image URL is in the conversation.
This guide shows you how to connect Claude, Cursor, or any compatible client to Imaginode, the AI creation canvas that gives access to 48 models (Flux 2, Nano Banana 2, Seedream 5, Kling V3, Seedance 2.5, Veo 3.1 and more) with a transparent credit counter. Two minutes of setup, nothing to install, and your assistant becomes a creative studio.
MCP, the USB port of AI assistants
The Model Context Protocol is an open standard that describes how an assistant discovers and calls external tools: an MCP server exposes functions, the client uses them, no matter who wrote what.
MCP stands for Model Context Protocol. It is an open standard, launched in late 2024 and since adopted by the whole ecosystem: Claude, Cursor, and dozens of other clients speak it natively. The idea is simple: rather than every assistant inventing its own way of connecting to every service, an MCP server describes its tools in a common format, and any compatible client can discover and call them. People often compare it to a USB port: one plug, thousands of devices.
Concretely, an MCP server exposes named tools, with their parameters and a description. Imaginode's server exposes four: list the available models with their prices, generate an image, launch a video, and track a generation through to the result. When you ask your assistant for an image, it picks the tool itself, fills in the prompt, makes the call, and reports the URL back to you. You never see the plumbing, and that is the point.
One detail that matters: Imaginode's server is hosted, at https://imaginode.ai/api/mcp. Nothing to install on your machine, no repository to clone, no Node or Python to configure. That is the difference between a remote MCP server and the local servers that require an installation: here, the only thing you need is an API key.
Connect Imaginode to Claude in two minutes, stopwatch in hand
Create an API key in your Imaginode profile (verified email required, secret shown only once), then hand it to your MCP client: one command in Claude Code, a custom connector in Claude.ai, a JSON block in Cursor.
Step one: the key. Create an account on Imaginode if you have not already (trial credits come with signup, verified email required), then open your profile and go to the "API keys" section. Give your key a name, "Claude Code" for instance, and create it. The secret, which starts with imk_, is shown only once: copy it right away. If you lose it, revoke the key and create another one, it takes ten seconds.
Step two: the connection. In Claude Code, a single terminal line does it: claude mcp add --transport http imaginode https://imaginode.ai/api/mcp --header "Authorization: Bearer your-key". In Claude.ai or the desktop app, add a custom connector with the server URL and the same header. In Cursor, declare the server in the mcp.json file with the URL and the Authorization header. Every other MCP-compatible client follows the same logic: one URL, one header.
Step three: there is none. Open a conversation and ask: "generate an image of a Breton lighthouse in a storm, analog film photo style". The assistant calls the tool, the image generates, the URL lands in the thread. The exact cost in credits and your remaining balance are announced on every call, before the result even arrives.
What your assistant can do once connected
Illustrate the content it is writing, spin out visuals in series, launch a video clip and follow it through to the final file: the assistant chains generations in the same thread as the rest of your work.
The most immediate use case is illustration while writing. Your assistant drafts a sales page, an article, a newsletter: it can now generate the matching visuals, in the same thread, keeping the context. The image prompt benefits from everything the conversation already contains, your brand, your tone, the exact subject of the section. That is very different from a generator open in another tab that knows nothing about your project.
Second family: the series. "Generate the same bottle on a white studio background, then on light wood, then in a night-time mood": the assistant chains the calls, names the files, lists the URLs for you. For product photos declined at volume or YouTube thumbnails to A/B test, the work loop shrinks to a single sentence. And since every call reports its cost, you know exactly what the series cost you.
Video works on the same principle, with one nuance: a video generation takes one to five minutes, sometimes more for the big formats. So the tool immediately returns a tracking identifier and the cost, then the assistant polls the status regularly and delivers the URL when it is ready. In the meantime, it can keep working on something else: it is an agent, not an hourglass.
What it costs, and why an agent cannot go off the rails
Every call is debited in credits at the same rate as the canvas (an image from 1 to 7 credits, a video from roughly 30 to 170), failures are refunded automatically, and a quota of 10 generations per minute per key caps any runaway.
The uncomfortable question first: is letting an agent spend money really reasonable? On Imaginode, the guardrails live in the infrastructure, not in promises. Every generation is debited before it launches, at a known price: 1 to 7 credits for an image, roughly 30 to 170 for a video depending on the model, duration, and resolution, knowing that one credit is worth one euro cent. The per-model breakdown is public, and the list_models tool gives the prices to the assistant itself.
If a generation fails on the provider's side, the credits are refunded automatically, no ticket, no claim: you only pay for what succeeds. And above all, an agent can never spend beyond your balance: no overdraft, no surprise bill at the end of the month. The worst possible scenario is a balance at zero and a message inviting you to top up.
That leaves the looping agent, the one that fires the same generation over and over because a script went haywire. Every API key is limited to 10 generations per minute: enough for any real use, too little to drain a balance while you are away. And if a key leaks or worries you, one click in your profile revokes it, effective immediately. Five active keys maximum, one per use, is good hygiene.
The habits that separate a good agent from a wasteful one
Iterate on a 1-credit model before paying for premium, write prompts in English, poll the video status every 30 seconds without ever relaunching, and reuse output URLs as inputs: four habits that change the bill.
First habit, the most profitable: validate on the cheap model, finalize on premium. Flux Schnell costs 1 credit and is more than enough to test a framing, a mood, a composition. Once the prompt is dialed in, rerun the same idea on Nano Banana 2 or Flux 2 Pro for the final render. A well-briefed assistant applies this rule on its own: just tell it "iterate on the cheap model, I'll tell you when to switch to quality". It is the same logic as choosing your model on the canvas.
Second habit: prompts in English. Generation models understand every language, but their training is overwhelmingly English-speaking and the results gain in precision. Good news: your assistant is an excellent translator. Talk to it in your language, let it phrase the prompt in English, and ask it to show you what it sent, that is the best way to learn to write prompts that work.
Third and fourth habits, for video and chains: never relaunch a video "because it seems slow", status tracking exists for exactly that, and a relaunch costs the price of a full generation. And reuse output URLs as inputs: the image generated in the previous step can serve as the first frame of the next video, exactly like wiring two nodes on the canvas. Your assistant then builds real workflows, in conversation.
For developers: the same thing in three REST endpoints
GET /api/models for the catalog, POST /api/generate to launch (model, prompt, options, key as Bearer), GET /api/generate/status to track: the MCP server is just a facade over a public REST API.
If you would rather script it directly, everything the MCP server does goes through three public endpoints. GET https://imaginode.ai/api/models returns the full catalog, options and prices in credits, no authentication needed. POST https://imaginode.ai/api/generate launches a generation: a JSON body with the model, the prompt and the options (duration, resolution, aspect ratio, audio, input images), your key in the Authorization header, and the response contains the request identifier, the cost debited, and your new balance.
GET https://imaginode.ai/api/generate/status then tracks the generation: running while it works, then completed with the output URLs, or failed with the refund already applied. It is the same pipeline, the same validations, and the same billing as the canvas and the MCP: one mechanism, three doors in.
Input images must be hosted on your Imaginode account, either uploaded to your media library or coming from a previous generation whose URL you reuse. The API and MCP guide in the documentation details every field, the limits, and the best practices, in five languages.
Chat, canvas, agent: three doors to the same engine
The canvas remains the place where you design and keep your workflows; MCP and the API are the doors through which an assistant or a script drives the same engine, on the same credit balance.
Should you still open the canvas if the assistant can generate everything? Yes, for one simple reason: a conversation stays linear. To design a visual pipeline, compare variants side by side, keep your character references, and find your work again weeks later, the node canvas remains the workshop. The agent, on the other hand, excels at execution: producing, declining, folding generation into a larger workflow that includes text, code, and files.
The two complement each other all the better because they share everything: the same account, the same credits, the same media library. An image generated by Claude this morning is in your Imaginode media tonight, ready to be plugged into a video node. A reference character built on the canvas can inspire the prompts your assistant will send tomorrow.
If this article is your first encounter with Imaginode, the shortest path is still to create your account, run your first generations on the canvas to understand the models and the costs, then create your API key and connect your assistant. From there, you have a creative studio that answers to the mouse as well as to the conversation, and that always tells you, down to the cent, what each image cost you.