Leonardo AI Image Generator: How to Use It (12 Steps)

September 2, 2026

21 min read

Leonardo AI has quietly become one of the most-used image generators on the web, and most of the traffic isn’t coming from people typing prompts into a blank box. It’s coming from freelancers building consistent brand characters, game studios prototyping concept art, and small marketing teams who got tired of paying a photographer for stock-style product shots. Since Canva folded the platform into its own ecosystem in 2024, Leonardo has kept its separate identity, its own pricing, and its own token economy, while quietly picking up Canva’s design-tool polish underneath. If you’ve only used Midjourney or a bare Stable Diffusion install before, Leonardo’s mix of a model hub, an editable canvas, and per-account LoRA training is worth learning properly.

This tutorial walks through account setup, token math, prompt structure, the Canvas editor, custom model training, the Universal Upscaler, and the API, in that order, so you can go from a blank account to a repeatable production workflow. Every step below reflects the plan structure and token allowances live on Leonardo AI as of September 2026.

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What is Leonardo AI and why it’s different from Midjourney or DALL-E

Leonardo AI isn’t a single model wearing a brand name, the way Midjourney V8.2 or GPT Image 2 are. It’s a hub: PhotoReal v2 for photorealistic output, Alchemy Refiner for detail passes, and Prompt Magic v3 for prompt interpretation all sit behind one interface, and you pick which one handles a given generation. That structure matters for a tutorial because “how to use Leonardo AI” really means “how to route a job to the right internal model,” not just “how to type a prompt.”

The platform has been owned by Canva since Canva completed the acquisition on July 29, 2024, bringing over Leonardo’s roughly 120-person team, according to TechCrunch’s coverage of the deal. Leonardo kept operating as a standalone product with its own site, billing, and roadmap, while its generation and upscaling tools also started surfacing as embedded apps inside Canva’s own design editor. In practice that means you can learn Leonardo once and use it two ways: as its own web app for deep control, or as a Canva plugin when you just need a quick asset inside a design you’re already building.

Where Leonardo pulls ahead of a single-model generator is consistency. Its Consistent Character Engine and per-account LoRA training let you lock a face, a product, or an art style across dozens of images, something Midjourney users typically solve with the more fragile --cref flag and DALL-E-style tools don’t offer at all. Where it falls behind is raw artistic surprise. Reviewers consistently describe Leonardo as more controllable and repeatable, while still crediting Midjourney with a stronger “wow factor” on purely exploratory prompts.

In practice, that trade-off decides who reaches for Leonardo first. Game studios use it for concept art batches where the same character needs to hold up across a dozen poses and outfits. Marketing teams use it for product photography that needs to look identical in style from one campaign to the next, not artistically fresh each time. Solo creators and indie developers tend to land on Leonardo specifically for the token math from Step 2, which comes out cheaper per image than Midjourney’s fast-hour model once you’re generating in volume rather than a handful of images a week.

Prerequisites and requirements

You don’t need design software or a GPU to follow this tutorial, but you do need a few accounts and, if you’re building the API project in the later steps, a basic Python environment. Here’s what to have ready before Step 1:

A web browser and an email address (or Google/Discord account) to register at leonardo.ai
A credit card if you plan to go past the free daily token allowance (the Apprentice plan starts at $12/month)
Python 3.10 or newer, if you’re following the API section (check with python3 --version)
The requests library for Python: pip install requests
A code editor (VS Code, Cursor, or similar) for the API and automation steps
Reference images ready in JPG or PNG format if you plan to train a custom LoRA model in Step 9
Basic familiarity with JSON, since the Leonardo API returns and accepts JSON payloads

Nothing here requires prior AI or design experience. The steepest part of the learning curve isn’t the interface, it’s understanding how tokens get consumed, which is exactly what Step 2 covers.

Step 1: Create your Leonardo AI account and pick a plan

Go to leonardo.ai and sign up with an email, Google account, or Discord login. New accounts land on the Free plan by default, which gives you 150 tokens per day, roughly 4,500 tokens across a full month if you use it daily. That’s enough to test the interface and generate a few dozen images before you need to decide whether to upgrade.

Before you generate anything, look at the four-tier pricing structure, because the tier you pick determines which models, how much concurrency, and how many LoRA training slots you get access to.

Plan	Monthly price	Annual price (per month)	Tokens included	Custom LoRA trainings
Free	$0	$0	150/day (~4,500/mo)	Not included
Apprentice	$12/mo	~$10/mo	8,500/mo	1 per month
Artisan	$30/mo	~$24/mo	25,000/mo	5 per month
Maestro	$60/mo	~$48/mo	60,000/mo	Up to 20 per month

For this tutorial, Apprentice is the minimum tier that unlocks private generations, Alchemy, and Prompt Magic v3, all of which you’ll use starting in Step 3. If you only need to test the workflow, the Free plan works for every step except custom model training and API access, which require a paid plan.

Step 2: Understand how tokens actually get spent

Token consumption is the single most common source of confusion for new Leonardo users, and it’s worth spending five minutes on before you start generating in volume. Every action, image generation, upscale, canvas edit, or video/motion job, draws from the same token pool. Higher resolution, more advanced models, and multiple images per batch all cost more tokens per action.

Third-party cost analyses put the effective image yield per plan at roughly the following, though exact numbers vary with resolution and model choice:

Plan	Monthly tokens	Approx. images per month	Effective cost per image
Apprentice ($12)	8,500	~1,400–2,100	~$0.006–$0.009
Artisan ($30)	25,000	~4,100–6,250	~$0.005–$0.007
Maestro ($60)	60,000	~10,000–15,000	~$0.004–$0.006

Two behaviors trip up most beginners. First, the Free plan’s 150 daily tokens don’t roll over, so if you skip a day, you don’t get to “bank” the unused allowance for later. Second, paid plans include a rollover token bank on top of the monthly allotment (Apprentice carries up to 25,500 rollover tokens, for example), but that bank only fills once you’ve used your primary monthly pool, so heavy early-month usage can leave you thinking you’re out of tokens when you actually have a rollover balance sitting unused. Check your token balance under Account Settings before assuming you’ve hit a hard wall.

Step 3: Generate your first image and choose the right model

From the dashboard, click “AI Image Generation” to open the main generation panel. This is where the “model hub” concept becomes concrete: instead of one generate button tied to one model, you pick a model from a dropdown before you type your prompt.

PhotoReal v2: the photorealistic engine, best for product shots, portraits, and anything meant to look camera-captured. Available on Artisan and Maestro.
Alchemy: Leonardo’s general-purpose rendering pipeline with an optional Refiner pass for finer detail, useful for illustration and stylized art.
Prompt Magic v3: an interpretation layer that rewrites and expands your prompt before generation, useful when you’re getting outputs that ignore half of what you typed.

Type a prompt into the text field, for example: “a weathered leather backpack on a wooden studio table, soft window light, shallow depth of field, product photography.” Set your aspect ratio (square, portrait, or landscape are the standard options, wider custom ratios cost proportionally more tokens for the extra pixels), pick a batch size of 2–4 images, and click Generate.

If your first result looks generic or ignores part of your prompt, the fix is almost never a longer prompt. It’s usually the wrong model for the job (using Alchemy for a photorealistic product shot instead of PhotoReal v2, for instance) or too many competing instructions in a single sentence. Split compound prompts into a clear subject clause, a lighting clause, and a style clause, in that order.

Step 4: Master prompt structure for consistent results

Leonardo rewards structured prompts more than free-form ones. A reliable template that works across PhotoReal v2 and Alchemy:

[subject and action], [environment/setting], [lighting description], [camera/lens detail], [art style or medium], [quality modifiers]

Example:
"a woman in a red coat walking through a rain-soaked city street at night,
neon signs reflecting on wet pavement, cinematic backlighting, shot on 35mm
film, moody color grading, highly detailed, 8k"

Negative prompts work the same way they do in Stable Diffusion-based tools: use the “Negative Prompt” field to exclude unwanted elements (“blurry, distorted hands, extra limbs, watermark, low resolution”) rather than trying to word your way around them in the main prompt. Leonardo’s interface keeps negative prompts in a separate box, so you don’t need special syntax to trigger them.

Guidance scale (labeled “Prompt Adherence” or similar depending on the model) controls how tightly the output follows your text versus how much creative freedom the model takes. Start around the middle of the slider. Push it higher only if outputs are drifting from your prompt, since pushing it too high tends to produce oversaturated, artifact-heavy images rather than more accurate ones.

Step 5: Edit and refine with the Canvas tool

Canvas is Leonardo’s inpainting and outpainting workspace, and it’s the feature that separates it most clearly from single-shot generators. Open any generated image and click “Edit in Canvas” to load it into the editor.

Use the selection brush to mask the region you want to change (a face, a background element, a product label).
Type a prompt describing only the masked region, not the whole image, for example “a green ceramic mug” if you’re replacing an object.
Adjust the “Generation Strength” slider — lower values preserve more of the original pixels around your mask edges, higher values give the model more freedom to reinterpret the area.
Click “Generate” to render just the masked region. Canvas blends the edit into the surrounding image automatically.
For outpainting, drag the canvas boundary outward and use the same masking workflow to extend the scene beyond the original frame.

Canvas edits consume tokens per generation just like a fresh image, so treat each edit pass as its own budgeted action rather than a free touch-up. Iterating three or four times on a stubborn region is normal, so it’s a good place to actually track your token spend as you go.

Step 6: Upscale images with the Universal Upscaler

Generated images typically come out at a working resolution suited for screen use, not print. Before exporting for anything client-facing, run the image through Leonardo’s upscaler.

Open the image and click “Universal Upscaler” from the tools menu.
Choose an upscale multiplier (typically 2x or 4x, depending on your target output size).
Set “Creativity” low if you want a faithful, detail-preserving upscale, or higher if you want the upscaler to add texture and fine detail that wasn’t in the original.
Generate the upscale and download the result.

Treat upscaling as a separate token-consuming step, not part of your original generation cost. If you’re generating a batch of four candidates and only upscaling the one you keep, budget accordingly, generation and upscaling are billed independently.

Step 7: Build consistent characters with the Consistent Character Engine

If you need the same character or mascot to appear across multiple images, generating each one independently and hoping the face matches doesn’t work reliably. Leonardo’s Consistent Character Engine solves this directly.

Generate or upload a reference image of your character.
Open the Consistent Character tool and upload that reference as the base.
Write new prompts describing different poses, outfits, or scenes while keeping the character reference active.
Generate variations. The engine locks facial structure and key identifying features while letting the rest of the scene change.

This is the tool to reach for before jumping straight to LoRA training in Step 9 (the same fine-tuning concept covered in our guide to fine-tuning models with LoRA, applied here to images instead of language models). Consistent Character Engine works from a single reference image and no training time, while LoRA training requires multiple reference images and a processing period, but produces a more durable, reusable style or subject that survives across sessions and projects.

Step 8: Set up API access for programmatic generation

API access is included on Artisan and Maestro plans and draws from the same token pool as web generations. Generate an API key from Account Settings > API Access, then keep it out of your source code.

export LEONARDO_API_KEY="your-api-key-here"

Here’s a minimal Python script that submits a generation job and polls for the result:

import os
import time
import requests

API_KEY = os.environ["LEONARDO_API_KEY"]
BASE_URL = "https://cloud.leonardo.ai/api/rest/v1"

headers = {
    "accept": "application/json",
    "content-type": "application/json",
    "authorization": f"Bearer {API_KEY}",
}

payload = {
    "prompt": "a minimalist ceramic vase on a marble surface, soft studio lighting",
    "modelId": "photoreal-v2",
    "width": 1024,
    "height": 1024,
    "num_images": 2,
}

response = requests.post(f"{BASE_URL}/generations", json=payload, headers=headers)
response.raise_for_status()
generation_id = response.json()["sdGenerationJob"]["generationId"]

# Poll until the job finishes
while True:
    result = requests.get(f"{BASE_URL}/generations/{generation_id}", headers=headers)
    status = result.json()["generations_by_pk"]["status"]
    if status == "COMPLETE":
        images = result.json()["generations_by_pk"]["generated_images"]
        for img in images:
            print(img["url"])
        break
    elif status == "FAILED":
        print("Generation failed")
        break
    time.sleep(5)

Full parameter references, including model IDs and supported dimensions, are documented in Leonardo’s official API reference. The getting-started guide covers authentication and rate limits in more depth than fits in this tutorial.

Step 9: Train a custom LoRA model for brand or character consistency

For work that needs the same product, mascot, or art style across dozens of assets over time, a trained custom model outlasts the Consistent Character Engine’s single-reference approach.

Collect 10–20 reference images of your subject, varied in angle, lighting, and background, but consistent in the subject itself.
Go to “Training & Datasets” and create a new dataset, uploading your reference set.
Start a new model training job, choosing a base model to fine-tune from (PhotoReal v2 for photorealistic subjects, Alchemy for stylized ones).
Wait for training to complete. This is a background job, not an instant action, and consumes one of your plan’s monthly LoRA training slots (1 on Apprentice, 5 on Artisan, up to 20 on Maestro).
Once trained, your custom model appears in the model dropdown alongside PhotoReal v2 and Alchemy, ready to generate new scenes featuring your locked subject.

Poor training data is the most common reason custom models come out inconsistent. Reference images that are all the same pose, same lighting, or same crop teach the model that pose and lighting instead of teaching it the subject. Vary the surrounding conditions and keep the subject itself the constant.

Training time itself typically runs from a few minutes to under an hour depending on dataset size and current platform load, and you’ll get a notification once the job finishes rather than needing to keep the tab open. Once trained, a custom model behaves like any other entry in the model dropdown: it can be combined with the same negative prompts, guidance settings, and Canvas editing workflow covered in Steps 4 and 5, so none of the prompting skills you build earlier in this tutorial go to waste once you move to custom models.

Step 10: Use Leonardo inside Canva for design workflows

Since the 2024 acquisition, Leonardo’s generation tools are also reachable from inside the Canva editor for teams who live in Canva day to day. Open any Canva design, search the Apps panel for “Leonardo AI,” and generate directly into your active design canvas without switching tabs. Generated images pull from the same Leonardo token pool tied to your account, so plan tier and token math from Step 1 and Step 2 still apply, Canva doesn’t provide a separate free allowance for Leonardo generations.

This path is worth using specifically when you’re producing an asset that’s going straight into a Canva template, a social post, a presentation slide, a flyer, since it skips the download-and-reupload cycle you’d otherwise go through generating on leonardo.ai and importing separately.

Step 11: Generate motion and short video clips

Motion generation, turning a still image into a short animated clip, is available starting on Artisan plans, with the deepest access on Maestro. From any generated image, select “Animate” or “Motion” from the image actions menu, choose a motion strength setting, and generate. Higher motion strength produces more dramatic camera or subject movement, but also increases the odds of visual artifacts, especially around hands, hair, and fine textures. Start at a low-to-moderate motion strength and only increase it if the output looks too static, rather than defaulting to the highest setting.

Common pitfalls when using Leonardo AI

Most Leonardo problems trace back to a handful of repeatable mistakes. Here are the ones that show up most often:

Using the wrong model for the job. Alchemy on a photorealistic product shot, or PhotoReal v2 on a stylized illustration, both produce mediocre results that look like a prompt problem but aren’t.
Ignoring the daily vs. monthly token distinction. Free-plan users often assume unused daily tokens carry over. They don’t, so batching heavy usage into one day wastes the rest of the week’s allowance.
Overloading a single prompt with too many instructions. Stacking five unrelated style keywords into one sentence produces a muddled compromise image rather than any one of them clearly.
Skipping the negative prompt field. Trying to prevent unwanted elements by rephrasing the positive prompt is far less reliable than explicitly excluding them.
Training a custom model on inconsistent reference images. Mismatched lighting, cropping, or pose across your training set teaches the model the wrong pattern.
Forgetting that Canvas edits and upscales cost separate tokens. Treating a multi-pass edit-and-upscale workflow as “one image” leads to running out of tokens mid-project.
Pushing prompt adherence too high. Beyond a certain point, higher guidance settings produce oversaturated, artifact-prone images rather than more accurate ones.
Assuming the Free plan supports API access. API access requires Artisan or Maestro. Free and Apprentice-only accounts hitting the API will get an authorization error, not a token error.

Sample output and what to expect

Running the API script from Step 8 with the vase prompt against PhotoReal v2 returns a JSON payload similar to this once the job completes:

{
  "generations_by_pk": {
    "id": "a1b2c3d4-...",
    "status": "COMPLETE",
    "modelId": "photoreal-v2",
    "prompt": "a minimalist ceramic vase on a marble surface, soft studio lighting",
    "generated_images": [
      {
        "id": "img-001",
        "url": "https://cdn.leonardo.ai/users/.../a1b2c3d4-image1.jpg",
        "nsfw": false
      },
      {
        "id": "img-002",
        "url": "https://cdn.leonardo.ai/users/.../a1b2c3d4-image2.jpg",
        "nsfw": false
      }
    ]
  }
}

A well-structured prompt at 1024×1024 on PhotoReal v2 typically takes somewhere between 10 and 30 seconds to complete on a standard queue, longer during peak usage hours or if you’re on the Free plan’s lower-priority queue. Batches of four images generally cost proportionally more tokens than a single image, not a flat per-batch fee, so check your token balance after your first few generations to calibrate your own budget rather than relying purely on the estimates in Step 2’s table.

Troubleshooting common Leonardo AI issues

Here are the issues that come up most often, and what actually fixes them:

Generation queue seems stuck. Free-tier jobs share a lower-priority queue and can take noticeably longer during peak hours. Check your plan’s queue priority before assuming something is broken.
Images ignore part of the prompt. Break the prompt into shorter, single-idea clauses and confirm you’re on a model suited to the subject matter (PhotoReal v2 for realism, Alchemy for stylized work).
Faces or hands look distorted. Add explicit negative prompt terms (“distorted hands, extra fingers, malformed face”) and consider a moderate, not maximum, guidance setting.
Custom model outputs don’t resemble the training subject. Retrain with a more consistent, varied reference set, and confirm the dataset uploaded correctly before training started.
Token balance dropped faster than expected. Review your recent activity log. Canvas edits, upscales, and motion generations all draw from the same pool as standard generations and are easy to undercount.
API returns a 401 error. Confirm your plan includes API access (Artisan or Maestro) and that your API key hasn’t been regenerated since you last copied it.
Upscaled image looks over-processed. Lower the Creativity setting on the Universal Upscaler. High creativity adds texture that can look artificial on already-detailed source images.
Leonardo app inside Canva won’t generate. Confirm you’re logged into the same account in both Canva and Leonardo. The integration doesn’t work across mismatched accounts.

Commercial rights and image ownership

Before shipping any Leonardo-generated image into client work or a paid product, check which plan you generated it on, since ownership terms shift with tier. Paid plans include commercial usage rights and the ability to keep generations private, meaning they won’t surface in Leonardo’s public community feed. The Free plan, by contrast, generates publicly by default, anything you make is visible to other users browsing the community feed unless you explicitly mark it private, which the Free tier typically doesn’t allow. If you’re prototyping client work, generate on at least Apprentice from the start rather than testing on Free and re-generating the final version later, since re-generation rarely reproduces an identical result even with the same prompt and seed.

This matters even more once you start training custom LoRA models on client-supplied reference images. Confirm you have the rights to use those source images for training before uploading them to a dataset, since the resulting custom model is trained specifically on that visual data and effectively encodes it into every future generation from that model.

Advanced tips for production workflows

Once the basics are solid, a few habits separate a one-off generation from a repeatable pipeline. First, save prompt templates rather than rewriting them from scratch, Leonardo’s prompt history makes it easy to duplicate and tweak a previous winning prompt instead of starting cold. Second, if you’re generating on a schedule (weekly social assets, for instance), the API script from Step 8 is worth wrapping in a scheduled job rather than manually clicking through the web interface every time.

Third, when a custom LoRA model isn’t converging well after training, it’s usually cheaper in tokens to fix the dataset and retrain than to keep generating from a mediocre model and hoping prompts compensate for it. Fourth, for teams sharing one Leonardo account, keep an eye on the Maestro plan’s higher concurrency limits, lower tiers cap how many generations can run at once, which becomes a real bottleneck once more than one person is generating simultaneously.

Complete working project: automated product image pipeline

Here’s a complete script that ties Steps 3, 6, and 8 together into a small pipeline: it generates a batch of product images from a list of prompts, waits for completion, and saves the resulting URLs to a file for review.

import os
import time
import json
import requests

API_KEY = os.environ["LEONARDO_API_KEY"]
BASE_URL = "https://cloud.leonardo.ai/api/rest/v1"
HEADERS = {
    "accept": "application/json",
    "content-type": "application/json",
    "authorization": f"Bearer {API_KEY}",
}

PROMPTS = [
    "a minimalist ceramic vase on a marble surface, soft studio lighting",
    "a leather wallet on a dark wood table, warm side lighting, product photography",
    "a pair of wireless earbuds on a white background, clean commercial lighting",
]

def submit_generation(prompt, model_id="photoreal-v2", width=1024, height=1024, num_images=2):
    payload = {
        "prompt": prompt,
        "modelId": model_id,
        "width": width,
        "height": height,
        "num_images": num_images,
    }
    resp = requests.post(f"{BASE_URL}/generations", json=payload, headers=HEADERS)
    resp.raise_for_status()
    return resp.json()["sdGenerationJob"]["generationId"]

def wait_for_completion(generation_id, timeout=180, interval=5):
    elapsed = 0
    while elapsed < timeout:
        resp = requests.get(f"{BASE_URL}/generations/{generation_id}", headers=HEADERS)
        data = resp.json()["generations_by_pk"]
        if data["status"] == "COMPLETE":
            return [img["url"] for img in data["generated_images"]]
        if data["status"] == "FAILED":
            raise RuntimeError(f"Generation {generation_id} failed")
        time.sleep(interval)
        elapsed += interval
    raise TimeoutError(f"Generation {generation_id} timed out")

def run_pipeline(prompts):
    results = {}
    for prompt in prompts:
        print(f"Submitting: {prompt[:50]}...")
        gen_id = submit_generation(prompt)
        urls = wait_for_completion(gen_id)
        results[prompt] = urls
        print(f"  -> {len(urls)} images ready")
    return results

if __name__ == "__main__":
    output = run_pipeline(PROMPTS)
    with open("generated_images.json", "w") as f:
        json.dump(output, f, indent=2)
    print("Saved results to generated_images.json")

Run it with python3 pipeline.py after setting LEONARDO_API_KEY in your environment. For a production version, add retry logic around the polling loop and rate-limit your submissions if you’re batching more than a handful of prompts at once, since the API enforces per-plan concurrency limits that match your subscription tier.

How Leonardo AI compares to other image generators

If you’re deciding whether Leonardo fits your workflow better than another tool, the comparison usually comes down to control versus spontaneity. Leonardo’s model hub, Canvas editor, and LoRA training give it an edge for anyone who needs the same character, product, or style reproduced reliably across many images. Tools built around a single flagship model, whether that’s a Midjourney version or a standalone diffusion model, tend to win on raw stylistic range from a single short prompt, without the setup overhead of choosing between internal models.

If your work leans toward brand assets, product photography, or recurring characters, the token-per-dollar math from Step 2 combined with the training tools in Step 9 make Leonardo a reasonable default. Readers weighing Google’s model instead should check our Nano Banana Pro tutorial for a comparable step-by-step breakdown. If you’re doing purely exploratory concept art with no consistency requirement, a single-model generator with less setup friction may get you to a usable image faster. For a broader look at how the current generation of tools stacks up on raw output quality, see our best AI image generator comparison for 2026.

Leonardo AI vs Midjourney vs Adobe Firefly vs Stable Diffusion

Pricing structures across AI image tools are different enough that a straight dollar comparison is misleading unless you line up what each subscription actually includes. Midjourney sells fast GPU hours rather than tokens, currently priced at $10 (Basic), $30 (Standard), $60 (Pro), and $120 (Mega) per month, with its default model, V8.2, having replaced V8.1 as the default on July 24, 2026. Adobe Firefly’s consumer plans (see our full Adobe Firefly walkthrough) run $9.99 to $199.99 per month for credit-based access to Firefly Image 4 and Image 4 Ultra, but Adobe does not publish a public rate card for its enterprise Firefly Services API, access there requires a sales contract. Stable Diffusion, by contrast, is open-weight: running Stable Diffusion 3.5 locally through a tool like ComfyUI costs nothing beyond your own GPU time, though it demands far more setup than any hosted service on this list.

Tool	Entry price	Top consumer tier	Editing canvas	Custom model training	Official API
Leonardo AI	Free (150 tokens/day)	Maestro, $60/mo	Yes (Canvas)	Yes, LoRA, from Apprentice	Yes, Artisan and Maestro
Midjourney V8.2	Basic, $10/mo	Mega, $120/mo	Yes (web editor)	No native fine-tuning	No official public API
Adobe Firefly Image 4	Free (25 credits/mo)	$199.99/mo	Yes (Generative Fill)	No public fine-tuning	Enterprise contract only
Stable Diffusion 3.5	Free (self-hosted)	N/A (open weights)	Via ComfyUI/A1111	Yes, full fine-tuning	Self-hosted only

The practical takeaway: Leonardo is the only tool in this group that bundles hosted generation, an editing canvas, LoRA-based fine-tuning, and an official API into a single consumer-priced subscription. Midjourney matches Leonardo’s polish for pure image quality but doesn’t offer native model fine-tuning or a public API at any price. Firefly’s advantage is deep Adobe Creative Cloud integration and commercially safe training data, but its API story is opaque and enterprise-only. Stable Diffusion wins on cost and flexibility for anyone willing to run their own hardware or rent GPU time, at the expense of Leonardo’s managed convenience.

Choosing the right plan for your actual workload

The four-tier structure looks simple until you try to map it to a real workload, so it helps to think in terms of who’s generating, not just how many images. A solo creator posting a handful of social assets per week rarely exhausts Apprentice’s 8,500 monthly tokens, even accounting for a few Canvas edits and an upscale pass per finished piece. A small agency running client work across multiple brands tends to outgrow Artisan quickly once Canvas revisions and LoRA retraining enter the picture, since both draw from the same pool as fresh generations.

Maestro’s jump to 60,000 tokens and up to 20 LoRA trainings per month is overkill for a single user, but makes sense the moment more than one person shares an account, since it’s also the tier with the highest generation concurrency. If you’re building the API pipeline from the earlier steps for scheduled, unattended generation, budget conservatively: a nightly batch job generating 50 images a day will burn through roughly 1,500 to 3,000 tokens per week depending on resolution, which is enough to justify Artisan or Maestro over Apprentice even for a single developer.

Frequently asked questions

Is Leonardo AI free to use?
Yes, the Free plan gives 150 tokens per day, roughly 4,500 per month if used daily, enough for testing and light personal use. It does not include API access or custom LoRA training.

How much does Leonardo AI cost per month?
Paid plans run $12/month (Apprentice), $30/month (Artisan), and $60/month (Maestro), each with roughly 20% off if billed annually. Tokens included range from 8,500 to 60,000 per month across those tiers.

Does Leonardo AI have an API?
Yes, API access is included on Artisan and Maestro plans, billed against the same token pool as web generations. Full documentation is available at Leonardo’s official developer docs.

Is Leonardo AI owned by Canva?
Yes, Canva acquired Leonardo AI on July 29, 2024. Leonardo continues to operate as a standalone product with its own pricing and roadmap, while also being accessible as an app inside the Canva editor.

What’s the difference between PhotoReal v2 and Alchemy?
PhotoReal v2 is tuned for photorealistic output like product shots and portraits, while Alchemy is a general-purpose rendering pipeline better suited to illustration and stylized art, with an optional Refiner pass for added detail.

Can I train Leonardo on my own images to create a custom style or character?
Yes, custom LoRA model training is available starting on the Apprentice plan (1 training per month), scaling up to 20 per month on Maestro. It requires 10–20 varied reference images and runs as a background job.

How is Leonardo AI different from Midjourney?
Leonardo exposes multiple internal models plus an editable Canvas and LoRA training for reproducible characters and styles, while Midjourney centers on a single evolving flagship model known for strong out-of-the-box artistic range. Leonardo tends to favor control and consistency, while Midjourney tends to favor stylistic surprise from short prompts.

Does Leonardo AI support video or motion generation?
Yes, image-to-motion generation is available starting on Artisan plans, with expanded access on Maestro, letting you turn a still generated image into a short animated clip.

Can I use Leonardo AI images for commercial projects?
Yes, on paid plans, generations include commercial usage rights and can be kept private. The Free plan generates publicly by default and is best reserved for testing and personal projects rather than client-facing work.

Related Coverage

Sofia Lindström

Editor-in-Chief

Sofia Lindström is the Editor-in-Chief at Tech Insider, where she leads editorial strategy and oversees coverage across AI, cybersecurity, and enterprise technology. With over a decade in Swedish tech journalism, she previously served as technology editor at Dagens Industri and covered the Nordic startup ecosystem for Breakit. Sofia holds an MSc in Media Technology from KTH Royal Institute of Technology and is a frequent speaker at Web Summit and Slush. She is passionate about making complex technology accessible to business leaders.

View all articles

How to Use Leonardo AI Image Generator: 12 Steps [2026]