banana2.io Paid content Multilingual

Nano Banana 2 is an AI image model you reach through third-party creative workspaces rather than an official Google site. If you want prompt-driven image editing, consistent characters across multiple generations, or reference-guided image creation, you can use it inside a multi-model platform like HeyMarmot, which bundles it with video and music tools. The practical catch: you get free starter credits when you sign up, but continued use is paid, so the model is best suited to people who will generate images regularly enough to justify topping up.

What Nano Banana 2 actually is

Nano Banana 2 is an image generation and editing model. You describe what you want in text, optionally attach a reference image, and the model produces or modifies a visual.

The important distinction is where you access it. HeyMarmot describes itself as an "all-in-one AI creative assistant" that integrates top-tier AI models — it is a third-party workspace, not Google's own product page. That matters for two reasons:

• Feature availability depends on the host. The workspace decides which parameters you can adjust, how references are handled, and how credits are counted.
• Pricing and access live with the host, not the model. Free credits on sign-up and paid subsequent usage are HeyMarmot's terms, not a universal rule for the model.

If you see "Nano Banana 2" advertised elsewhere, check whether that site is the model's official home or another workspace wrapping it.

Core use cases

Prompt-driven image generation

You write a description and get a finished image. HeyMarmot's image tool also lets you upload a reference image to guide the output when text alone isn't precise enough — useful for matching a color palette, composition style, or scene detail you already have in mind.

Image editing

Editing here means transforming an existing image through instructions rather than manual pixel work. The reference-image path is the key mechanism: instead of describing everything from scratch, you supply the visual context and let the model work within it. This is faster for tasks like restyling a photo, adjusting tone, or reworking a composition while keeping the subject recognizable.

Character consistency

Character consistency is the harder problem, and it's where reference images do the most work. The goal is to keep the same character looking like themselves across multiple generations — same face structure, hair, clothing, and overall vibe — instead of getting a slightly different person each time.

The approach that works: build a small set of reference images of your character, then reuse them as input on every new generation rather than relying on a text description alone. Text descriptions drift; visual references anchor.

How to get started

1. Create an account. HeyMarmot offers free credits on sign-up, which is enough to test the image tool before committing.
2. Open the AI image creation tool. You can start from text alone or upload a reference image.
3. Write your prompt or attach your reference. For editing and consistency work, attach the reference first, then describe the change you want.
4. Generate and inspect. Check whether the output matches your intent — especially character features if consistency is the goal.
5. Iterate. Adjust the prompt or swap the reference and regenerate. Each run consumes credits.
6. Move to paid usage when free credits run out. Continued generation is a paid feature; check the pricing page for current terms before you rely on it for ongoing work.

Prompt tips for editing and consistency

For editing:

• State what should change and what should stay the same. "Change the background to a rainy street at night, keep the subject's pose and clothing unchanged" gives the model a clear boundary.
• Use the reference image for anything visual that's hard to put into words — lighting, texture, framing.
• Make one meaningful change per generation when precision matters. Stacking five edits in one prompt makes it hard to tell what went wrong.

For character consistency:

• Keep a fixed reference set for each character and reuse it every time.
• Describe only the variable parts in your prompt — scene, action, expression — and let the reference carry identity.
• If the character drifts, compare outputs against your reference set and re-anchor rather than piling on more description.

Evaluating credit cost and tool fit

Credits are the real constraint. Before committing to a workflow, ask:

Choose Nano Banana 2 through a workspace like HeyMarmot if you want image editing, character consistency, and reference-guided generation in one place alongside video and music tools. If you only need occasional one-off images, the free starter credits may cover you — but plan for paid usage if generation becomes part of your regular workflow.

Nano Banana 2 image editing means using the Nano Banana 2 model inside a multi-model workspace to change an existing image with a text instruction — for example, swapping a background, adjusting lighting, or restyling a subject — instead of generating a brand-new image from scratch. On HeyMarmot, a third-party AI creative workspace (not a Google official product), you do this by uploading or generating a base image, describing the change you want, and generating the result. It fits tasks where you already have an image you mostly like and want to modify one or two things while keeping the rest intact.

Where Nano Banana 2 editing sits in a workspace like HeyMarmot

HeyMarmot is an all-in-one AI creative assistant that bundles text-to-video, image-to-video, AI image creation, and text-to-music in one place. Its image tools let you either describe an idea and generate a visual, or upload a reference image to guide the output. Nano Banana 2 editing is the reference-guided path: you bring an image in, and the model edits it according to your prompt.

Two things follow from that setup:

• You are not locked into one model. The workspace integrates multiple top-tier models, so image editing is one capability among several rather than a standalone app.
• Editing and generation share the same interface. The same upload-and-describe flow that generates an image also edits one, which is why the steps below look similar to plain image generation.

The edit flow, step by step

The general pattern for an edit is: provide a base image, state the change, generate, then check the result.

1. Start with a base image. Either upload an existing image or generate one first with a text prompt. If you generated it, keep that image as your working base so later edits stay anchored to it.
2. Describe only the change. Write a prompt that names what should change and, where it matters, what should stay the same. "Replace the gray background with a sunset beach, keep the subject's pose and clothing unchanged" is more controllable than "make it nicer."
3. Generate and inspect. The model returns an edited image. Check the specific region you asked to change and the regions you asked to preserve.
4. Iterate on the same base. If something drifted, re-run from the original base image with a corrected prompt rather than editing the edited output. Repeatedly editing an edit compounds unwanted changes.

Expected result: an image that matches the base in the areas you protected and reflects your instruction in the area you targeted. If it doesn't, the prompt — not the workflow — is usually the thing to fix.

Writing edit prompts: separate "keep" from "change"

The single most useful habit for Nano Banana 2 editing is to split your prompt into two explicit parts.

A combined prompt reads like: "Keep the subject's face, hair, and clothing exactly as in the reference. Change only the background to a rainy city street at night, matching the original lighting direction."

Why this works: the model has to decide what your instruction implies for every pixel. Naming what to preserve removes that guesswork. Vague prompts like "improve this" or "make it professional" leave both the target and the protected areas undefined, which is where unwanted changes come from.

Keeping a character consistent across edits

Character consistency is the main reason people use reference images. The workspace supports uploading multiple reference images so the model captures color tone, composition style, and scene details, and weaves them into the output. For a character, that means:

• Reuse the same base or reference set for every edit. Consistency comes from a fixed anchor, not from the prompt alone.
• Add references when the character appears in new contexts. If you move a character to a new scene, include both the character reference and a scene reference so the model has context for each.
• Describe the character's fixed traits in the keep section. Hair color, face shape, and signature clothing are the traits most likely to drift, so state them explicitly.
• Expect drift to accumulate. Each generation is a fresh interpretation. If a character looks slightly off after several edits, go back to the earliest good reference and re-edit from there.

How credits are consumed

Nano Banana 2 on this workspace uses a credit model: you get starter credits on sign-up, and continued use is paid. Editing is a generation, so each edit you run consumes credits the same way a fresh image generation does. Practical implications:

• Iterating costs credits. Re-running an edit to fix drift is another generation, so a tight prompt saves both time and credits.
• Check current pricing before scaling up. The site links to a pricing page; exact rates and plan details are not fixed here, so confirm them there rather than assuming.
• Starter credits are for trying the flow, not for volume work. Treat them as a way to test whether the edit quality meets your needs before committing to paid usage.

Common failure cases and how to correct them

Unwanted changes outside the edit area. The model altered the face, hands, or background you didn't mention. Fix: add an explicit keep clause naming those elements, and re-run from the original base.

Identity drift across a series. The character looks like a cousin rather than the same person. Fix: re-anchor to the first strong reference, include multiple reference images, and list the character's fixed traits in the prompt.

The edit is too subtle or too aggressive. "Change the lighting" may barely register, while "make it dramatic" may overhaul everything. Fix: name the specific attribute and its target state — "increase the key light from the left, keep shadows soft."

Prompt ignored entirely. Usually a sign the instruction conflicts with the base image or is buried in unrelated detail. Fix: shorten the prompt to one keep clause and one change clause, then expand only if needed.

When this workflow is the right choice

Use Nano Banana 2 editing when you have a base image you want to modify in a controlled way — especially when a character or product must stay recognizable across multiple versions. It is a good fit for iterating on a design prototype, restyling a photo, or placing a consistent character into new scenes.

It is a weaker fit when you want a fully new image with no anchor, or when you need pixel-exact, deterministic edits — text-guided editing is interpretive, so treat each result as a strong draft rather than a guaranteed output. If your goal is a brand-new visual, plain text-to-image generation in the same workspace is the more direct path.

Character consistency in Nano Banana 2 comes down to two things: a reference image that anchors the face and outfit, and a prompt that separates identity details from scene details. If you supply only a text description, expect the character to drift between generations. If you supply a reference image plus a short, structured identity block, you can reuse the same character across poses, scenes, and outfits with far fewer retries. This workflow applies to any image-editing session in the HeyMarmot workspace, where Nano Banana 2 runs alongside other models.

What character consistency means here

Consistency means the same person reads as the same person across multiple outputs — same facial structure, hair, skin tone, and signature clothing — even when the pose, background, or lighting changes.

Drift happens because image models regenerate the character from scratch each time. Nothing in a plain text prompt pins down "this exact face." Words like "a young woman with brown hair" describe a category, not a person, so every generation samples a different individual from that category.

Two levers reduce drift:

• A reference image carries the visual identity the prompt can't describe precisely.
• A locked identity block in the prompt keeps the details the reference can't fully control (exact outfit, color palette, distinguishing marks).

Use both. A reference image alone can still shift clothing and color; a prompt alone can't hold a face.

Build a reusable character reference

Do this once, then reuse it for every subsequent image.

Step 1 — Generate a clean base portrait. Create a single, front-facing image of your character with neutral lighting and a plain background. Avoid dramatic angles, heavy shadows, or busy scenes — those make the reference harder for the model to read.

Step 2 — Write an identity block. This is a short, fixed paragraph you paste into every prompt. Cover:

• Face: age range, face shape, distinguishing features
• Hair: color, length, texture, style
• Skin tone
• Outfit: specific garment, color, and material
• Palette: two or three dominant colors
• One or two unique marks (a scar, a specific accessory, a logo)

Keep it under about 60 words. Longer blocks dilute the signal.

Step 3 — Test the block. Generate three images with the same identity block and the same reference image, changing only the scene. If the character holds across all three, the block is working. If not, tighten the vague parts — usually hair and outfit.

Step-by-step: consistent character across new scenes

1. Upload your reference image as the visual anchor for the generation.
2. Paste the identity block at the start of the prompt, unchanged from previous runs.
3. Add the scene instruction after the identity block — new pose, background, action, or lighting.
4. Generate one image first. Check the face and outfit before committing to a batch.
5. Iterate on the scene only. If the character is right but the scene is wrong, edit the scene text and leave the identity block untouched.
6. Reuse the winning output as the new reference if you're moving to a very different angle or outfit, so the model has a fresh anchor.

The key discipline: never change the identity block and the scene at the same time. If something breaks, you won't know which change caused it.

Prompt patterns that lock identity while allowing scene changes

Structure your prompt in two clearly separated parts.

Identity block (fixed):

A woman in her late 20s, oval face, sharp jawline, dark brown wavy shoulder-length hair, warm medium skin tone, wearing a fitted charcoal turtleneck, small silver hoop earrings, a thin scar above the left eyebrow. Palette: charcoal, silver, warm beige.

Scene block (variable):

Standing in a rain-soaked neon alley at night, looking over her shoulder, cinematic lighting.

Swap only the scene block for each new image. This keeps the model's attention on the same identity while the environment changes freely.

For outfit changes, add an explicit override line rather than rewriting the identity block:

Keep the same face, hair, and skin tone. Change outfit to a cream linen shirt.

This tells the model which parts are allowed to move.

Common failure causes and fixes

The most common mistake is stacking edits. Each round of editing nudges the character slightly, and after four or five rounds the face is gone. Re-anchor from the original reference whenever you notice drift starting.

Planning credits around iteration

Consistency work is iterative, so budget for retries rather than expecting a first-try match. The HeyMarmot workspace provides free starter credits on sign-up, and continued use is paid — check the pricing page for current rates before a long session.

Practical planning:

• Front-load the work. Spend your first few generations nailing the base portrait and identity block. Every later image gets cheaper because you retry less.
• Generate one, then batch. Test a single image before running a set. A failed batch wastes far more credits than a failed single.
• Keep a reference library. Save your best base portrait and two or three approved scene images. Reusing them as anchors cuts retries on future projects.

Quick checklist

• One clean reference image, front-facing, neutral background
• Identity block under 60 words, pasted unchanged every time
• Scene instructions in a separate block, changed one variable at a time
• Re-anchor from the original reference when drift appears
• Test single images before batching to control credit spend

Nano Banana 2 prompts work best when you treat them as a short creative brief rather than a list of keywords. A reliable prompt names the subject, the action, the setting, the style, the lighting, and the framing — then stops. If you are editing an existing image instead of generating a new one, the same logic applies but the structure changes: state what to change and what to keep. The guidance below covers both cases, plus how to use reference images for character consistency and how to fix prompts that produce the wrong result.

The six-part prompt structure

Most failed prompts are missing one of these elements, or pile on so many that the model has to guess which one matters.

A complete generation prompt built from the table:

A ceramicist in her 60s shaping a bowl on a wheel, in a sunlit studio with clay-dusted shelves, editorial photography with muted earth tones, soft window light from the left, medium shot slightly above eye level.

That is roughly 40 words. It is specific enough to constrain the output and short enough that no element competes with another.

How long should a prompt be?

Longer is not better. Every added clause is another thing the model can weight differently than you intended. Start with the six elements above. Add detail only when a generation comes back wrong and you can name the specific thing that was wrong — then add one clause to fix it. If you add five clauses at once and the result improves, you will not know which one did the work.

Writing edit prompts: change this, keep that

Editing prompts fail differently from generation prompts. The common mistake is describing the desired final image instead of describing the change. The model then reinterprets the whole scene rather than modifying one part of it.

Write edit prompts as two explicit lists:

• Change: the specific element to modify — "replace the grey background with a warm terracotta wall"
• Keep: the elements that must survive untouched — "keep the subject's face, pose, clothing, and lighting unchanged"

For example, to swap a background without disturbing the subject:

Change the background to a warm terracotta wall. Keep the subject's face, hair, pose, clothing, and the existing light direction exactly as they are.

Naming what to keep is not optional. Without it, models frequently "improve" adjacent details — a face gets subtly re-rendered, a shadow shifts, a fabric texture changes. The keep-list is your protection against that drift.

One change per pass

If you need three edits, run three passes. Combining "change the background, brighten the image, and add a hat" into one instruction makes it hard to tell which instruction caused an unwanted side effect. Sequential single edits also let you stop as soon as the result is right, instead of regenerating everything.

Using reference images for character consistency

Character consistency across multiple images depends on giving the model a stable visual anchor, not on describing the character in more words. A reference image carries far more identity information than any paragraph of description.

The workflow that holds up:

1. Generate or select a clean reference. A clear, well-lit image of the character with an unobstructed face works better than a dramatic or partially cropped one.
2. Attach the reference to every subsequent generation. Do not rely on a text description of the character to carry identity forward.
3. Name the character in the prompt. Give them a consistent label — "Mira" — and use the same label every time. Named elements are easier to reference and easier to keep stable than "the woman in the red coat."
4. Describe only what changes. The reference handles identity; the prompt handles the new scene, pose, or action.

A consistency prompt looks like this:

Mira, standing in a rain-soaked alley at night, neon signage reflecting on wet pavement, cinematic photography, cool blue and magenta lighting, full-body shot.

The reference image supplies Mira's face and build. The prompt supplies everything else. If you instead re-describe Mira's features in text each time, small wording changes will produce small identity changes.

When consistency still drifts

If the character's identity shifts between generations, check these in order:

• Is the reference image attached to this generation, or did it drop out?
• Is the reference itself consistent — same person, same lighting, same angle as your other references?
• Did you add a clause that conflicts with the reference, such as a different hair color or age?
• Is the new scene so different in lighting or angle that the model is reconstructing rather than transferring the face?

Fix one of these at a time and regenerate. Changing several variables at once makes the cause unknowable.

Troubleshooting common prompt failures

The general rule for all of these: isolate one variable, change it, regenerate, compare. Rewriting the entire prompt after a bad result throws away the information you just gained about what the model did with your wording.

Iterating without wasting generations

Treat prompting as a loop, not a one-shot:

1. Write the six-element prompt.
2. Generate.
3. Compare the result against your intent and name the single biggest gap.
4. Change only the element responsible for that gap.
5. Regenerate and compare again.

Two or three passes usually converge. If you are several passes in and the result is not improving, the problem is usually structural — a missing reference image, a contradictory clause, or a prompt so long that no single element dominates. In that case, cut back to the six elements and start the loop again rather than adding more description.

Note that generation consumes credits on this platform, with starter credits on sign-up and paid usage afterward, so converging in fewer passes has a practical benefit beyond speed.

Nano Banana 2 credits are the usage units you spend to run image generation and editing inside a third-party multi-model workspace such as HeyMarmot. On HeyMarmot specifically, the site states that new accounts get free credits on sign-up, and that Nano Banana 2 usage beyond the starter amount is paid. That means credits are not a feature of the underlying model itself — they are the workspace's billing layer. If you are planning a batch of edits or a character-consistency series, the practical question is not "how many credits does Nano Banana 2 cost" in the abstract, but how your specific workspace meters each action.

What a credit actually represents

A credit is an internal accounting token, not a fixed unit of images. The workspace decides how many credits each action costs, and that number can vary by:

• Model choice — Nano Banana 2 may be priced differently from other image or video models in the same workspace.
• Task type — a fresh text-to-image generation is often metered differently from an edit of an existing image.
• Output settings — resolution, number of variations, or upscaling can change the cost.
• Retries — a re-run after an unsatisfactory result is usually a new charge, because the system performed new compute.

Because the site's public page does not publish a per-image credit table, treat any specific "1 credit = 1 image" assumption as unverified until you see it in your own account's pricing or usage screen.

How credits get consumed in practice

The pattern below is the typical flow in a credit-based creative workspace. Verify the exact labels against your own dashboard, since menu names differ between products.

1. Sign up — the site advertises free credits on sign-up, so your balance starts above zero without payment.
2. Submit a task — you enter a prompt, optionally upload reference images, and start the generation.
3. Credits are deducted — the deduction happens when the job is accepted for processing, not necessarily when you approve the result.
4. Review the output — if it works, you keep it. If not, you either refine the prompt or re-run, and each re-run is a separate spend.
5. Check your balance — most workspaces show remaining credits in the account or billing area, sometimes with a usage history listing each job.

The step that surprises people most is step 3. In many credit systems, a job that fails partway through still consumes credits because compute was already used. Whether HeyMarmot refunds failed jobs is not stated on the page evidence, so test with a small job before committing a large batch.

Free starter credits vs. paid usage

The site lists a Pricing page at heymarmot.com/pricing. Since the page evidence does not include specific prices, credit pack sizes, or whether subscriptions include a monthly credit allowance, check that page directly rather than assuming a rate.

Avoiding lost work when credits run low

The failure mode to design around is simple: you build a multi-step edit sequence, run out of credits at step four, and cannot finish. Practical habits:

• Check your balance before starting a series, not after the first result disappoints you.
• Front-load prompt testing on cheap, low-effort generations so your expensive runs are the ones you actually keep.
• Keep your reference images and prompts saved outside the tool so a credit interruption does not cost you the setup work too.
• Do one full end-to-end test — generate, edit, and export — before scaling to a batch, so you know the real credit cost per finished asset.

Common reasons a job fails or charges without output

• Prompt rejected or filtered — content policy blocks can stop a job before or during processing.
• Reference image problems — unsupported formats, oversized files, or images that conflict with the prompt.
• Timeout on complex edits — heavy multi-reference or high-resolution jobs are more likely to fail.
• Re-running instead of editing — starting a new generation when you meant to adjust the previous one doubles the spend.
• Assuming a failed job is free — unless the workspace documents refunds, assume the deduction stands.

If a job fails repeatedly, the cheapest diagnostic is usually to simplify: one reference image, a shorter prompt, default output settings. That isolates whether the problem is your input or the service.

Deciding whether credits work for you

Credits suit you if you want to try Nano Banana 2 without a commitment and your usage is bursty — a few sessions, then nothing for weeks. They work against you if you run high-volume batches with many retries, because every discarded attempt is a real cost. Before committing, confirm three things in your own account: the credit cost per generation and per edit, whether failed jobs are refunded, and what the paid top-up or subscription actually includes. Those three numbers determine whether the free starter credits are a genuine trial or just enough to show you the bill.