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

# Stream Generate Content

> Streams content generation using Google Gemini API format

Streaming version of the Gemini generateContent endpoint. Returns Server-Sent Events.

## Path Parameters

<ParamField path="model" type="string" required>
  Model name (e.g., `gemini-2.5-pro`, `gemini-3.5-flash`).
</ParamField>

## Query Parameters

<ParamField query="key" type="string">
  API key (alternative to header authentication).
</ParamField>

## Request Body

Same as [Generate Content](/api-reference/gemini/generate-content). This includes multimodal `parts` arrays with structured `inline_data` image parts for vision requests.

For streaming requests, omit `generationConfig.candidateCount` or keep it at `1`; requests with a larger value are rejected instead of silently dropping extra candidates.

## Response

Returns a stream of JSON objects, each containing a partial response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:streamGenerateContent?key=sk-your-api-key" \
    -H "Content-Type: application/json" \
    -d '{
      "contents": [
        {
          "parts": [{"text": "Tell me a story"}]
        }
      ]
    }'
  ```

  ```python Python theme={null}
  import google.generativeai as genai

  genai.configure(
      api_key="sk-your-api-key",
      transport="rest",
      client_options={"api_endpoint": "api.tokenlab.sh"}
  )

  model = genai.GenerativeModel("gemini-2.5-pro")
  response = model.generate_content("Tell me a story", stream=True)

  for chunk in response:
      print(chunk.text, end="")
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    'https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:streamGenerateContent?key=sk-your-api-key',
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        contents: [{ parts: [{ text: 'Tell me a story' }] }]
      })
    }
  );

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    console.log(decoder.decode(value));
  }
  ```

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

  import (
      "bufio"
      "bytes"
      "encoding/json"
      "fmt"
      "net/http"
  )

  func main() {
      payload := map[string]interface{}{
          "contents": []map[string]interface{}{
              {"parts": []map[string]string{{"text": "Tell me a story"}}},
          },
      }

      jsonData, _ := json.Marshal(payload)
      req, _ := http.NewRequest("POST",
          "https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:streamGenerateContent?key=sk-your-api-key",
          bytes.NewBuffer(jsonData))
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()

      scanner := bufio.NewScanner(resp.Body)
      for scanner.Scan() {
          fmt.Println(scanner.Text())
      }
  }
  ```

  ```php PHP theme={null}
  <?php
  $payload = [
      'contents' => [
          ['parts' => [['text' => 'Tell me a story']]]
      ]
  ];

  $ch = curl_init('https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:streamGenerateContent?key=sk-your-api-key');

  curl_setopt_array($ch, [
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_POST => true,
      CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
      CURLOPT_POSTFIELDS => json_encode($payload),
      CURLOPT_WRITEFUNCTION => function($ch, $data) {
          echo $data;
          return strlen($data);
      }
  ]);

  curl_exec($ch);
  curl_close($ch);
  ```

  ## Vision Input Example

  Streaming vision requests use the same `contents[].parts[]` structure as the non-streaming endpoint.

  ```json theme={null}
  {
    "contents": [
      {
        "role": "user",
        "parts": [
          { "text": "Please describe this image." },
          {
            "inline_data": {
              "mime_type": "image/jpeg",
              "data": "/9j/4AAQSkZJRgABAQ..."
            }
          }
        ]
      }
    ]
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Stream Chunk theme={null}
  {
    "candidates": [
      {
        "content": {
          "role": "model",
          "parts": [
            {"text": "Once upon a time"}
          ]
        }
      }
    ]
  }
  ```
</ResponseExample>