> ## Documentation Index
> Fetch the complete documentation index at: https://gccai.heqingsong.uk/llms.txt
> Use this file to discover all available pages before exploring further.

# Nano Banana Lite Génération d'images

>  - Le modèle d'image le plus rapide et le moins cher de la série Gemini 3.1, conçu pour la génération d'images à grande échelle et à faible coût
- Prend en charge uniquement la résolution 1K (les valeurs 2K/4K/0.5K sont automatiquement rétrogradées en 1K, sans erreur)
- Prend en charge la génération texte-vers-image et image-vers-image, jusqu'à 14 images de référence
- Facturation basée sur les tokens d'entrée / de sortie ; connexion directe au canal officiel Gemini, génération d'images via tâches asynchrones 

> [!NOTE]
>
> **Compatibilité des noms de modèle** : `gemini-3.1-flash-lite-image` accepte l'alias `nano-banana-2-lite`, et `gemini-3.1-flash-lite-image-ext` accepte l'alias `nano-banana-2-lite-ext` ; chaque nom et son alias sont équivalents et interchangeables.

```bash cURL theme={null}
# model peut valoir "gemini-3.1-flash-lite-image", l'alias "nano-banana-2-lite" est également accepté
curl --request POST \
  --url https://gccai.heqingsong.uk/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gemini-3.1-flash-lite-image",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯闪烁",
    "size": "16:9",
    "resolution": "1K",
    "n": 1
  }'
```

```python Python theme={null}
import requests

url = "https://gccai.heqingsong.uk/v1/images/generations"

payload = {
    "model": "gemini-3.1-flash-lite-image",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯闪烁",
    "size": "16:9",
    "resolution": "1K",
    "n": 1
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript JavaScript theme={null}
const url = "https://gccai.heqingsong.uk/v1/images/generations";

const payload = {
  model: "gemini-3.1-flash-lite-image",
  prompt: "赛博朋克风格的城市夜景，霓虹灯闪烁",
  size: "16:9",
  resolution: "1K",
  n: 1
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
```

```go Go theme={null}
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://gccai.heqingsong.uk/v1/images/generations"

    payload := map[string]interface{}{
        "model":      "gemini-3.1-flash-lite-image",
        "prompt":     "赛博朋克风格的城市夜景，霓虹灯闪烁",
        "size":       "16:9",
        "resolution": "1K",
        "n":          1,
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

```java Java theme={null}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://gccai.heqingsong.uk/v1/images/generations";

        String payload = """
        {
          "model": "gemini-3.1-flash-lite-image",
          "prompt": "赛博朋克风格的城市夜景，霓虹灯闪烁",
          "size": "16:9",
          "resolution": "1K",
          "n": 1
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}
```

```php PHP theme={null}
<?php

$url = "https://gccai.heqingsong.uk/v1/images/generations";

$payload = [
    "model" => "gemini-3.1-flash-lite-image",
    "prompt" => "赛博朋克风格的城市夜景，霓虹灯闪烁",
    "size" => "16:9",
    "resolution" => "1K",
    "n" => 1
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

```ruby Ruby theme={null}
require 'net/http'
require 'json'
require 'uri'

url = URI("https://gccai.heqingsong.uk/v1/images/generations")

payload = {
  model: "gemini-3.1-flash-lite-image",
  prompt: "赛博朋克风格的城市夜景，霓虹灯闪烁",
  size: "16:9",
  resolution: "1K",
  n: 1
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body
```

```swift Swift theme={null}
import Foundation

let url = URL(string: "https://gccai.heqingsong.uk/v1/images/generations")!

let payload: [String: Any] = [
    "model": "gemini-3.1-flash-lite-image",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯闪烁",
    "size": "16:9",
    "resolution": "1K",
    "n": 1
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()
```

```csharp C# theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://gccai.heqingsong.uk/v1/images/generations";

        var payload = @"{
            ""model"": ""gemini-3.1-flash-lite-image"",
            ""prompt"": ""赛博朋克风格的城市夜景，霓虹灯闪烁"",
            ""size"": ""16:9"",
            ""resolution"": ""1K"",
            ""n"": 1
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}
```

```c C theme={null}
#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://gccai.heqingsong.uk/v1/images/generations";
        const char *payload = "{"
            "\"model\":\"gemini-3.1-flash-lite-image\","
            "\"prompt\":\"赛博朋克风格的城市夜景，霓虹灯闪烁\","
            "\"size\":\"16:9\","
            "\"resolution\":\"1K\","
            "\"n\":1"
        "}";

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Authorization: Bearer <token>");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}
```

```objectivec Objective-C theme={null}
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://gccai.heqingsong.uk/v1/images/generations"];

        NSDictionary *payload = @{
            @"model": @"gemini-3.1-flash-lite-image",
            @"prompt": @"赛博朋克风格的城市夜景，霓虹灯闪烁",
            @"size": @"16:9",
            @"resolution": @"1K",
            @"n": @1
        };

        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];

        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];

        NSURLSessionDataTask *task = [[NSURLSession sharedSession]
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];

        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}
```

```ocaml OCaml theme={null}
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://gccai.heqingsong.uk/v1/images/generations"

let payload = {|{
  "model": "gemini-3.1-flash-lite-image",
  "prompt": "赛博朋克风格的城市夜景，霓虹灯闪烁",
  "size": "16:9",
  "resolution": "1K",
  "n": 1
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "Authorization" "Bearer <token>"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in

  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response
```

```dart Dart theme={null}
import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://gccai.heqingsong.uk/v1/images/generations');

  final payload = {
    'model': 'gemini-3.1-flash-lite-image',
    'prompt': '赛博朋克风格的城市夜景，霓虹灯闪烁',
    'size': '16:9',
    'resolution': '1K',
    'n': 1
  };

  final response = await http.post(
    url,
    headers: {
      'Authorization': 'Bearer <token>',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );

  print(response.body);
}
```

```r R theme={null}
library(httr)
library(jsonlite)

url <- "https://gccai.heqingsong.uk/v1/images/generations"

payload <- list(
  model = "gemini-3.1-flash-lite-image",
  prompt = "赛博朋克风格的城市夜景，霓虹灯闪烁",
  size = "16:9",
  resolution = "1K",
  n = 1
)

response <- POST(
  url,
  add_headers(
    Authorization = "Bearer <token>",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))
```

```json 200 theme={null}
{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
    }
  ]
}
```

```json 400 theme={null}
{
  "error": {
    "code": 400,
    "message": "请求参数无效",
    "type": "invalid_request_error"
  }
}
```

```json 401 theme={null}
{
  "error": {
    "code": 401,
    "message": "身份验证失败，请检查您的API密钥",
    "type": "authentication_error"
  }
}
```

```json 402 theme={null}
{
  "error": {
    "code": 402,
    "message": "账户余额不足，请充值后再试",
    "type": "payment_required"
  }
}
```

```json 403 theme={null}
{
  "error": {
    "code": 403,
    "message": "访问被禁止，您没有权限访问此资源",
    "type": "permission_error"
  }
}
```

```json 429 theme={null}
{
  "error": {
    "code": 429,
    "message": "请求过于频繁，请稍后再试",
    "type": "rate_limit_error"
  }
}
```

```json 500 theme={null}
{
  "error": {
    "code": 500,
    "message": "服务器内部错误，请稍后重试",
    "type": "server_error"
  }
}
```

```json 502 theme={null}
{
  "error": {
    "code": 502,
    "message": "网关错误，服务器暂时不可用",
    "type": "bad_gateway"
  }
}
```

## Autorisations

**Authorization** `string` *required*

Tous les points de terminaison de l'API nécessitent une authentification Bearer Token

Obtenir votre clé API :

Rendez-vous sur la [page de gestion des clés API](https://gccai.heqingsong.uk/keys) pour obtenir votre clé API

Ajoutez-la à l'en-tête de la requête :

```
Authorization: Bearer YOUR_API_KEY
```

## Body

**model** `string` *required* (default: gemini-3.1-flash-lite-image)

Nom du modèle de génération d'images

Les noms de modèle suivants sont pris en charge :

* `gemini-3.1-flash-lite-image` (Nano Banana Lite, alias compatible `nano-banana-2-lite`)
* `gemini-3.1-flash-lite-image-ext` (alias compatible `nano-banana-2-lite-ext`)

> [!NOTE]
>
> Les deux ont les mêmes paramètres et contraintes (uniquement 1K, `google_search` / `official_fallback` non pris en charge, jusqu'à 14 images de référence). Aucun des deux n'a de variante `-official` ni ne prend en charge le paramètre de repli `official_fallback`. La facturation dépend de la configuration back-office de chaque canal respectif.
>
> Les alias `nano-banana-2-lite` (correspondant à `gemini-3.1-flash-lite-image`) et `nano-banana-2-lite-ext` (correspondant à `gemini-3.1-flash-lite-image-ext`) sont équivalents à leurs noms d'origine respectifs et interchangeables.

**nsfw\_check** `boolean` (default: false)

Indique s'il faut modérer le contenu avant d'envoyer la tâche d'image.

* `true` : vérifier les prompts et les images d'entrée avec `omni-moderation-latest`
* `false` ou omis : ne pas envoyer de requête de modération, sans coût ni latence de modération supplémentaires (par défaut)

**prompt** `string` *required*

Description textuelle pour la génération d'images

**size** `string`

Ratio d'aspect de l'image

Ratios pris en charge :

* `auto` — Choix automatique du ratio d'aspect
* `1:1` — Carré, avatars, réseaux sociaux
* `3:2` / `2:3` — Photos standard
* `4:3` / `3:4` — Ratio d'affichage traditionnel
* `16:9` / `9:16` — Écran large / couvertures vidéo verticales
* `5:4` / `4:5` — Images Instagram
* `21:9` — Bannière ultra-large

> [!WARNING]
>
> Pour la génération texte-vers-image, lorsque `size` vaut `auto`, la valeur par défaut est `1:1` ou `16:9` ; pour la génération image-vers-image, le ratio d'aspect suit la réponse de la source en amont. Nous vous recommandons de spécifier explicitement un ratio d'aspect.

**resolution** `string` (default: 1K)

Résolution de l'image de sortie

Valeurs prises en charge :

* `1K` — \~1024px, résolution standard (**Lite ne prend en charge que ce niveau**)

> [!WARNING]
>
> **Lite ne prend en charge que la 1K**. Les valeurs `2K` / `4K` / `0.5K` sont **silencieusement rétrogradées en 1K**, sans erreur et sans réellement produire une haute résolution. L'interface utilisateur front-end n'a pas besoin d'exposer d'option de résolution.

**n** `integer` (default: 1)

Nombre d'images à générer

Plage : 1 \~ 4, par défaut `1`

Lorsque `n>1`, le back-end envoie plusieurs requêtes simultanées à la source en amont et facture selon le **nombre réel d'images générées avec succès**. **Il est recommandé que le front-end envoie toujours 1** (affichage de la progression image par image, facturation plus intuitive).

**⚠️ Note :** Doit être un nombre brut (par exemple `1`), sans guillemets, sinon une erreur sera renvoyée

**image\_urls** `array`

Liste des URL d'images de référence pour la génération image-vers-image

Deux formats sont pris en charge :

**1. URL d'image complète**

* URL d'image accessible publiquement (http\:// ou https\://)
* Exemple : `https://example.com/image.jpg`

**2. Format encodé en Base64**

* **Le format Data URI complet doit être utilisé**
* Format : `data:image/{format};base64,{base64data}`
* Formats d'image pris en charge : jpeg, png, webp
* Exemple : `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`
* ⚠️ Note : Le préfixe `data:image/jpeg;base64,` doit être inclus

**Limitations :**

* Maximum **14** images de référence (recommandé : jusqu'à 10 références d'objets + 4 références de personnages)
* Taille d'une image : ne dépassant pas 10 Mo
* Formats pris en charge : jpeg, png, webp

**webhook** `string`

Adresse de rappel de la tâche (base)

En cas de succès / échec de la tâche, la plateforme appelle `webhook + /callback` (sans transmettre à la source en amont). Fournir ce paramètre réduit considérablement le polling ; il reste toutefois recommandé de conserver le polling comme solution de repli.

> [!NOTE]
>
> **Points clés d'utilisation de Lite**
>
> * **Ne prend pas en charge `google_search` / `google_image_search`** : Lite utilise le point de terminaison `interactions` de la Developer API, la source en amont n'a pas activé l'outil Search (renvoie "Search as tool is not enabled for this model"), et l'adaptateur de la plateforme ne transmet pas ce paramètre. **Le fournir ne provoque pas d'erreur et l'image est générée normalement, mais sans aucun effet d'amélioration par la recherche**. Pour une amélioration par la recherche, utilisez plutôt `gemini-3.1-flash-image-preview`.
> * Ne prend pas en charge la retouche locale via `mask_url` (la série Gemini utilise le ratio d'aspect + images de référence, et non les masques).
> * **Facturation basée sur les tokens** (à la différence du prix fixe par image de flash/pro) : entrée environ 0,25 $/million de tokens, sortie d'image environ 30 $/million de tokens, une image 1K ≈ 1120 tokens de sortie ≈ **0,0336 \$/image**. Le prix réel dépend de la configuration du multiplicateur dans le back-office.
> * Toutes les images générées contiennent le filigrane invisible **SynthID** de Google (comportement en amont, impossible à désactiver).

## Response

**code** `integer`

Code de statut de la réponse

**data** `array`

Tableau de données de réponse

**Propriétés**

**status** `string`

Statut de la tâche

* `submitted` — Soumise

**task\_id** `string`

Identifiant unique de la tâche


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.