> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Usar modelos de imagem Gemini
> Chame modelos de imagem Gemini (Nano Banana 2 / Pro) no CometAPI usando o Google Gen AI SDK para geração de texto para imagem, imagem para imagem e composição com múltiplas imagens.
Este guia demonstra como usar modelos de imagem Gemini via CometAPI com o **Google Gen AI SDK**. Ele aborda:
* Geração de texto para imagem
* Edição de imagem para imagem
* Composição com múltiplas imagens
* Como salvar imagens geradas
- **Base URL:** `https://api.cometapi.com`
- Instale o SDK: `pip install google-genai` (Python) ou `npm install @google/genai` (Node.js)
***
## Configuração
Inicialize o cliente com a base URL do CometAPI:
```python Python theme={null}
from google import genai
from google.genai import types
import os
COMETAPI_KEY = os.environ["COMETAPI_KEY"]
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=COMETAPI_KEY,
)
```
```javascript Node.js theme={null}
import { GoogleGenAI } from "@google/genai";
const COMETAPI_KEY = process.env.COMETAPI_KEY;
const ai = new GoogleGenAI({
apiKey: COMETAPI_KEY,
httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});
```
```go Go theme={null}
package main
import (
"context"
"os"
"google.golang.org/genai"
)
func main() {
ctx := context.Background()
apiKey := os.Getenv("COMETAPI_KEY")
client, _ := genai.NewClient(ctx, &genai.ClientConfig{
APIKey: apiKey,
Backend: genai.BackendGeminiAPI,
HTTPOptions: genai.HTTPOptions{
BaseURL: "https://api.cometapi.com",
},
})
// use client below...
}
```
***
## Geração de imagem a partir de texto
Gere uma imagem a partir de um prompt de texto e salve-a em um arquivo.
```python Python theme={null}
from google import genai
from google.genai import types
from PIL import Image
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
response = client.models.generate_content(
model="gemini-3.1-flash-image-preview",
contents="Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
),
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.text is not None:
print(part.text)
elif part.inline_data is not None:
final_image = part.as_image()
if final_image:
final_image.save("generated_image.png")
print("Image saved to generated_image.png")
```
```javascript Node.js theme={null}
import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";
const ai = new GoogleGenAI({
apiKey: process.env.COMETAPI_KEY,
httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});
const response = await ai.models.generateContent({
model: "gemini-3.1-flash-image-preview",
contents: "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
config: { responseModalities: ["TEXT", "IMAGE"] },
});
let finalImagePart;
for (const part of response.candidates[0].content.parts) {
if (part.thought === true) {
continue;
}
if (part.text) {
console.log(part.text);
}
if (part.inlineData) {
finalImagePart = part;
}
}
if (finalImagePart) {
const buffer = Buffer.from(finalImagePart.inlineData.data, "base64");
fs.writeFileSync("generated_image.png", buffer);
console.log("Image saved to generated_image.png");
}
```
```bash Shell theme={null}
curl -s -X POST \
"https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"parts": [{"text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"}]
}],
"generationConfig": {
"responseModalities": ["TEXT", "IMAGE"]
}
}'
```
**Salve a parte final da imagem:**
Os dados da imagem estão em `candidates[0].content.parts`, que podem conter partes de texto e/ou de imagem. Os modelos de imagem Gemini também podem retornar partes de pensamento intermediárias antes da imagem final, especialmente quando você solicita texto e imagens ao mesmo tempo ou habilita explicitamente a saída de thinking. Não salve a primeira `inlineData` cegamente; ignore as partes em que `thought` for `true` e então salve a última parte de imagem restante.
Resposta típica contendo apenas a imagem final:
```json theme={null}
{
"candidates": [{
"content": {
"parts": [
{ "text": "Here is your image..." },
{
"inlineData": {
"mimeType": "image/png",
"data": ""
}
}
]
}
}]
}
```
Resposta com uma parte de texto, uma imagem de pensamento intermediária e a imagem final:
```json theme={null}
{
"candidates": [{
"content": {
"role": "model",
"parts": [
{ "text": "Here is your image..." },
{
"inlineData": {
"mimeType": "image/jpeg",
"data": ""
},
"thought": true
},
{
"inlineData": {
"mimeType": "image/jpeg",
"data": ""
},
"thought": false,
"thoughtSignature": ""
}
]
},
"finishReason": "STOP"
}]
}
```
Use esta regra de parsing para toda resposta de imagem do Gemini:
```javascript theme={null}
const imageParts = response.candidates[0].content.parts.filter(
(part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);
```
***
## Geração de imagem para imagem
Envie uma imagem de entrada e transforme-a com um prompt de texto.
```python Python theme={null}
from google import genai
from google.genai import types
from PIL import Image
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
# Load the source image
source_image = Image.open("source.jpg")
response = client.models.generate_content(
model="gemini-3.1-flash-image-preview",
contents=["Transform this into a watercolor painting", source_image],
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
),
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.text is not None:
print(part.text)
elif part.inline_data is not None:
final_image = part.as_image()
if final_image:
final_image.save("watercolor_output.png")
```
```javascript Node.js theme={null}
import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";
const ai = new GoogleGenAI({
apiKey: process.env.COMETAPI_KEY,
httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});
const imageData = fs.readFileSync("source.jpg").toString("base64");
const response = await ai.models.generateContent({
model: "gemini-3.1-flash-image-preview",
contents: [
{ text: "Transform this into a watercolor painting" },
{ inlineData: { mimeType: "image/jpeg", data: imageData } },
],
config: { responseModalities: ["TEXT", "IMAGE"] },
});
const imageParts = response.candidates[0].content.parts.filter(
(part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);
if (finalImagePart) {
fs.writeFileSync("watercolor_output.png", Buffer.from(finalImagePart.inlineData.data, "base64"));
}
```
```bash Shell theme={null}
curl -s -X POST \
"https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"role": "user",
"parts": [
{ "text": "Transform this into a watercolor painting" },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } }
]
}],
"generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
}'
```
* O SDK de Python aceita objetos `PIL.Image` diretamente — não é necessária codificação manual em Base64.
* **Não** inclua o prefixo `data:image/jpeg;base64,` ao passar strings Base64 brutas.
***
## Composição com múltiplas imagens
Gere uma nova imagem a partir de várias imagens de entrada. O CometAPI oferece suporte a duas abordagens:
### Método 1: Uma única imagem de colagem
Combine várias imagens de origem em uma única colagem e, em seguida, descreva a saída desejada.
```python Python theme={null}
from google import genai
from google.genai import types
from PIL import Image
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
collage = Image.open("collage.jpg")
response = client.models.generate_content(
model="gemini-3.1-flash-image-preview",
contents=[
"A model is posing and leaning against a pink BMW with a green alien keychain attached to a pink handbag, a pink parrot on her shoulder, and a pug wearing a pink collar and gold headphones",
collage,
],
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
),
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.inline_data is not None:
final_image = part.as_image()
if final_image:
final_image.save("composition_output.png")
```
```bash Shell theme={null}
curl -s -X POST \
"https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"role": "user",
"parts": [
{ "text": "A model is posing and leaning against a pink BMW with a green alien keychain attached to a pink handbag, a pink parrot on her shoulder, and a pug wearing a pink collar and gold headphones" },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } }
]
}],
"generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
}'
```
### Método 2: Várias imagens separadas (até 14)
Passe várias imagens diretamente. Os modelos Gemini 3 oferecem suporte a até 14 imagens de referência (objetos + personagens):
```python Python theme={null}
from google import genai
from google.genai import types
from PIL import Image
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
image1 = Image.open("image1.jpg")
image2 = Image.open("image2.jpg")
image3 = Image.open("image3.jpg")
response = client.models.generate_content(
model="gemini-3.1-flash-image-preview",
contents=["Merge the three images", image1, image2, image3],
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
),
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.inline_data is not None:
final_image = part.as_image()
if final_image:
final_image.save("merged_output.png")
```
```bash Shell theme={null}
curl -s -X POST \
"https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"role": "user",
"parts": [
{ "text": "Merge the three images" },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } }
]
}],
"generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
}'
```
***
## Geração de imagens em 4K
Especifique `image_config` com `aspect_ratio` e `image_size` para saída em alta resolução:
```python Python theme={null}
from google import genai
from google.genai import types
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
response = client.models.generate_content(
model="gemini-3.1-flash-image-preview",
contents="Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment",
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
image_config=types.ImageConfig(
aspect_ratio="1:1",
image_size="4K",
),
),
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.text is not None:
print(part.text)
elif image := part.as_image():
final_image = image
if final_image:
final_image.save("butterfly_4k.png")
```
```javascript Node.js theme={null}
import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";
const ai = new GoogleGenAI({
apiKey: process.env.COMETAPI_KEY,
httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});
const response = await ai.models.generateContent({
model: "gemini-3.1-flash-image-preview",
contents: "Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment",
config: {
responseModalities: ["TEXT", "IMAGE"],
imageConfig: { aspectRatio: "1:1", imageSize: "4K" },
},
});
const imageParts = response.candidates[0].content.parts.filter(
(part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);
if (finalImagePart) {
fs.writeFileSync("butterfly_4k.png", Buffer.from(finalImagePart.inlineData.data, "base64"));
}
```
```bash Shell theme={null}
curl -s -X POST \
"https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{"parts": [{"text": "Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment"}]}],
"generationConfig": {
"responseModalities": ["TEXT", "IMAGE"],
"imageConfig": {"aspectRatio": "1:1", "imageSize": "4K"}
}
}'
```
Para solicitações em alta resolução, avalie a saída pela parte final da imagem que não seja de pensamento. Se a sua integração salvar a primeira parte `inlineData`, ela poderá salvar uma imagem de pensamento intermediária com resolução mais baixa do que o `imageSize` solicitado.
***
## Edição de imagem em múltiplos turnos (chat)
Use o recurso de chat do SDK para refinar imagens de forma iterativa:
```python Python theme={null}
from google import genai
from google.genai import types
import os
client = genai.Client(
http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
api_key=os.environ.get("COMETAPI_KEY"),
)
chat = client.chats.create(
model="gemini-3.1-flash-image-preview",
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"],
),
)
## First turn: Generate
response = chat.send_message(
"Create a vibrant infographic explaining photosynthesis as a recipe, styled like a colorful kids cookbook"
)
final_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.text is not None:
print(part.text)
elif image := part.as_image():
final_image = image
if final_image:
final_image.save("photosynthesis.png")
```
## Segunda etapa: Refine
response = chat.send\_message("Atualize este infográfico para ficar em espanhol. Não altere nenhum outro elemento.")
final\_image = None
for part in response.parts:
if getattr(part, "thought", False):
continue
if part.text is not None:
print(part.text)
elif image := part.as\_image():
final\_image = image
if final\_image:
final\_image.save("photosynthesis\_spanish.png")
````
```javascript Node.js
import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";
const ai = new GoogleGenAI({
apiKey: process.env.COMETAPI_KEY,
httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});
const chat = ai.chats.create({
model: "gemini-3.1-flash-image-preview",
config: { responseModalities: ["TEXT", "IMAGE"] },
});
// First turn: generate
const response1 = await chat.sendMessage(
"Create a vibrant infographic explaining photosynthesis as a recipe, styled like a colorful kids cookbook"
);
const imageParts1 = response1.candidates[0].content.parts.filter(
(part) => part.inlineData && part.thought !== true,
);
const finalImagePart1 = imageParts1.at(-1);
if (finalImagePart1) {
fs.writeFileSync("photosynthesis.png", Buffer.from(finalImagePart1.inlineData.data, "base64"));
}
// Second turn: refine
const response2 = await chat.sendMessage(
"Update this infographic to be in Spanish. Do not change any other elements."
);
const imageParts2 = response2.candidates[0].content.parts.filter(
(part) => part.inlineData && part.thought !== true,
);
const finalImagePart2 = imageParts2.at(-1);
if (finalImagePart2) {
fs.writeFileSync("photosynthesis_spanish.png", Buffer.from(finalImagePart2.inlineData.data, "base64"));
}
````
***
## Dicas
Especifique palavras-chave de estilo (por exemplo, "cyberpunk, granulação de filme, baixo contraste"), proporção, assunto, plano de fundo, iluminação e nível de detalhe.
Ao usar HTTP bruto, não inclua o prefixo `data:image/png;base64,` — use apenas a string Base64 bruta. O SDK Python lida com isso automaticamente com objetos `PIL.Image`.
Defina `"responseModalities"` como apenas `["IMAGE"]` para garantir saída de imagem sem texto.
Verifique se seu código salvou uma imagem intermediária de thought. As respostas de imagem do Gemini podem incluir partes de imagem em que `thought` é `true`; essas não são a saída final. Ignore as partes com `thought: true` e salve a última parte de imagem em que `inlineData` existe e `thought` não é `true`. Se você não precisar de saída de texto, solicite `"responseModalities": ["IMAGE"]` para reduzir o tratamento de respostas mistas de texto/imagem.
Para mais detalhes, consulte a [Referência da API](/api/image/gemini/gemini-generates-image).
**Documentação oficial:** [Geração de imagens Nano Banana](https://ai.google.dev/gemini-api/docs/image-generation)
* [Compreensão de imagens Gemini](https://ai.google.dev/gemini-api/docs/image-understanding)