Gemini Image Generation (Nano Banana Series)

curl -X POST "https://api.laozhang.ai/v1/chat/completions" \
     -H "Authorization: Bearer $API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
    "model": "gemini-3-pro-image-preview",
    "stream": false,
    "messages": [
        {
            "role": "user",
            "content": "a beautiful sunset over mountains"
        }
    ]
}'

from openai import OpenAI
import base64
import re

client = OpenAI(
    api_key="sk-YOUR_API_KEY",
    base_url="https://api.laozhang.ai/v1"
)

response = client.chat.completions.create(
    model="gemini-3-pro-image-preview",  # Latest version, or use gemini-2.5-flash-image (stable)
    messages=[
        {
            "role": "user",
            "content": "a beautiful sunset over mountains"
        }
    ]
)

# Extract base64 image data
content = response.choices[0].message.content
match = re.search(r'!\[.*?\]\((data:image/png;base64,.*?)\)', content)

if match:
    base64_data = match.group(1).split(',')[1]
    image_data = base64.b64decode(base64_data)
    
    with open('output.png', 'wb') as f:
        f.write(image_data)
    print("✅ Image saved: output.png")

#!/bin/bash

# 1. Set API Key
export API_KEY="sk-YOUR_API_KEY"

# 2. Send request (Using Nano Banana 2 to generate 4K image)
curl -s -X POST "https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [
        {"text": "A futuristic city skyline at sunset, high detailed, 4k"}
      ]
    }],
    "generationConfig": {
      "responseModalities": ["IMAGE"],
      "imageConfig": {
        "aspectRatio": "16:9",
        "imageSize": "4K"
      }
    }
  }' \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 --decode > output_4k.png

echo "✅ 4K image saved: output_4k.png"

import requests
import base64
import os
import datetime

# --- API Key Configuration ---
API_KEY = "sk-YOUR_API_KEY"  # Replace with your API Key

# --- Parameters ---
PROMPT = "A cute orange cat"
ASPECT_RATIO = "1:1"
IMAGE_SIZE = "2K"  # Only Nano Banana 2 supports 1K, 2K, 4K
OUTPUT_DIR = "."  # Image save directory

# --- API Endpoint (Nano Banana 2) ---
API_URL = "https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent"

def generate_text_to_image(api_key, prompt, aspect_ratio, image_size, output_dir, api_url):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    payload = {
        "contents": [{"parts": [{"text": prompt}]}],
        "generationConfig": {
            "responseModalities": ["IMAGE"],
            "imageConfig": {
                "aspectRatio": aspect_ratio,
                "imageSize": image_size
            }
        }
    }

    print(f"🚀 Generating text-to-image (Nano Banana 2, {image_size})...")
    print(f"📝 Prompt: {prompt}")
    print(f"📐 {aspect_ratio} | {image_size}")

    try:
        response = requests.post(api_url, headers=headers, json=payload, timeout=180)
        if response.status_code != 200:
            print(f"❌ API request failed: {response.status_code} - {response.text}")
            return False
        
        result = response.json()
        image_data_b64 = result["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
        raw_data = base64.b64decode(image_data_b64)
        
        output_path = os.path.join(output_dir, "output.png")
        with open(output_path, "wb") as f:
            f.write(raw_data)
        
        print(f"✅ Image saved: {output_path}")
        return True
    except Exception as e:
        print(f"❌ Error: {str(e)}")
        return False

if __name__ == "__main__":
    generate_text_to_image(API_KEY, PROMPT, ASPECT_RATIO, IMAGE_SIZE, OUTPUT_DIR, API_URL)

import requests
import base64
import os
import datetime

# --- API Key Configuration ---
API_KEY = "sk-YOUR_API_KEY"  # Replace with your API Key

# --- Parameters ---
INPUT_IMAGE_PATH = "output.png"  # Use the image generated from Example 1
PROMPT = "Transform this cat into a Van Gogh Starry Night style oil painting"
ASPECT_RATIO = "1:1"
IMAGE_SIZE = "2K"
OUTPUT_DIR = "."

# --- API Endpoint (Nano Banana 2) ---
API_URL = "https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent"

def encode_image_to_base64(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def get_mime_type(image_path):
    ext = os.path.splitext(image_path)[1].lower()
    if ext in [".jpg", ".jpeg"]:
        return "image/jpeg"
    elif ext == ".png":
        return "image/png"
    else:
        return "application/octet-stream"  # Default type

def generate_image_to_image(api_key, input_image_path, prompt, aspect_ratio, image_size, output_dir, api_url):
    if not os.path.exists(input_image_path):
        print(f"❌ Error: Input image '{input_image_path}' not found.")
        return False

    encoded_image = encode_image_to_base64(input_image_path)
    mime_type = get_mime_type(input_image_path)

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
        }
    payload = {
        "contents": [{
            "parts": [
                {"text": prompt},
                {"inline_data": {"mime_type": mime_type, "data": encoded_image}}
            ]
        }],
        "generationConfig": {
            "responseModalities": ["IMAGE"],
            "imageConfig": {
                "aspectRatio": aspect_ratio,
                "imageSize": image_size
            }
        }
    }
    
    print(f"🚀 Generating image-to-image (Nano Banana 2, {image_size})...")
    print(f"📝 Prompt: {prompt}")
    print(f"📁 Input: {input_image_path}")

    try:
        response = requests.post(api_url, headers=headers, json=payload, timeout=180)
        if response.status_code != 200:
            print(f"❌ API request failed: {response.status_code} - {response.text}")
            return False
        
        result = response.json()
        image_data_b64 = result["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
        raw_data = base64.b64decode(image_data_b64)
        
        output_path = os.path.join(output_dir, "output_styled.png")
        with open(output_path, "wb") as f:
            f.write(raw_data)
            
        print(f"✅ Image saved: {output_path}")
        return True
    except Exception as e:
        print(f"❌ Error: {str(e)}")
        return False

if __name__ == "__main__":
    generate_image_to_image(API_KEY, INPUT_IMAGE_PATH, PROMPT, ASPECT_RATIO, IMAGE_SIZE, OUTPUT_DIR, API_URL)

import requests
import base64
import os
import datetime

# --- API Key Configuration ---
API_KEY = "sk-YOUR_API_KEY"  # Replace with your API Key

# --- Parameters ---
INPUT_IMAGE_PATHS = ["output.png", "output_styled.png"]  # Use images from Examples 1 and 2
PROMPT = "Combine these two cat images into a single artistic composition"
ASPECT_RATIO = "16:9"
IMAGE_SIZE = "2K"  # Nano Banana 2 supports 1K, 2K, 4K
OUTPUT_DIR = "."

# --- API Endpoint (Nano Banana 2) ---
API_URL = "https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent"

def encode_image_to_base64(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def get_mime_type(image_path):
    ext = os.path.splitext(image_path)[1].lower()
    if ext in [".jpg", ".jpeg"]:
        return "image/jpeg"
    elif ext == ".png":
        return "image/png"
    else:
        return "application/octet-stream"  # Default type

def generate_multi_image(api_key, input_image_paths, prompt, aspect_ratio, image_size, output_dir, api_url):
    parts = [{"text": prompt}]
    for path in input_image_paths:
        if not os.path.exists(path):
            print(f"❌ Error: Input image '{path}' not found. Please ensure the image is in the current directory.")
            return False
        encoded_image = encode_image_to_base64(path)
        mime_type = get_mime_type(path)
        parts.append({"inline_data": {"mime_type": mime_type, "data": encoded_image}})

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    payload = {
        "contents": [{"parts": parts}],
        "generationConfig": {
            "responseModalities": ["IMAGE"],
            "imageConfig": {
            "aspectRatio": aspect_ratio,
            "imageSize": image_size
            }
        }
    }

    print(f"🚀 Generating multi-image mix (Nano Banana 2, {image_size})...")
    print(f"📝 Prompt: {prompt}")
    print(f"📁 Input: {len(input_image_paths)} images")

    try:
        response = requests.post(api_url, headers=headers, json=payload, timeout=180)
        if response.status_code != 200:
            print(f"❌ API request failed: {response.status_code} - {response.text}")
            return False
        
        result = response.json()
        image_data_b64 = result["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
        raw_data = base64.b64decode(image_data_b64)
        
        output_path = os.path.join(output_dir, "output_mixed.png")
        with open(output_path, "wb") as f:
            f.write(raw_data)
            
        print(f"✅ Image saved: {output_path}")
        return True
    except Exception as e:
        print(f"❌ Error: {str(e)}")
        return False

if __name__ == "__main__":
    generate_multi_image(API_KEY, INPUT_IMAGE_PATHS, PROMPT, ASPECT_RATIO, IMAGE_SIZE, OUTPUT_DIR, API_URL)

import requests
import base64

API_KEY = "sk-YOUR_API_KEY"
API_URL = "https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent"

payload = {
    "contents": [{
        "parts": [{"text": "Visualize the current weather forecast for the next 5 days in San Francisco as a clean, modern weather chart"}]
    }],
    "tools": [{"google_search": {}}],  # Enable Google Search
    "generationConfig": {
      "responseModalities": ["TEXT", "IMAGE"],
      "imageConfig": {"aspectRatio": "16:9"}
    }
}

response = requests.post(API_URL, headers={
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}, json=payload, timeout=180)

result = response.json()
image_data = result["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
with open("weather_chart.png", "wb") as f:
    f.write(base64.b64decode(image_data))

# See the "Multi-Image Mixing" example above
# You can pass up to 14 images in the "parts" array

# Nano Banana (stable)
model="gemini-2.5-flash-image"

# Nano Banana 2 (latest)
model="gemini-3-pro-image-preview"

# Nano Banana (stable)
https://api.laozhang.ai/v1beta/models/gemini-2.5-flash-image:generateContent

# Nano Banana 2 (latest)
https://api.laozhang.ai/v1beta/models/gemini-3-pro-image-preview:generateContent

{
  "generationConfig": {
    "responseModalities": ["IMAGE"],
    "imageConfig": {
      "aspectRatio": "16:9",
      "imageSize": "4K"  // Must be uppercase "K"
    }
  }
}