Cara Membuat Gambar Nano Banana 2.1 & Nano Banana Pro lewat Google Flow API

6 menit baca • 15 Juni 2026 (6 November 2026)

useapi.net adalah API pihak ketiga. Kami tidak berafiliasi dengan Google dan tidak disahkan oleh Google.

Daftar isi

  1. Pendahuluan
  2. Model yang didukung
    1. Upscale ke 2K/4K
  3. Harga
  4. Cara membuat gambar Nano Banana dengan curl
  5. Gambar referensi & karakter
  6. Generate batch dengan skrip
  7. Contoh
  8. Pertanyaan yang sering diajukan
  9. Kesimpulan

Pendahuluan

Satu POST sinkron ke Google Flow API useapi.net mengembalikan hingga empat gambar Nano Banana 2.1, Nano Banana Pro, atau Nano Banana 2 Lite, yang dibuat dengan akun Google Flow Anda. Gambar sudah termasuk di setiap langganan Google AI, akun gratis juga, sementara Gemini API resmi menagih $0,034 sampai $0,134 per gambar (per November 2026). Tidak perlu project Google Cloud dan tidak perlu API key Gemini.

Panduan ini membahas model yang tersedia, selisih harganya, alur pembuatan gambar dengan satu panggilan curl yang tinggal disalin, dan skrip Node.js siap jalan yang membuat gambar secara batch dari daftar prompt. Ingin melihat beda ketiga model pada satu prompt? Lihat perbandingan model Nano Banana. Butuh video? Lihat tutorial Veo 3.1, pasangan panduan ini.

Model yang didukung

Pilih model per request dengan field model (default nano-banana-2-lite). Ketiga model berjalan di langganan Google AI mana pun, termasuk akun gratis.

ID model Nama pemasaran Referensi (I2I) Rasio aspek Catatan
nano-banana-2-lite (default) Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image maks. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† Model gambar default Google Flow sejak Juli 2026. Di mode image-to-image tetap 16:9 kecuali Anda mengirim rasio
nano-banana-2 Nano Banana 2.1 maks. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† Default auto di mode image-to-image
nano-banana-pro Nano Banana Pro / Gemini 3 Pro Image maks. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† Model gambar dengan kualitas tertinggi, default auto di mode image-to-image

† auto hanya berlaku di mode image-to-image (minimal satu reference_* atau character_* dikirim), dan backend menentukan rasionya dari gambar referensi pertama. Dengan beberapa referensi, orientasinya tidak dijamin, jadi kirim rasio yang eksplisit jika semua gambar harus kembali dengan bentuk yang sama.

Ketiganya menerima count (1–4) dan seed agar hasilnya bisa diulang. Jika model tidak diisi, API memakai nano-banana-2-lite, dengan atau tanpa referensi. Dua alias lama masih diterima: nano-banana dipetakan ke nano-banana-2, dan imagen-4 ke nano-banana-2-lite (Google menghapus Imagen dari Google Flow pada Juli 2026). Detail dan kemampuan tiap model ada di referensi POST /images.

Upscale ke 2K/4K

Gambar dari ketiga model bisa di-upscale dengan POST /images/upscale: kirim mediaGenerationId gambar dan resolution bernilai 2k (default) atau 4k. Responsnya berupa base64 di encodedImage. 2k berjalan di paket mana pun, termasuk akun gratis. 4k butuh Google AI Ultra, dan di paket lain langsung menjawab 400 dengan 4k upscaling is not available for this account sebelum captcha diselesaikan, jadi tidak ada biaya dan mencoba ulang tidak akan membantu. Keduanya tidak memakai kredit Flow.

Harga

Gambar tidak memakai kredit Flow di langganan Google AI mana pun, termasuk akun gratis, dan useapi.net tidak menagih biaya per gambar. Paket berbayar hanya diperlukan untuk video Omni 1.1 Flash, video Omni 1.2 Flash yang lebih dari 10 detik, extend dengan Omni 1.2, dan upscale video, sedangkan upscale gambar 4k butuh Ultra. Harga setiap model di setiap paket, dibandingkan dengan API resmi, ada di tabel harga Google Flow.

Cara membuat gambar Nano Banana dengan curl

Anda butuh API token useapi.net dan akun Google Flow yang sudah terhubung. Pembuatan gambar bersifat sinkron: satu POST menunggu sampai gambar selesai (biasanya 10–20 detik) dan mengembalikannya di respons, jadi tidak ada jobid yang perlu di-poll. Langkah kedua tinggal menyimpan hasilnya, dari URL bertanda tangan, atau jika URL itu tidak ada, dari gambar base64 inline.

  1. Kirim prompt — POST https://api.useapi.net/v1/google-flow/images:
curl -X POST "https://api.useapi.net/v1/google-flow/images" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Cat dressed like a pirate fencing with a real pirate, pirate looks absolutely terrified, this is happening on a deck of the Disney cruise ship",
    "model": "nano-banana-pro",
    "aspectRatio": "16:9",
    "count": 4,
    "seed": 123456
  }' > response.json

Panggilan ini mengembalikan 200 OK dengan jobId dan array media, satu entri per gambar (count 1–4, default 4). URL unduhan bertanda tangan untuk tiap gambar ada di media[].image.generatedImage.fifeUrl:

{
  "jobId": "j1731859345678i-u12345-email:jo***@gmail.com-bot:google-flow",
  "media": [
    {
      "image": {
        "generatedImage": {
          "seed": 123456,
          "mediaGenerationId": "user:12345-email:6a6f...-image:...",
          "prompt": "Cat dressed like a pirate fencing with a real pirate, pirate looks absolutely terrified, this is happening on a deck of the Disney cruise ship",
          "fifeUrl": "https://flow-content.google/image/...",
          "aspectRatio": "IMAGE_ASPECT_RATIO_LANDSCAPE"
        }
      }
    }
  ]
}
  1. Unduh gambar dari fifeUrl (URL bertanda tangan hanya berlaku sebentar, jadi segera unduh). Sesekali fifeUrl tidak ada dan gambar dikirim inline sebagai base64 di encodedImage, jadi dekode field itu sebagai cadangan:
URL=$(jq -r '.media[0].image.generatedImage.fifeUrl // empty' response.json)
if [ -n "$URL" ]; then
  curl -o image_1.jpg "$URL"
else
  jq -r '.media[0].image.generatedImage.encodedImage' response.json | base64 -d > image_1.jpg
fi

mediaGenerationId setiap gambar yang dihasilkan bisa dipakai lagi sebagai referensi di request berikutnya. Lihat Gambar referensi & karakter di bawah.

Ingin webhook juga? Kirim replyUrl di body request, dan API juga mengirim pembaruan status job ke URL itu. Panggilannya sendiri tetap menunggu sampai gambar selesai. Payload-nya sama dengan respons GET /jobs/jobId, dan gambar yang sudah selesai ada di response.media[].image.generatedImage.fifeUrl.

Gambar referensi & karakter

Untuk mengarahkan gambar dengan foto yang sudah ada, unggah dulu foto itu dengan POST /assets/email (byte mentah, Content-Type gambar, PNG/JPEG/WebP sampai 20 MB). Respons unggahan menaruh ID referensi bersarang di mediaGenerationId.mediaGenerationId, dan string bersarang itulah yang Anda kirim kembali sebagai reference_1 (ketiga model masing-masing menerima hingga 10 referensi):

# 1. Unggah gambar referensi
curl -X POST "https://api.useapi.net/v1/google-flow/assets/john%40gmail.com" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: image/jpeg" \
  --data-binary @reference.jpeg

# Respons: ID referensi bersarang satu tingkat di dalam:
# {
#   "mediaGenerationId": {
#     "mediaGenerationId": "user:12345-email:6a6f...-image:ff9aa5cc-..."
#   },
#   "width": 1024, "height": 1024, "email": "jo***@gmail.com"
# }

# 2. Buat gambar dengan referensi itu
curl -X POST "https://api.useapi.net/v1/google-flow/images" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-pro",
    "prompt": "Make this photograph look modern",
    "reference_1": "user:12345-email:6a6f...-image:ff9aa5cc-..."
  }'

Untuk menjaga identitas yang sama di banyak gambar, gabungkan 1–2 gambar referensi menjadi karakter yang bisa dipakai ulang dengan POST /characters, lalu kirim ID character-nya sebagai character_1…character_7. Karakter bisa dicampur bebas dengan reference_* dan berbagi batas jumlah gambar referensi yang sama untuk tiap model. Anda juga bisa menaruh penanda @reference_1 / @character_1 langsung di prompt untuk menunjukkan di bagian mana tiap gambar dipakai, dan setiap penanda inline harus punya parameter body yang cocok.

Generate batch dengan skrip

Mendapatkan gambar yang pas butuh banyak percobaan, dan menjalankannya satu per satu secara manual itu melelahkan. Skrip Node.js di bawah membaca daftar prompt dari prompts.json, mengunggah gambar referensi, mengirim setiap request, dan mengunduh semua gambar yang dikembalikan, jadi Anda bisa mengantrekan satu batch dan kembali nanti untuk memilih yang terbaik. Karena POST /images sinkron, skrip menyimpan setiap hasil begitu panggilannya selesai.

Anda butuh Node.js v21 atau lebih baru. Taruh prompts.json dan google-flow-images.mjs di folder yang sama lalu jalankan node ./google-flow-images.mjs API_TOKEN EMAIL, dengan API_TOKEN adalah API token useapi.net Anda dan EMAIL adalah email akun Google Flow yang sudah terhubung. Skrip mencari akun berdasarkan email secara otomatis dan memeriksa field health sebelum mengirim.

Lebih suka clone dan menjalankannya sendiri? google-flow-images.mjs dan prompts.json lengkap ada di GitHub di useapi/google-flow-api.

Buka prompts.json 
[
    {
        "prompt": "By default the nano-banana-2-lite model generates 4 image variations at 16:9."
    },
    {
        "model": "nano-banana-pro",
        "aspectRatio": "1:1",
        "count": 2,
        "seed": 123456,
        "prompt": "Nano Banana Pro (Gemini 3 Pro Image), two square variations. For all parameters see https://useapi.net/docs/api-google-flow-v1/post-google-flow-images"
    },
    {
        "model": "nano-banana-2",
        "aspectRatio": "auto",
        "reference_1": "./reference_image.jpeg",
        "prompt": "Image-to-image: pass a local reference file as reference_1 (uploaded automatically). auto aspect ratio derives from the first reference. All three models accept up to 10 references."
    },
    {
        "model": "nano-banana-2-lite",
        "aspectRatio": "9:16",
        "count": 4,
        "prompt": "Nano Banana 2 Lite portrait. Other models (nano-banana-2, nano-banana-pro) are selectable via the model field — see the POST /images docs."
    }
]
Buka skrip google-flow-images.mjs 
/*

Script version 1.2, September 11, 2026

Script to batch-generate images using prompts with the Google Flow API v1 by useapi.net 🚀
Uses the synchronous POST /images endpoint (default model: nano-banana-2-lite) and saves each image from fifeUrl, or from encodedImage when fifeUrl is absent.
For more details visit https://useapi.net/docs/api-google-flow-v1/post-google-flow-images

Installation Instructions:
==========================

You need Node.js v21 or newer installed to run this script. Download and install Node.js from:

- Windows, macOS, Linux: https://nodejs.org/

After installation, verify by running the following command in a terminal:

   node -v

Running the Script:
===================

Usage: node google-flow-images.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]

Replace API_TOKEN with your actual useapi.net API token, see https://useapi.net/docs/start-here/setup-useapi
Replace EMAIL with configured Google Flow email account, see https://useapi.net/docs/start-here/setup-google-flow
If optional PROMPTS_FILE not provided prompts.json will be used.

Example:
--------

node google-flow-images.mjs user:1234-abcdefhijklmnopqrstuv [email protected]

This command executes the script using API token user:1234-abcdefhijklmnopqrstuv with [email protected] Google Flow account email.

Changelog:
==========

- June 15, 2026: Initial release.
- September 10, 2026: Default model is now nano-banana-2-lite (Google removed Imagen from Flow, and imagen-4 now maps to nano-banana-2-lite). Saves encodedImage when fifeUrl is absent, and accepts .jpg reference images.
- September 11, 2026: A prompt whose reference_* file fails to upload is skipped and logged to google-flow-images_errors.txt instead of being submitted without that reference. Writes a downloaded image only once it has been fully received, so a failed download leaves no partial file for the next run to skip as "already exists".

*/

import fs from 'fs/promises';
import { writeFile } from 'node:fs/promises';


// Constants
const ERRORS_FILE = 'google-flow-images_errors.txt';
const DEFAULT_PROMPTS_FILE = 'prompts.json';
const DEFAULT_MODEL = 'nano-banana-2-lite';
const SLEEP_429 = 30 * 1000; // in milliseconds

const urlAccounts = 'https://api.useapi.net/v1/google-flow/accounts';
const urlImages = 'https://api.useapi.net/v1/google-flow/images';
const urlUploadAsset = 'https://api.useapi.net/v1/google-flow/assets/';

// Google Flow accepts png, jpeg and webp for reference images.
const supportedFileExtensions = ['png', 'jpg', 'jpeg', 'webp'];

// reference_1 .. reference_10 are accepted by POST /images.
const referenceParams = Array.from({ length: 10 }, (_, i) => `reference_${i + 1}`);

// { filename: mediaGenerationId }
const uploadedFiles = {};

// Utility to sleep for given milliseconds
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Function to fetch configured Google Flow API accounts
async function fetchAccounts(apiToken) {
    const response = await fetch(urlAccounts, {
        headers: {
            'Accept': 'application/json',
            'Authorization': `Bearer ${apiToken}`
        }
    });

    if (!response.ok) {
        console.error(`⛔ Error fetching accounts (HTTP ${response.status}): ${response.statusText}`);
        process.exit(1);
    }

    return response.json();
}

const elapsedTimeSec = (start) => (Date.now() - start) / 1000;

// Map a file extension to the Content-Type required by POST /assets
const contentTypeForExt = (ext) => ext === 'png' ? 'image/png' : ext === 'webp' ? 'image/webp' : 'image/jpeg';

async function uploadAsset(apiToken, email, filename) {

    // Check if already uploaded
    if (uploadedFiles.hasOwnProperty(filename))
        return uploadedFiles[filename];

    const startTime = Date.now();

    console.log(`⬆️  Account ${email} uploading file…`, filename);

    const body = new Blob([await fs.readFile(filename)]);

    const fileExt = filename.split('.').pop().toLowerCase();

    const response = await fetch(`${urlUploadAsset}${encodeURIComponent(email)}`, {
        method: 'POST',
        headers: {
            'Accept': 'application/json',
            'Authorization': `Bearer ${apiToken}`,
            'Content-Type': contentTypeForExt(fileExt)
        },
        body
    });

    if (response.ok) {
        const json = await response.json();
        // POST /assets returns the reference id nested as mediaGenerationId.mediaGenerationId
        const mediaGenerationId = json?.mediaGenerationId?.mediaGenerationId;
        console.log(`🆗 mediaGenerationId (${elapsedTimeSec(startTime)} sec)`, mediaGenerationId);
        uploadedFiles[filename] = mediaGenerationId;
    }
    else {
        console.error(`❗ Unable to upload file HTTP ${response.status} (${elapsedTimeSec(startTime)} sec)`, await response.text());
        // Do not attempt to upload failed file again
        uploadedFiles[filename] = undefined;
    }

    return uploadedFiles[filename];
}

// Download a single image from its signed fifeUrl.
async function downloadImage(url, filename) {
    try {
        await fs.access(filename);
        console.log(`⚠️ ${filename} already exists. Skipping download.`);
        return;
    } catch {
        // File does not exist, proceed with downloading
    }

    if (!url) {
        console.error(`🛑 No fifeUrl for ${filename}`);
        return;
    }

    console.log(`✅ Downloading ${url} to ${filename}`);
    try {
        const imageResponse = await fetch(url);
        if (!imageResponse.ok) {
            console.error(`⛔ Unable to download ${filename} (HTTP ${imageResponse.status})`, url);
            return;
        }
        // Read the whole body before creating the file, so a failed download leaves no
        // partial file behind for the next run to skip as "already exists".
        const data = Buffer.from(await imageResponse.arrayBuffer());
        await writeFile(filename, data);
    } catch (err) {
        console.error(`⛔ Error during download: ${err}`);
    }
}

// Submit a single prompt to the synchronous POST /images endpoint and download the results.
async function submitImage(apiToken, email, prompt, index) {
    const { model, prompt: text } = prompt;

    const useModel = model ?? DEFAULT_MODEL;

    console.log(`🚀 ${useModel} » Prompt #${index} • account ${email} …`);

    // Build the request body, uploading any local reference_* file to a mediaGenerationId first.
    const body = { model: useModel, email, prompt: text };

    for (const key of ['aspectRatio', 'count', 'seed'])
        if (prompt[key] !== undefined) body[key] = prompt[key];

    for (const refKey of referenceParams) {
        const value = prompt[refKey];
        if (value)
            body[refKey] = await uploadAsset(apiToken, email, value);
    }

    // A reference that failed to upload would be left out of the body, and the prompt would still be
    // generated (and charged) without it. Skip the prompt instead. uploadAsset remembers the failed file,
    // so a later prompt using it is skipped too, without another upload attempt.
    const failedUploads = referenceParams.filter(refKey => prompt[refKey] && !body[refKey]);
    for (const refKey of failedUploads) {
        console.error(`🛑 Prompt #${index} skipped: ${refKey} ${prompt[refKey]} failed to upload`);
        await fs.appendFile(ERRORS_FILE, `Upload failed for ${refKey} ${prompt[refKey]},#${index}:${text}\n`);
    }
    if (failedUploads.length)
        return;

    while (true) {
        const response = await fetch(urlImages, {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${apiToken}`
            },
            body: JSON.stringify(body)
        });

        const responseText = await response.text();

        if (response.status == 200) {
            const json = JSON.parse(responseText);
            const media = json?.media ?? [];

            if (media.length == 0)
                console.error(`🛑 200 OK but no media for prompt #${index}:\n${text}\n`);

            // count > 1 returns multiple images in the media array.
            for (let i = 0; i < media.length; i++) {
                const img = media[i]?.image?.generatedImage;
                const filename = `google-flow_${index}_${i + 1}.jpg`;
                // fifeUrl is normally present. When it is absent the image arrived inline as base64 in encodedImage.
                if (!img?.fifeUrl && img?.encodedImage)
                    await fs.writeFile(filename, Buffer.from(img.encodedImage, 'base64'));
                else
                    await downloadImage(img?.fifeUrl, filename);
            }
            return 200;
        }

        switch (response.status) {
            case 429:
                console.log(`🔄️ Retry on HTTP ${response.status}`, responseText);
                await sleep(SLEEP_429);
                break;
            case 503:
                console.log(`🔄️ Service unavailable, retry on HTTP ${response.status}`, responseText);
                await sleep(SLEEP_429);
                break;
            case 402:
                console.log(`🛑 No subscription / insufficient credits`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                process.exit(1);
            case 400:
            case 500:
                console.log(`🛑 Rejected (validation or content moderation)`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                return response.status;
            default:
                console.log(`❗ FAILED with HTTP ${response.status}`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                return response.status;
        }
    }
}

// Main function
async function main() {
    const apiToken = process.argv[2];
    const email = process.argv[3];
    const promptFile = process.argv[4] || DEFAULT_PROMPTS_FILE;

    if (!apiToken || !email) {
        console.error('Usage: node google-flow-images.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]');
        process.exit(1);
    }

    console.info('Script v1.2');
    console.info('Node version is: ' + process.version);

    const start = new Date();
    try {
        console.info('START EXECUTION', start);
        await execute(apiToken, email, promptFile);
    } catch (error) {
        console.error('⛔ Error during execution:', error.stack || error);
    } finally {
        console.info('COMPLETED', new Date());
        console.info('EXECUTION ELAPSED', diffInMinutesAndSeconds(start, new Date()));
    }
}

async function execute(apiToken, email, promptFile) {
    const accounts = await fetchAccounts(apiToken);

    console.info(`Configured Google Flow API accounts (${Object.keys(accounts).length}):`, Object.keys(accounts).join(', '));

    if (Object.keys(accounts).length <= 0) {
        console.error(`⛔ No configured Google Flow accounts found. Please refer to https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    if (!accounts[email]) {
        console.error(`⛔ Account ${email} not found. Please refer to https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    if (accounts[email].health && accounts[email].health !== 'OK') {
        console.error(`⛔ Account ${email} health is '${accounts[email].health}'. Please resolve and update the account, see https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    const promptData = await fs.readFile(promptFile, 'utf8');
    const prompts = JSON.parse(promptData);
    console.log(`Total number of prompts to process`, prompts.length);

    let warnings = [];

    // Parameters accepted by this script for the POST /images endpoint.
    // See https://useapi.net/docs/api-google-flow-v1/post-google-flow-images for every model's full parameter set.
    const supportedParams = ['model', 'prompt', 'aspectRatio', 'count', 'seed', ...referenceParams];

    const invalidKeys = (prompt) => Object.keys(prompt).filter(key => !key.startsWith('__') && !supportedParams.includes(key))

    for (let i = 1; i <= prompts.length; i++) {
        const prompt = prompts[i - 1];
        const { prompt: text } = prompt;

        const validateImage = async (file) => {
            if (file) {
                try {
                    await fs.access(file);
                } catch {
                    warnings.push(`⚠️  Image '${file}' does not exist. Prompt ${i}`);
                }

                const ext = file.split('.').pop().toLowerCase();

                if (!supportedFileExtensions.includes(ext))
                    warnings.push(`⚠️  Image ${file} extension ${ext} not supported. Prompt ${i}`);
            }
        };

        const notSupported = invalidKeys(prompt);
        if (notSupported.length)
            warnings.push(`⚠️  Following params not supported: ${notSupported.join(',')}. Prompt ${i}`);

        if (!text)
            warnings.push(`⚠️  prompt is required. Prompt ${i}`);

        await Promise.all(referenceParams.map(refKey => validateImage(prompt[refKey])));
    }

    if (warnings.length > 0) {
        warnings.forEach(warning => console.warn(warning));
        console.error(`⛔ Execution stopped due to warnings.`);
        process.exit(1);
    }

    for (let i = 0; i < prompts.length; i++)
        await submitImage(apiToken, email, prompts[i], i + 1);
}

function diffInMinutesAndSeconds(date1, date2) {
    const diffInSeconds = Math.floor((date2 - date1) / 1000);
    return `${Math.floor(diffInSeconds / 60)} minutes ${diffInSeconds % 60} seconds`;
};

main();

Contoh

Gambar asli yang dibuat lewat Google Flow API yang sama dengan Nano Banana Pro dan Nano Banana 2 Lite, diambil langsung dari blog dan perbandingan model kami.

Nano Banana Pro — teks ke gambar (sumber): “Cat dressed like a pirate fencing with a real pirate… on a Disney cruise ship.”

Hasil teks ke gambar Nano Banana Pro

Nano Banana Pro — 5 gambar referensi (sumber): lima potret terpisah digabung menjadi satu foto grup “K-Pop group victory celebration”.

Foto grup Nano Banana Pro dari beberapa referensi

Nano Banana 2 Lite, model default (sumber): prompt peternak lebah dari perbandingan tiga model kami, dibuat dalam 9:16 oleh model tercepat di antara ketiganya.

Hasil peternak lebah Nano Banana 2 Lite lewat Google Flow API

Pertanyaan yang sering diajukan

  • Apakah ada API Nano Banana 2? Lewat useapi.net, ada: di Google Flow API, nano-banana-2 membuat gambar dengan Nano Banana 2.1, versi yang dipakai Google Flow, di langganan Google AI mana pun atau akun gratis, tanpa biaya per gambar. Nano Banana 2 (Gemini 3.1 Flash Image) berbiaya $0,067 per gambar 1K di Gemini API resmi Google (per November 2026). Ini endpoint REST standar, tanpa project Cloud.
  • Apakah ada API Nano Banana Pro? Lewat useapi.net, ada: Nano Banana Pro (Gemini 3 Pro Image) berjalan sebagai nano-banana-pro di endpoint POST /images, dan satu request sinkron mengembalikan hingga empat gambar tanpa biaya per gambar. Gemini API resmi Google menagih $0,134 untuk setiap gambar Pro (per November 2026).
  • Model apa yang dipakai API secara default? Di useapi.net, default-nya nano-banana-2-lite (Gemini 3.1 Flash-Lite Image), dengan atau tanpa referensi. Ganti per request dengan mengisi model menjadi nano-banana-2 (Nano Banana 2.1) atau nano-banana-pro (Gemini 3 Pro Image, kualitas tertinggi). Ketiganya menerima hingga 10 gambar referensi dan bisa di-upscale ke 2K/4K. Nano Banana 2 Lite vs 2.1 vs Pro menampilkan ketiganya pada satu prompt.
  • Apakah Imagen 4 masih ada di Google Flow? Di useapi.net, model id imagen-4 masih berfungsi, jadi kode yang sudah ada tetap jalan. Namun Google menghapus Imagen dari Google Flow pada Juli 2026, sehingga request itu sekarang membuat gambar dengan nano-banana-2-lite, model gambar default Google Flow sejak saat itu. Untuk memilih model lain, isi model dengan nano-banana-2 atau nano-banana-pro.
  • Apakah saya perlu captcha atau project Google Cloud? Lewat useapi.net Anda tidak perlu project Google Cloud maupun menyelesaikan captcha sendiri. Google Flow meminta reCAPTCHA untuk setiap gambar, dan worker useapi.net menyelesaikannya otomatis: akun Google Flow pertama Anda mendapat 300 penyelesaian gratis dengan key AntiCaptcha, CapSolver, dan EzCaptcha milik kami, lalu setelah itu Anda menambahkan key penyedia Anda sendiri dengan POST /accounts/captcha-providers. Skrip di panduan ini tidak mengirim captchaToken.

Kesimpulan

Kunjungi Server Discord atau Channel Telegram kami untuk pertanyaan dan masalah dukungan.

Lihat repo GitHub kami berisi contoh kode.

Dipublikasikan juga di

Juga dipublikasikan di dev.to (bahasa Inggris) dan dibagikan di Bluesky.

Mulai memakai API

Satu langganan US$15/bulan mencakup semua API di useapi.net: satu token untuk semua layanan. Di setiap layanan Anda bisa menghubungkan hingga 3 akun milik Anda sendiri, dan useapi.net menangani REST API, load balancing, dan polling. Butuh lebih banyak akun? Setiap langganan tambahan US$10/bulan dan menambah 3 akun lagi per layanan.

Berlangganan — US$15/bulan Bayar dengan kripto

Tidak punya kartu kredit internasional? Anda bisa berlangganan dengan kripto (pembayaran kripto tidak bisa di-refund). Harga dan paket volume ada di halaman langganan. Jika membayar lewat Stripe, Anda mendapat refund penuh dalam 14 hari sejak pembelian pertama, selama jumlah generasi yang berhasil kurang dari 50. Sudah berlangganan? Ubah jumlahnya di Stripe Customer Portal, tidak perlu membeli lagi.