> ## 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.1 Flash Image (Stream)

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

Gemini 3.1 Flash Image (Stream) generates images using Google's Gemini 3.1 Flash 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.1-flash-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.1-flash-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.1-flash-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.1-flash-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.1-flash-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.1-flash-image-stream">
  View the interactive API playground for Gemini 3.1 Flash Image (Stream).
</Card>

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