AI Game Asset & NFT Art Generation with Nano Banana 2: Consistent Character Styles in Seconds

If you're building a game or NFT collection, you know the struggle: maintaining a consistent art style across hundreds of assets is expensive, time-consuming, and frustrating. Traditional workflows require hiring multiple artists or spending weeks tweaking prompts to keep characters looking cohesive. Nano Banana 2 changes that. With its multi-turn image editing and reference-image input capabilities, you can lock a style and generate dozens of consistent assets in minutes. Better yet, using WisGate's API, you'll spend less than half the cost of official pricing while maintaining stable, high-quality output. Let's walk through how to generate 50 style-consistent game assets for just $2.90.

Understanding the Challenge of Consistent Character Art Styles

Generating game assets or NFT art at scale presents a unique problem. You need dozens—sometimes hundreds—of characters, items, or environments that all feel like they belong in the same world. Without consistency, your game looks disjointed. With traditional AI image generation, each prompt produces wildly different interpretations of style, proportions, and aesthetic. You end up spending hours tweaking prompts, regenerating images, and manually editing to achieve uniformity.

The cost compounds quickly. Official Nano Banana 2 pricing runs $0.068 per image. Generate 50 assets, and you're looking at $3.40 before any failed attempts or regenerations. For indie developers and NFT creators working on tight budgets, that adds up fast. Beyond cost, there's the time factor. Each generation takes precious minutes, and inconsistent results mean more iterations.

This is where style locking becomes essential. Instead of hoping each new prompt produces a cohesive look, you establish a visual reference upfront and use it to guide every generation. Nano Banana 2's multi-turn editing and reference-image input features make this possible. You define the style once, then batch-generate dozens of variations that maintain that aesthetic. Combined with WisGate's more affordable pricing at $0.058 per image, you get professional-quality, consistent assets without breaking the bank.

How Nano Banana 2's Multi-Turn Editing and Reference-Image Input Work

Nano Banana 2 introduces two powerful capabilities for style consistency: multi-turn image editing and reference-image input. Understanding how these work is key to unlocking efficient batch generation.

Multi-turn image editing allows you to iteratively refine an image across multiple API calls while maintaining context. Instead of starting from scratch each time, you build on previous results. This means you can generate a base character, then use follow-up prompts to adjust details—adding accessories, changing poses, or tweaking colors—all while preserving the core style established in your reference image.

Reference-image input is the real game-changer. You provide a single image that defines your desired aesthetic. This could be a pixel art character, a fantasy illustration, or a specific art style you want to replicate. Nano Banana 2 uses this reference to guide all subsequent generations, ensuring new assets match that visual language. This eliminates the guesswork and dramatically reduces the number of failed attempts.

For pixel art styles, effective prompts include descriptors like "8-bit sprite style," "retro game character," or "isometric pixel art." For fantasy art, try "hand-painted fantasy illustration," "D&D character art," or "watercolor fantasy style." These patterns, combined with your reference image, create a powerful constraint that keeps output consistent.

Step-by-Step Tutorial: Batch Generating Style-Consistent Assets

Now let's generate 50 style-consistent game assets using WisGate's API. This tutorial assumes you have a WisGate account and an API key. If not, start your free trial at https://wisgate.ai/.

Step 1: Prepare Your Reference Image

First, select or create a reference image that defines your desired style. This could be an existing character, an art style sample, or a custom illustration. Save it as a PNG or JPEG. For this example, we'll use a pixel art character as our reference. The image should be clear and representative of the aesthetic you want across all 50 assets.

Step 2: Encode Your Reference Image to Base64

The WisGate API accepts images as base64-encoded strings. Convert your reference image using a command-line tool or online converter. On macOS or Linux:

base64 -i reference_character.png > reference_base64.txt

On Windows, use an online base64 encoder or PowerShell:

[Convert]::ToBase64String([IO.File]::ReadAllBytes('reference_character.png')) | Out-File reference_base64.txt

Step 3: Craft Your Style-Locked Prompt

Write a prompt that combines your style descriptor with the asset you want to generate. For pixel art game characters:

"Generate a pixel art game character in the same style as the reference image. The character should be a warrior with a sword, wearing armor. Use the exact same color palette, proportions, and 8-bit sprite aesthetic."

For fantasy NFT art:

"Create a fantasy character illustration matching the reference image's style. The character is a mage with magical robes and a staff. Maintain the same hand-painted aesthetic, color scheme, and fantasy art style."

Step 4: Make Your First API Call to Test

Before batch generating, test a single request to ensure your reference image and prompt work together. Use this curl command:

curl -s -X POST \
  "https://wisgate.ai/v1beta/models/gemini-3-pro-image-preview:generateContent" \
  -H "x-goog-api-key: $WISDOM_GATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "YOUR_BASE64_REFERENCE_IMAGE_HERE"
          }
        },
        {
          "text": "Generate a pixel art game character in the same style as the reference image. The character should be a warrior with a sword, wearing armor. Use the exact same color palette, proportions, and 8-bit sprite aesthetic."
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["TEXT", "IMAGE"],
      "imageConfig": {
        "aspectRatio": "1:1",
        "imageSize": "2K"
      }
    }
  }' | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' | head -1 | base64 --decode > character_1.png

Replace $WISDOM_GATE_KEY with your actual API key and YOUR_BASE64_REFERENCE_IMAGE_HERE with your encoded reference image. This generates one character and saves it as character_1.png. Review the output to confirm the style matches your reference.

Step 5: Batch Generate 50 Assets

Once your test succeeds, create a simple script to generate 50 assets. Here's a bash script:

#!/bin/bash

API_KEY="$WISDOM_GATE_KEY"
REFERENCE_IMAGE=$(cat reference_base64.txt)
BASE_PROMPT="Generate a pixel art game character in the same style as the reference image. The character should be a [CHARACTER_TYPE] with [EQUIPMENT]. Use the exact same color palette, proportions, and 8-bit sprite aesthetic."

CHARACTER_TYPES=("warrior" "mage" "rogue" "paladin" "ranger" "cleric" "barbarian" "bard")
EQUIPMENT=("sword" "staff" "bow" "axe" "spear" "dagger" "hammer" "wand")

for i in {1..50}; do
  TYPE=${CHARACTER_TYPES[$((RANDOM % ${#CHARACTER_TYPES[@]}))]}
  EQUIP=${EQUIPMENT[$((RANDOM % ${#EQUIPMENT[@]}))]}
  PROMPT="${BASE_PROMPT//\[CHARACTER_TYPE\]/$TYPE}"
  PROMPT="${PROMPT//\[EQUIPMENT\]/$EQUIP}"
  
  curl -s -X POST \
    "https://wisgate.ai/v1beta/models/gemini-3-pro-image-preview:generateContent" \
    -H "x-goog-api-key: $API_KEY" \
    -H "Content-Type: application/json" \
    -d "{
      \"contents\": [{
        \"parts\": [
          {
            \"inlineData\": {
              \"mimeType\": \"image/png\",
              \"data\": \"$REFERENCE_IMAGE\"
            }
          },
          {
            \"text\": \"$PROMPT\"
          }
        ]
      }],
      \"generationConfig\": {
        \"responseModalities\": [\"TEXT\", \"IMAGE\"],
        \"imageConfig\": {
          \"aspectRatio\": \"1:1\",
          \"imageSize\": \"2K\"
        }
      }
    }" | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' | head -1 | base64 --decode > "character_$i.png"
  
  echo "Generated character $i of 50"
  sleep 1
done

Save this as generate_assets.sh, make it executable with chmod +x generate_assets.sh, then run it. The script generates 50 characters with randomized types and equipment, all maintaining your reference style. Each generation takes about 20 seconds, so the full batch completes in roughly 16–17 minutes.

Pricing and Performance Advantages with WisGate API

Let's talk numbers. The official Nano Banana 2 rate is $0.068 per image. WisGate provides the same stable quality at $0.058 per image—a 15% savings. For 50 assets, that's $2.90 instead of $3.40. Over a project generating 500 assets, you save $50. For larger collections, the savings compound significantly.

Performance is equally impressive. WisGate delivers consistent 20-second generation times across base64 outputs from 0.5k to 4k resolution. This stability means predictable batch times. Generating 50 assets takes roughly 16–17 minutes, allowing you to iterate quickly and test different styles without long waits.

To get started, visit https://wisgate.ai/studio/image to explore interactive image generation, or dive directly into the API at https://wisgate.ai/v1beta/models/gemini-3-pro-image-preview:generateContent. The API documentation provides additional parameters for fine-tuning aspect ratios, image sizes, and generation settings.

For developers integrating into production workflows, WisGate's unified API platform supports multiple model types—image, video, and coding—through a single endpoint. This simplifies infrastructure and reduces vendor lock-in.

Final Thoughts and Next Steps for Game Developers and NFT Creators

Consistent art at scale no longer requires hiring a team or spending weeks on manual tweaking. Nano Banana 2's multi-turn editing and reference-image input, combined with WisGate's affordable API, make it possible to generate hundreds of cohesive assets quickly and affordably.

The workflow is straightforward: define your style with a reference image, craft prompts that maintain that aesthetic, and batch-generate assets through WisGate's API. At $2.90 for 50 high-quality characters, you're looking at production-ready game assets or NFT art at a fraction of traditional costs.

Ready to start? Head to https://wisgate.ai/ and sign up for a free trial. Explore the Nano Banana 2 model in WisGate AI Studio, test the API with your own reference images, and begin generating your style-locked asset collection today. Whether you're an indie developer shipping your first game or an NFT creator scaling your collection, WisGate makes it faster and more affordable to bring your vision to life.