Menu
Mattering Automations connector

A Leonardo AI MCP that treats generation as the async job it is

Connect one API key and Leonardo's generation platform becomes workflow steps: one unified create endpoint spanning image, video, music, sound, dialogue, and 3D models, plus Blueprints for templated production pipelines. Create returns a job id, a poll returns finished CDN URLs, and the canvas handles the waiting honestly.

11 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Leonardo AI MCP connector does

The Leonardo AI connector for Mattering Automations is 11 nodes: Leonardo AI: Create Generation (Async) submits work to the unified generations endpoint, where one model field selects among roughly 70 models spanning image, video, music, sound effects, dialogue, 3D, and upscalers; Leonardo AI: List Models enumerates what is available; Leonardo AI: Get Generation polls a job and returns the finished assets; Leonardo AI: Create Classic Generation (Async) covers the older modelId-based image endpoint; Leonardo AI: Create Init Image Upload (Presigned) starts an image-to-image workflow; and a six-node Blueprints family lists, inspects, executes, and polls Leonardo's templated multi-step pipelines.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An assistant can browse the model list, submit a generation, and report back with the finished image URLs, through the same nodes your workflows use.

Generation is asynchronous and the connector says so instead of pretending otherwise. Create nodes return a generation id, not an image: the job runs on Leonardo's side, and Leonardo AI: Get Generation reports a pending status with an empty asset list until the work completes. On the canvas that is a create step, a short delay, and a poll, and the finished assets arrive as cdn.leonardo.ai URLs that Leonardo says never expire, so nothing heavy ever passes through the workflow itself.

Because Mattering is a work platform rather than middleware, generated work lands somewhere useful by default: finished image URLs can attach to the task that requested them, land in a Mattering database as records, or flow into a review step where a person approves the creative before it goes anywhere public. Generations consume Leonardo API credits, which are purchased separately from Leonardo's web app plans, so treat every create node as metered compute.

One connection, three surfaces

  • Visual automations. Drag Leonardo AI nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Leonardo AI node, ready to drop on the canvas

11 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 7

Leonardo AI: Get Blueprint

Get one blueprint with its required input schema and settings. Read this before executing: execution validates strictly against the schema.

Leonardo AI: Get Blueprint Execution

Poll a blueprint execution's status until the run completes or fails.

Leonardo AI: Get Generation

Poll a generation by id. Reports a pending status with an empty asset list until the job completes, then returns the finished cdn.leonardo.ai URLs (Leonardo states API assets do not expire).

Leonardo AI: List Blueprint Execution Generations

List every generation a blueprint execution produced, with their ids for polling.

Leonardo AI: List Blueprint Versions

List a blueprint's versions. Versions can change the input schema, so check here when an execution starts failing validation.

Leonardo AI: List Blueprints

List available blueprints (Leonardo's templated multi-step generation pipelines) with ids and names.

Leonardo AI: List Models

List the models available on the unified v2 generations endpoint (roughly 70 across image, video, music, SFX, dialogue, 3D and upscalers). Free read; the connector's auth probe, and the source of the model names the create nodes ask for.

Action nodes 4

Leonardo AI: Create Classic Generation (Async)

Create an image generation on the older v1 endpoint addressed by modelId. Async: returns a generation id only; poll with Leonardo AI: Get Generation. Spends API credits.

Leonardo AI: Create Generation (Async)

Submit a generation to the unified v2 endpoint: one model field selects among roughly 70 image, video, music, SFX, dialogue, 3D and upscaler models. Async: returns a generation id only; poll with Leonardo AI: Get Generation for the finished CDN URLs. Spends API credits.

Leonardo AI: Create Init Image Upload (Presigned)

Reserve an init image upload for image-to-image workflows: returns the presigned upload form and the image id generation requests reference. The byte upload itself is a separate plain HTTP POST to the presigned target, and the window is short, so upload promptly.

Leonardo AI: Execute Blueprint (Async)

Run a blueprint with inputs matching its schema. Async: returns an execution id; poll with Leonardo AI: Get Blueprint Execution and collect results with Leonardo AI: List Blueprint Execution Generations. Spends API credits.

Connecting Leonardo AI takes one credential

Leonardo issues API keys from its web app under API Access. Note that the API runs on its own credit balance, purchased separately from Leonardo's web app subscription plans; a web plan alone does not fund API generations. Mattering sends the key as a bearer credential on every request.

1

In Leonardo, open API Access, create an API key, and make sure the account holds API credits.

2

In Mattering Automations, open Connectors, click Add Connector, choose Leonardo AI, and create a credential with that key.

3

Click Test Connection. Mattering calls Leonardo's model list, a free read that confirms the key authenticates.

4

All 11 Leonardo AI nodes appear in the canvas palette. Run Leonardo AI: List Models first: the model ids it returns are what the create nodes ask for.

Common uses for the Leonardo AI MCP

One create endpoint, seventy models

Leonardo AI: Create Generation (Async) takes a prompt and a model name and covers image, video, music, sound effects, dialogue, 3D, and upscaling through the same node; Leonardo AI: List Models enumerates the options with their capabilities. New Leonardo models work the day they appear in the list, without a connector update.

The create, wait, poll pattern

Create returns a generation id immediately. A short delay node then a Leonardo AI: Get Generation call retrieves the result; while the job is still running the poll honestly reports a pending status with no assets, so a workflow can loop until the status is complete and then use the CDN URLs.

Image-to-image from anywhere on the canvas

Leonardo AI: Create Init Image Upload (Presigned) reserves an upload slot and returns the presigned form plus the image id that generation requests reference. The URL half is the node's job; the actual byte upload is a plain HTTP POST any system can perform against the presigned target.

Blueprints as production pipelines

Blueprints are Leonardo's templated multi-step generation pipelines with fixed inputs and tuned settings. Leonardo AI: List Blueprints and Leonardo AI: Get Blueprint discover what exists and what inputs a blueprint wants, Leonardo AI: Execute Blueprint (Async) runs it, and Leonardo AI: Get Blueprint Execution plus Leonardo AI: List Blueprint Execution Generations poll the run and collect every generation it produced.

Creative that waits for review

Finished asset URLs can land on a Mattering Productivity task for approval before anything ships: the generation happens automatically, but a person decides whether the image becomes the campaign. Because outputs are permanent CDN URLs, the review task stays valid indefinitely.

Batch variations on a schedule

A scheduled workflow can walk a Mattering database of prompts, submit a generation for each, and poll them as a group, landing finished URLs back on each record. Credits meter every create, so batch workflows pair naturally with a count or budget condition up front.

Example: A creative request becomes reviewed artwork without a tab ever opening

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a task in Mattering Productivity carries a creative brief and a target model.

2

Leonardo AI: List Models confirms the model and supplies its exact name.

3

Leonardo AI: Create Generation (Async) submits the prompt and returns a generation id.

4

A delay node waits, then Leonardo AI: Get Generation polls until the status is complete and returns the image URLs.

5

The CDN URLs land back on the task as a comment for approval, so a person signs off before the artwork goes anywhere public.

Leonardo AI MCP questions, answered

What Leonardo AI operations are supported?

11 nodes: the unified v2 create endpoint (one model field selecting among roughly 70 image, video, music, sound effect, dialogue, 3D, and upscaler models), model listing, generation polling, the classic modelId-based image create, presigned init image uploads, and the six-node Blueprints family (list, get, versions, execute, poll execution, list execution generations). Deliberately not shipped: generation deletion (no longer publicly documented), the retired motion endpoint (video ships through the unified endpoint instead), datasets, and the older variation endpoints whose documentation is no longer public.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.

Why do the create nodes not return the image?

Because Leonardo does not: generation is an asynchronous job on its platform, and the create call returns a generation id while the work runs. The connector models this honestly rather than blocking a workflow step for however long a video render takes. Leonardo AI: Get Generation reports a pending status with an empty asset list until the job completes, then returns the finished URLs; on the canvas that is create, a short delay, then poll, looping on the status field.

Where do the generated files actually live?

On Leonardo's CDN. Finished generations come back as cdn.leonardo.ai URLs, and Leonardo states that assets generated through the API do not expire. The connector never moves raw image or video bytes through workflow payloads: downstream steps receive URLs they can store in a database, attach to a task, or send onward.

What are Blueprints and when would a workflow use one over plain generation?

Blueprints are Leonardo's templated generation pipelines: multi-step recipes with fixed input schemas and tuned settings, versioned on Leonardo's side. Plain generation is one prompt against one model; a blueprint encodes a repeatable production look whose inputs are a form, not an art direction. Discover them with Leonardo AI: List Blueprints, inspect required inputs with Leonardo AI: Get Blueprint, run with Leonardo AI: Execute Blueprint (Async), and poll with the execution nodes, collecting every generation the run produced.

What do generations cost?

Generations consume Leonardo API credits, and the API balance is purchased separately from Leonardo's web app subscription plans, a distinction that regularly surprises new API users. Costs vary by model and settings, and the connector never invents prices: check Leonardo's API pricing page for current numbers. The reads (model list, blueprint list, polling) are free; the create and execute nodes are the metered ones.

How does image-to-image work through the connector?

In two halves. Leonardo AI: Create Init Image Upload (Presigned) reserves the upload and returns a presigned form plus the image id; posting the actual bytes to that presigned target is a plain HTTP call any system can make, and the presigned window is short, so upload promptly. Once uploaded, generation requests reference the image id. The connector ships the URL half and says so, rather than pretending to move files it never touches.

Both a unified create and a classic create: which one should a workflow use?

The unified Leonardo AI: Create Generation (Async) is the default: it is Leonardo's current API surface, one endpoint across all modalities, selected by model name. Leonardo AI: Create Classic Generation (Async) exists for the older image endpoint addressed by modelId, which established workflows and some documented recipes still use. Both return a generation id that the same Leonardo AI: Get Generation node polls.

11 nodes waiting on the canvas

Put Leonardo AI to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Leonardo AI is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products