Amazon Nova Canvas is AWS's own image-generation model, delivered through Amazon Bedrock. This is a complete, neutral reference: what Nova Canvas is and how AWS positions it, the full capability set (text-to-image, image variation, inpainting, outpainting, background removal, image conditioning and color-guided generation), how to call it on Bedrock with one model ID, what it costs per image, practical prompting guidance, the built-in safety and invisible-watermarking story, an honest comparison with Amazon Titan Image Generator and Stability AI's Stable Diffusion — and how AWS credits make building on it $0.
Amazon Nova Canvas is the image-generation member of the Amazon Nova family — Amazon's own foundation models on Bedrock. Where Nova Micro/Lite/Pro/Premier read and write text, and Nova Reel generates video, Nova Canvas is the model that turns a text prompt (optionally plus a reference image) into a finished image, and edits existing images on demand.
Place it the same way you place the rest of Nova: it is the AWS "house brand" for image generation, sold through the same well-stocked store. Bedrock still offers third-party image models — most notably Stability AI's Stable Diffusion family — through the same API, but Nova Canvas is the model AWS builds, runs on its own infrastructure, and tunes for the price, latency and governance profile that production teams on AWS tend to want.
AWS's positioning for Nova Canvas is deliberately practical rather than maximalist. The pitch is not "the most artistically expressive image model on the internet"; it is a dependable, enterprise-safe image generator that does the editing operations real products need — generate, vary, inpaint, outpaint, remove backgrounds, and control layout and color — with content safety and provenance built in, inside the security perimeter you already trust. For the large category of "we need on-demand images in our app or pipeline, and we need it to behave," that is the relevant pitch.
The single most important thing to understand about Nova Canvas is that it is not just text-to-image. A common misconception is that it competes only on "type a prompt, get a picture." In practice its differentiated value is the editing suite exposed through one model: image variation, mask-based and prompt-based inpainting, outpainting (extending an image beyond its borders), background removal, and structural conditioning. Those are the operations that turn a novelty into a production tool — and §II walks through each.
Nova Canvas inherits the Bedrock guarantees that matter to companies: your prompts and images are not used to train the base model, your data stays in your AWS account and region, and the usual controls apply unchanged (IAM, PrivateLink, KMS encryption, CloudWatch logging). It also adds two image-specific safety layers — built-in content moderation and an invisible watermark embedded in every generated image for provenance — which §V covers in detail. Choosing Nova Canvas does not mean stepping outside Bedrock's governance model; it is the same service with a different model ID.
One caveat, stated once and meant throughout: the capabilities and especially the prices on this page are representative as of 2026. AWS iterates the Nova family quickly and image pricing changes as the market moves. Treat the figures here as a guide to the shape of the model and its relative cost — and confirm current capabilities, resolution limits and per-image pricing on the official AWS Bedrock and Nova pages.
Amazon Nova Canvas is AWS's own image-generation and image-editing model on Bedrock — text-to-image plus variation, inpainting, outpainting, background removal and layout/color conditioning — positioned as the enterprise-safe, production-grade choice (content moderation + invisible watermark + Bedrock governance), billed per image and reachable through one model ID.
Nova Canvas exposes its features as named "task types" in a single request format: you tell the model which operation you want (generate, edit, condition) and supply the relevant inputs (a prompt, a source image, a mask). The breadth of editing operations — not just generation — is what makes it a production tool rather than a demo.
Read the list below as the menu of operations one model gives you. In code, each is selected by a task-type field in the Nova Canvas request body, with the appropriate parameters (prompt text, an input image, a mask defined either by a drawn mask image or by a text description of what to mask, a negative prompt, image dimensions, a quality setting, a seed for reproducibility, and a count of images to return).
What it does: the core operation — produce one or more images from a text prompt, at a chosen resolution and aspect ratio. You can steer output with a negative prompt (things to avoid), a quality setting (standard vs premium), a seed for reproducible results, and a request count to get several candidates at once. Best for: generating original imagery from a description — marketing creative, concept art, product mockups, hero images, illustration.
What it does: takes one or more reference images plus an optional prompt and produces new images that preserve the essence (subject, style, mood) of the input while varying the specifics. Best for: generating a set of on-brand variations from a single approved image, exploring alternatives around a concept, or producing a consistent series without re-describing the look each time.
What it does: regenerates a masked region of an existing image while leaving the rest untouched — remove an object, swap an item, change a detail, fix an artifact. The mask can be supplied as a drawn mask image or described in words (a "mask prompt" — e.g. "the coffee cup"), which is a notable convenience. Best for: targeted edits: replacing a product on a shelf, removing a person from a photo, changing a garment's color, cleaning up a generated image.
What it does: the inverse of inpainting — generates new content outside the original image to extend it (widen a shot, change aspect ratio, build a larger scene around a subject, place a product into a generated background). You supply the source image and a mask indicating the area to keep, and the model fills the rest. Best for: reframing for different placements (square social vs wide banner), expanding tight crops, and compositing a subject into a new setting.
What it does: automatically isolates the foreground subject and removes the background, returning an image with a transparent background — no manual masking required. Best for: e-commerce product shots, catalog standardization, compositing subjects onto new backgrounds, and any pipeline that needs clean cutouts at volume.
What it does: uses a reference image to constrain the structure of the generated result. With edge (Canny) conditioning, the model follows the outlines/edges of the reference; with segmentation conditioning, it follows the layout of regions. You combine this with a text prompt to keep the composition while changing the content/style. Best for: "same layout, new look" — re-styling a scene, generating variations that respect a sketch or wireframe, or holding a precise composition across many renders.
What it does: generates an image that adheres to a supplied color palette (a set of hex colors), so output matches brand colors or a required scheme. Best for: brand-consistent marketing assets, themed creative, and any case where the palette is a hard requirement rather than a suggestion.
Text-to-image is table stakes; almost every image model does it. Nova Canvas earns its place in a production pipeline because one model also does variation, mask-based and text-prompt inpainting, outpainting, automatic background removal, and layout/color conditioning — the operations that turn "generate a picture" into "produce on-brand, correctly-framed, edited assets at volume," without stitching together separate tools.
Nova Canvas is reached through Amazon Bedrock, so if you can call any model on Bedrock you can call Nova Canvas by enabling it and passing its model ID. There is no separate image service, SDK or account to set up — it is the same managed Bedrock service with a different model ID and an image-specific request body.
The workflow is the standard Bedrock workflow. First, in the Bedrock console under Model access, enable Nova Canvas in your region (a one-time toggle). Then call it with the AWS SDK (boto3, the AWS SDK for JavaScript, etc.) using InvokeModel, passing the model ID and a JSON body whose taskType selects the operation (text-to-image, variation, inpainting, outpainting, background removal, conditioning) along with the relevant parameters. The response returns the generated image(s) as base64-encoded data you decode and store (typically to Amazon S3).
The model ID is amazon.nova-canvas-v1:0. A request body for plain generation includes the task type, a textToImageParams block with your text prompt (and optional negativeText), and an imageGenerationConfig block with parameters such as numberOfImages, width and height, a quality setting (standard or premium), a cfgScale (how strictly to follow the prompt), and a seed. Editing tasks swap in the matching params block (for example an inPaintingParams or outPaintingParams block carrying the input image and the mask). Unlike the text models, image generation is a single InvokeModel call rather than the conversational Converse API.
Because Nova Canvas lives inside Bedrock, the surrounding Bedrock and AWS plumbing works with it unchanged: you store outputs in S3, govern access with IAM, connect privately over PrivateLink, encrypt with KMS, and monitor with CloudWatch. For higher availability you can route through a cross-region inference profile the same way you would for the text tiers (see the amazon-bedrock-cross-region-inference sibling). And the same credit eligibility applies — image generation is billed against your AWS account and is covered by AWS credits.
Nova Canvas is billed <strong>per generated image</strong>, not per token. The price of one image depends on two things: its resolution (size in pixels) and the quality setting you request (standard or premium). That makes cost easy to model — you can multiply your expected image volume by a per-image rate and get a reliable estimate.
The pricing structure has a small number of tiers. Images at or below a certain resolution threshold cost one rate; larger images cost more. Within each, the premium quality setting costs more than standard. So the four practical cells are: standard small, premium small, standard large, premium large. Editing operations (inpainting, outpainting, variation, background removal, conditioning) are billed as image generations as well — each output image you receive is a billable image.
Representative magnitudes as of 2026: a single standard-resolution image is on the order of a few cents (roughly $0.04 in the smaller/standard cell), with premium and larger-resolution images stepping up from there (roughly into the $0.06–$0.08 range for premium/large). These are illustrative figures to convey the shape of the pricing, not a quote — confirm current per-image rates, the exact resolution breakpoints, and regional differences on the official AWS Bedrock pricing page.
The cost-control levers are different from the token models. There is no "Batch 50% discount" or prompt caching for images; instead you manage cost by: (1) generating at the resolution you actually need rather than always maxing it out; (2) using standard quality unless premium is visibly worth it for the use case; (3) requesting fewer candidates per call once your prompts are dialed in (the numberOfImages parameter multiplies cost directly); and (4) caching/reusing generated assets rather than regenerating identical images. For steady, very high volume, talk to AWS about committed pricing.
| Output | Quality | Resolution band | Representative price / image | Notes |
|---|---|---|---|---|
| Generated image | Standard | Smaller (≤ ~1.0 MP) | ~$0.04 | The default, lowest-cost cell |
| Generated image | Premium | Smaller (≤ ~1.0 MP) | ~$0.06 | Higher fidelity, small size |
| Generated image | Standard | Larger (> ~1.0 MP) | ~$0.06 | Bigger output, standard quality |
| Generated image | Premium | Larger (> ~1.0 MP) | ~$0.08 | Highest-cost cell |
| Edit (inpaint / outpaint / variation / bg-removal) | Std or premium | Per output image | Same as generation | Each returned image is billable |
Per-image billing makes cost almost trivially predictable: (images per month) × (per-image rate for your resolution + quality) × (numberOfImages per call). Generate at the size you need, keep quality at standard unless premium is visibly worth it, and cache outputs — those three habits control the vast majority of Nova Canvas spend.
Two things separate a production image model from a toy: how predictably you can steer it, and how responsibly it behaves. Nova Canvas addresses the first with a small set of well-defined controls, and the second with built-in content moderation plus an invisible watermark embedded in every output for provenance.
On prompting, Nova Canvas rewards specificity. Useful prompts name the subject, the setting/background, the style or medium (photographic, 3D render, watercolor, line art), the lighting and mood, the composition/shot (close-up, wide, top-down), and any brand/color constraints. Describe what you want in the prompt and push what you don't want into the negative prompt (for example: "blurry, distorted hands, text, watermark"). The cfgScale parameter trades creativity against prompt-adherence (higher = follow the prompt more strictly), and a fixed seed makes a result reproducible so you can iterate one variable at a time. For hard color requirements, prefer color-guided generation over describing colors in words; for layout requirements, prefer image conditioning over verbal description.
A few habits that consistently help: (1) be concrete — "a ceramic coffee mug on a marble countertop, soft morning window light, shallow depth of field, photographic" beats "a nice coffee mug"; (2) use the negative prompt to remove recurring artifacts rather than over-stuffing the main prompt; (3) iterate with a fixed seed so each change is attributable; (4) generate a small batch (numberOfImages) and pick, rather than re-rolling one at a time; (5) reach for the right task type — don't try to "prompt away" a background when background removal does it cleanly, and don't describe a layout you can pin down with conditioning.
Nova Canvas applies content safety on both sides of the request: it is designed to refuse prompts that ask for disallowed content and to filter unsafe outputs, in line with AWS's responsible-AI commitments. For application-level control on top of the model's own safeguards, you can pair generation with the broader Bedrock safety and governance tooling and your own policy checks. The practical upshot for builders: the model is intended to be safe to expose in a product without you having to hand-build a moderation layer from scratch — though you still own your application's policy.
Every image Nova Canvas produces carries an invisible watermark — provenance information embedded directly in the image in a way that is imperceptible to viewers and designed to survive common transformations, rather than a visible logo stamped on the picture. The goal is content provenance: being able to identify an image as AI-generated by Nova Canvas. AWS exposes a way to detect this watermark (a check that tells you whether an image was generated by the model). For teams with disclosure, trust-and-safety or compliance requirements around AI-generated media, this built-in provenance is a meaningful differentiator over models that emit unmarked images.
Nova Canvas is built to be safe to ship: content moderation on input and output, an invisible watermark in every image for provenance (with a detection capability), and the full Bedrock governance model (no training on your data, in-account/in-region, IAM/KMS/PrivateLink). You still own your application's policy — but you are not building the safety floor from nothing.
Three image-generation choices on AWS confuse people: Amazon Nova Canvas (the current Amazon image model), Amazon Titan Image Generator (Amazon's earlier image model), and Stability AI's Stable Diffusion family (third-party models offered on Bedrock). Here is how to choose among them in 2026.
Nova Canvas vs Titan Image Generator. Titan Image Generator was Amazon's first-generation image model on Bedrock and pioneered the in-house approach (text-to-image, editing, invisible watermarking). Nova Canvas is the successor and, for new image work in 2026, the better default on capability and quality — a broader, more cohesive editing suite (variation, inpainting/outpainting, background removal, Canny/segmentation conditioning, color guidance) and stronger output. If you are starting fresh with Amazon's own image model, default to Nova Canvas, not Titan. Existing Titan Image integrations still work, but new builds should start on Canvas. (See the amazon-titan sibling for the wider Titan family, whose most enduring relevance is its text-embeddings models for RAG retrieval.)
Nova Canvas vs Stable Diffusion (Stability AI). This is the live everyday decision, and the honest framing is "AWS-native and enterprise-safe" vs "the open-ecosystem creative standard." Stable Diffusion (including the SD3 / Stable Image family, available on Bedrock) is the model family the creative and developer community has built an enormous ecosystem around — fine-tunes, LoRAs, ControlNets, community tooling — and is often the reach-for choice when you want maximum stylistic range, community assets, or specific artistic control. Nova Canvas is the reach-for choice when you want a single AWS-native model with a built-in, coherent editing suite, predictable per-image pricing, content moderation and invisible watermarking, and zero integration beyond Bedrock. Both are on Bedrock behind the same API, so trying both is a model-ID change.
A simple rule of thumb. Default to Nova Canvas for new, production, enterprise-safe image generation and editing on AWS — especially when provenance/watermarking, content moderation, predictable cost and the built-in editing operations matter. Reach for Stable Diffusion when you specifically want the open ecosystem, community fine-tunes/tooling, or a particular artistic capability it does better. Treat Titan Image Generator as the prior generation: fine where it is already running, but not the default for new work. You are not locked in — switching among them on Bedrock is a model-ID change, so start with Nova Canvas, evaluate on your own prompts and brand, and switch only where the output tells you to.
Nova Canvas earns its keep wherever a product or pipeline needs images on demand — generated, varied, or edited — with predictable cost and enterprise-grade safety. The editing suite is what makes many of these practical, not just the raw generation.
These are starting points, not laws — always validate output quality on your own brand and prompts before committing. The recurring theme is that the differentiated value is rarely "generate a one-off picture"; it is doing image work at volume — on-brand variations, clean cutouts, correctly-framed assets, targeted edits — inside the AWS perimeter.
The teams that get the most from Nova Canvas treat it as an image pipeline, not a prompt box: generate or vary a base asset, edit it with inpainting/outpainting/background-removal, constrain it with conditioning and color, store to S3, and reuse aggressively. The breadth of one model's editing operations is exactly what makes that pipeline simple.
Getting from "interested in Nova Canvas" to a running image pipeline is short, because Nova Canvas is just Bedrock with a different model ID. The only meaningful decision beyond which task types you need is whether to pay for it yourself or have AWS credits cover the build — which, for most startups and many companies, they will.
The mechanical first steps: (1) enable Nova Canvas under Bedrock Model access in your region; (2) prototype text-to-image with InvokeModel and tune quality, cfgScale, numberOfImages and the negative prompt against a handful of your real prompts; (3) add the editing task types you actually need — inpainting, outpainting, background removal, conditioning, color guidance — rather than trying to do everything through generation; (4) wire outputs to S3 and put the standard governance in place (IAM, KMS, CloudWatch); and (5) if you need maximum stylistic range for a specific case, A/B it against Stable Diffusion on the same Bedrock API. That sequence gets most teams to a reliable, cost-predictable image pipeline quickly.
The cost story is where CloudRoute comes in. Nova Canvas is inexpensive per image, but at real volume image generation still costs money — and AWS will frequently fund the build with credits. Nova Canvas usage (and the supporting services around it) is credit-eligible. The relevant pools: AWS Activate (general startup credits, commonly up to $100K for institutionally-funded startups), a dedicated Bedrock / Generative-AI POC pool ($10K–$50K) for proving out a use case, and the competitive Generative AI Accelerator (awards up to $1M for a small cohort of AI-first startups). Credits apply automatically against your AWS bill — including Nova Canvas image generation — until exhausted.
Most of those pools are partner-filed through the AWS Partner Network (the ACE program), not a public self-serve form, which is why teams route through an AWS partner rather than applying alone. That is the gap CloudRoute fills: it matches you to the right credit pool for your stage and to a vetted AWS DevOps/ML partner who both files the credit application and helps build the image pipeline (the generation and editing workflows, the S3 plumbing, the moderation and provenance handling, the cost tuning). The customer pays $0 — AWS funds the credit pool, AWS pays the partner through engagement-funding programs, and the partner pays CloudRoute a routing commission. You never see an invoice. For the credit mechanics specifically, see the cross-cluster pages on AWS credits for generative-AI startups and Bedrock POC funding.
A scannable view of the three image-generation choices a team on AWS actually weighs in 2026, on the dimensions that drive the choice. It is qualitative and directional (capabilities and pricing both move quickly) — validate on your own prompts and brand, and remember all three live behind the same Bedrock API, so trying another is a model-ID change.
| Model | Maker / access | Sweet spot | Editing suite | Safety + provenance | On Bedrock? |
|---|---|---|---|---|---|
| Amazon Nova Canvas | Amazon · Bedrock | Enterprise-safe, production image gen + editing on AWS | Broad (variation, in/outpaint, bg-removal, conditioning, color) | Moderation + invisible watermark + detection | Yes (native, current) |
| Amazon Titan Image Generator | Amazon · Bedrock | Prior-gen Amazon image model (already-running integrations) | Generation + basic editing + watermark | Moderation + invisible watermark | Yes (earlier gen) |
| Stable Diffusion (Stability AI) | Stability AI · Bedrock | Open-ecosystem creative range, community fine-tunes/tooling | Strong via ecosystem (ControlNet/LoRA outside Bedrock) | Varies by deployment | Yes (third-party) |
Situation: Their customers (online sellers) needed clean, standardized product photos — white-background cutouts plus a few lifestyle variations per SKU. The team was doing it with a patchwork of a manual photo editor, a separate background-removal tool, and a generic image API, which was slow, inconsistent, and hard to keep on-brand. They wanted a single governed pipeline that could generate, vary, cut out backgrounds and reframe images at volume, with provenance they could disclose to marketplaces — and they did not want to spend seed runway proving it out.
What CloudRoute did: CloudRoute matched them in under 24 hours to an EU AWS partner with GenAI and media-pipeline experience. The partner (1) built the pipeline on <strong>Amazon Nova Canvas</strong> via Bedrock — <strong>background removal</strong> for standardized cutouts, <strong>image variation</strong> for on-brand alternates, and <strong>outpainting</strong> to place products into lifestyle backgrounds and reframe for each marketplace's aspect ratios; (2) used <strong>color-guided generation</strong> to keep each seller's palette; (3) wired outputs to <strong>S3</strong> with IAM/KMS governance and kept the <strong>invisible watermark</strong> for marketplace disclosure; and (4) filed a Bedrock POC credit application plus an Activate application to fund the build and early scale.
Outcome: The manual studio workflow was replaced by a single Nova Canvas pipeline: per-SKU turnaround dropped from hours to seconds, output was consistent and on-brand, and image generation/editing was fully covered by the approved credits — so the team paid $0 during the build and early scale. CloudRoute's commission was paid by the partner from AWS engagement funding, not by the customer.
workflow: manual studio → one Nova Canvas pipeline · turnaround: hours → seconds · credits: POC + Activate · out-of-pocket: $0
Nova Canvas is AWS's enterprise-safe way to generate and edit images at scale — and AWS credits can make it cost nothing to build. CloudRoute routes you to the right credit pool (Activate up to $100K, Bedrock POC $10K–$50K, GenAI Accelerator up to $1M) and a vetted AWS partner who files the application and builds the pipeline — the generation and editing workflows, the S3 plumbing, the provenance and cost tuning. Customer pays $0.