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

# Gemini 3 Pro Image (Stream)

> Google's Gemini 3 Pro Image (Stream) for image generation via Gemini API. Real-time SSE delivery of thinking and image chunks.

Gemini 3 Pro Image (Stream) generates images using Google's Gemini 3 Pro Image model through the native Gemini API via Anyfast. Responses are delivered in real-time using Server-Sent Events (SSE), with thinking chunks arriving first followed by the image data chunk.

<Warning>
  Streaming requires a **Direct** group token. Select the **Direct** group when creating your token in the Anyfast console.
</Warning>

## Key capabilities

* **SSE Streaming** — Real-time delivery of thinking and image chunks
* **Thinking mode** — Internal reasoning chunks (`thought: true`) stream before the final image
* **Text-to-image** — Generate images from text descriptions
* **Image editing** — Pass a reference image in `inline_data` alongside your text instruction
* **Aspect ratio control** — `1:1`, `4:3`, `3:4`, `16:9`, `9:16`
* **Resolution control** — `1K` (\~1024px), `2K` (\~2048px), `4K` (\~4096px) on the long edge

## SSE response format

The streaming endpoint returns newline-delimited SSE lines. Each line starts with `data:` followed by a JSON object. There are three chunk types:

1. **Thinking chunks** — Arrive first; `parts[0].thought` is `true`
2. **Image chunk** — Contains `parts[0].inlineData` with `mimeType` and base64 `data` (note: camelCase in stream response)
3. **Final usage chunk** — Contains top-level `usageMetadata` with `thoughtsTokenCount` and token details

```
data: {"candidates":[{"content":{"role":"model","parts":[{"text":"...","thought":true}]}}],"usageMetadata":{"trafficType":"ON_DEMAND"},"modelVersion":"gemini-3-pro-image","createTime":"...","responseId":"..."}

data: {"candidates":[{"content":{"role":"model","parts":[{"inlineData":{"mimeType":"image/png","data":"<base64>"}}]}}],...}

data: {"usageMetadata":{"promptTokenCount":8,"candidatesTokenCount":1120,"totalTokenCount":1392,"trafficType":"ON_DEMAND","promptTokensDetails":[{"modality":"TEXT","tokenCount":8}],"candidatesTokensDetails":[{"modality":"IMAGE","tokenCount":1120}],"thoughtsTokenCount":264}}
```

<Note>
  In the streaming response, the image field is named `inlineData` (camelCase). In the non-streaming request body, the field is `inline_data` (snake\_case). This is a native Gemini API behaviour.
</Note>

## Text-to-image example

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.anyfast.ai/v1beta/models/gemini-3-pro-image:streamGenerateContent?key=YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "contents": [
        {
          "role": "user",
          "parts": [
            { "text": "Generate an image of a sunset over mountains" }
          ]
        }
      ],
      "generationConfig": {
        "responseModalities": ["TEXT", "IMAGE"],
        "imageConfig": {
          "aspectRatio": "16:9",
          "imageSize": "1K"
        }
      }
    }'
  ```

  ```python Python theme={null}
  import requests, base64, json

  url = "https://www.anyfast.ai/v1beta/models/gemini-3-pro-image:streamGenerateContent"
  params = {"key": "YOUR_API_KEY"}
  data = {
      "contents": [
          {
              "role": "user",
              "parts": [{"text": "Generate an image of a sunset over mountains"}]
          }
      ],
      "generationConfig": {
          "responseModalities": ["TEXT", "IMAGE"],
          "imageConfig": {"aspectRatio": "16:9", "imageSize": "1K"}
      }
  }

  response = requests.post(url, params=params, json=data, stream=True)

  for line in response.iter_lines():
      if not line:
          continue
      decoded = line.decode("utf-8")
      if not decoded.startswith("data:"):
          continue
      chunk = json.loads(decoded[len("data:"):].strip())

      candidates = chunk.get("candidates", [])
      if not candidates:
          continue
      parts = candidates[0].get("content", {}).get("parts", [])
      for part in parts:
          # Skip thinking chunks
          if part.get("thought"):
              continue
          # Save image chunk
          if "inlineData" in part:
              img_bytes = base64.b64decode(part["inlineData"]["data"])
              with open("output.png", "wb") as f:
                  f.write(img_bytes)
              print("Image saved to output.png")
  ```
</CodeGroup>

## Image editing example (with reference image)

Include both a `text` instruction and an `inline_data` reference image in the same `parts` array.

<CodeGroup>
  ```bash cURL theme={null}
  # First encode your image to base64:
  # BASE64=$(base64 -i your_photo.jpg)
  #
  # Then send the request:
  curl "https://www.anyfast.ai/v1beta/models/gemini-3-pro-image:streamGenerateContent?key=YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "contents": [
        {
          "role": "user",
          "parts": [
            {
              "text": "Hi, this is a picture of me. Can you add a llama next to me?"
            },
            {
              "inline_data": {
                "mime_type": "image/jpeg",
                "data": "<YOUR_BASE64_ENCODED_IMAGE>"
              }
            }
          ]
        }
      ],
      "generationConfig": {
        "responseModalities": ["TEXT", "IMAGE"],
        "imageConfig": {
          "aspectRatio": "1:1",
          "imageSize": "1K"
        }
      }
    }'
  ```

  ```python Python theme={null}
  import requests, base64, json

  # Read and encode your reference image
  with open("your_photo.jpg", "rb") as f:
      image_b64 = base64.b64encode(f.read()).decode("utf-8")

  url = "https://www.anyfast.ai/v1beta/models/gemini-3-pro-image:streamGenerateContent"
  params = {"key": "YOUR_API_KEY"}
  data = {
      "contents": [
          {
              "role": "user",
              "parts": [
                  {
                      "text": "Hi, this is a picture of me. Can you add a llama next to me?"
                  },
                  {
                      "inline_data": {
                          "mime_type": "image/jpeg",
                          "data": image_b64
                      }
                  }
              ]
          }
      ],
      "generationConfig": {
          "responseModalities": ["TEXT", "IMAGE"],
          "imageConfig": {"aspectRatio": "1:1", "imageSize": "1K"}
      }
  }

  response = requests.post(url, params=params, json=data, stream=True)

  for line in response.iter_lines():
      if not line:
          continue
      decoded = line.decode("utf-8")
      if not decoded.startswith("data:"):
          continue
      chunk = json.loads(decoded[len("data:"):].strip())

      candidates = chunk.get("candidates", [])
      if not candidates:
          continue
      parts = candidates[0].get("content", {}).get("parts", [])
      for part in parts:
          if part.get("thought"):
              continue
          if "inlineData" in part:
              img_bytes = base64.b64decode(part["inlineData"]["data"])
              with open("output.png", "wb") as f:
                  f.write(img_bytes)
              print("Image saved to output.png")
  ```
</CodeGroup>

## Parameters

| Parameter                                  | Type   | Required | Description                                                         |
| ------------------------------------------ | ------ | -------- | ------------------------------------------------------------------- |
| `key`                                      | string | Yes      | API key (query parameter)                                           |
| `alt`                                      | string | No       | Set to `sse` for explicit SSE mode (optional, streaming is default) |
| `contents[].parts[].text`                  | string | Yes      | Text prompt or instruction                                          |
| `contents[].parts[].inline_data.mime_type` | string | No       | Reference image type: `image/jpeg`, `image/png`, `image/webp`       |
| `contents[].parts[].inline_data.data`      | string | No       | Base64-encoded reference image                                      |
| `generationConfig.responseModalities`      | array  | Yes      | `["IMAGE"]` or `["TEXT", "IMAGE"]`                                  |
| `generationConfig.imageConfig.aspectRatio` | string | No       | `1:1` / `4:3` / `3:4` / `16:9` / `9:16`                             |
| `generationConfig.imageConfig.imageSize`   | string | No       | `1K` / `2K` / `4K` (default: `1K`)                                  |

<Card title="API Reference" icon="code" href="/api-reference/model-api/google/gemini-3-pro-image-stream">
  View the interactive API playground for Gemini 3 Pro Image (Stream).
</Card>

<script src="/feedback.js" />