Authorization: Bearer YOUR_API_KEY

// ❌ Never hardcode API keys
const apiKey = 'nb2_abc123...';

// ✅ Use environment variables
const apiKey = process.env.NANO_BANANA_API_KEY;

const response = await fetch('https://api.nano-banana2.com/api/v1/generate', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({

{
  "id": "gen_abc123xyz",
  "status": "completed",
  "created_at": "2025-11-12T10:30:00Z",
  "outputs": [
    {
      "url": "https://cdn.nano-banana2.com/outputs/abc123.png",
      "width": 1920,
      "height": 1080
    }
  ],
  "credits_used": 4

const formData = new FormData();
formData.append('image', imageFile);
formData.append('prompt', 'Change the background to a sunset beach scene');
formData.append('aspect_ratio', 'auto');
formData.append('output_format'

const formData = new FormData();
formData.append('image1', firstImage);
formData.append('image2', secondImage);
formData.append('prompt', 'Blend these images with natural lighting and unified style');
formData.append('blend_strength', 

const response = await fetch(
  `https://api.nano-banana2.com/api/v1/status/${jobId}`,
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`
    }
  }
);

const status = await response.json

import { NanoBanana2Client } from '@nano-banana2/sdk';

const client = new NanoBanana2Client({
  apiKey: process.env.NANO_BANANA_API_KEY
});

// Generate image
async function generateImage() {
  try {

from nano_banana2 import NanoBanana2Client
import os
import asyncio

client = NanoBanana2Client(api_key=os.getenv('NANO_BANANA_API_KEY'))

# Generate image
async def

// Step 1: Generate base character
const baseCharacter = await client.generate({
  prompt: "A friendly robot character with yellow banana-shaped head, blue uniform",
  aspectRatio: "1:1"
});

const characterRefUrl = baseCharacter.outputs[0].url;

// Step 2: Generate scenes with consistent character

// Generate style reference
const styleRef = await client.generate({
  prompt: "Abstract art style, vibrant colors, geometric shapes",
  aspectRatio: "1:1"
});

// Apply style to new generations
const styledImage = await client.generate({

// Register webhook endpoint
app.post('/webhooks/nano-banana', (req, res) => {
  const { job_id, status, outputs } = req.body;

  if (status ===

class RateLimitedClient {
  private queue: Array<() => Promise<any>> = [];
  private processing = false;
  private requestsPerSecond = 10;

async function generateWithRetry(
  params: GenerateParams,
  maxRetries = 3
): Promise<GenerateResponse> {
  for (let attempt = 0; attempt <

import Redis from 'ioredis';
import crypto from 'crypto';

const redis = new Redis(process.env.REDIS_URL);

async function getCachedOrGenerate(params:

class CreditManager {
  async checkBalance(): Promise<number> {
    const response = await fetch(
      'https://api.nano-banana2.com/api/v1/credits/balance',
      {
        headers: { 'Authorization': 

import { Logger } from 'winston';

class MonitoredClient {
  private logger: Logger;
  private metrics: MetricsCollector;

  async generate(params: GenerateParams

// Express.js API endpoint
app.post('/api/images/generate', authenticate, async (req, res) => {
  try {
    const { prompt, aspectRatio } = req.body;

async function generateProductVariants(
  productImage: string,
  backgrounds: string[]
) {
  const variants = await Promise.all(
    backgrounds.map(

async function moderateAndGenerate(prompt: string) {
  // Pre-generation moderation
  const moderationResult = await moderatePrompt(prompt);

  if (!moderationResult.safe) {
    throw new Error(

async function generateMultiplePrompts(prompts: string[]) {
  // Process in batches to avoid rate limits
  const batchSize = 10;
  const results = [];

  for (let i = 0

import sharp from 'sharp';

async function optimizeGeneratedImage(imageUrl: string) {
  // Download image
  const response = await fetch(imageUrl);
  const buffer = await

import { describe, it, expect, vi } from 'vitest';

describe('NanoBanana2Client', () => {
  it('should generate image successfully', async () => {
    const mockClient = {
      generate: vi.

describe('Nano Banana 2 Integration', () => {
  it('should generate real image', async () => {
    const client = new NanoBanana2Client({
      apiKey: process.env.TEST_API_KEY
    });

# .env.production
NANO_BANANA_API_KEY=your_production_key
NANO_BANANA_API_URL=https://api.nano-banana2.com
REDIS_URL=redis://your-redis-url
CDN_URL=https://your-cdn.com
MAX_CONCURRENT_REQUESTS=10
REQUEST_TIMEOUT=30000

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

ENV NODE_ENV=production
ENV PORT=3000

EXPOSE 3000

CMD ["node", "dist/server.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nano-banana-app
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: app
        image: your-app:latest
        env:
        - 

// Solution: Increase timeout and implement retry
const result = await client.generate({
  prompt: "complex scene",
  timeout: 60000, // 60 seconds
  retries: 3
});

// Solution: Implement exponential backoff
if (error.status === 429) {
  const retryAfter = error.headers['retry-after'];
  await sleep(retryAfter * 1000);
  return await client.generate(params);

// Solution: Use seed for reproducibility
const result = await client.generate({
  prompt: "character description",
  seed: 42,
  referenceImages: [characterUrl]
});

const promptSimilarity = calculateSimilarity(newPrompt, cachedPrompt);
if (promptSimilarity > 0.95) {
  return getCachedResult(cachedPrompt);
}

const results = await client.generateBatch({
  prompts: arrayOfPrompts,
  sharedParams: {
    aspectRatio: "16:9",
    outputFormat: "jpeg"
  }
});

// Generate base scenes once
const baseScenes = await generateBaseScenes();

// Reuse in different contexts
const variations = await Promise.all(
  baseScenes.map(scene =>
    client.edit