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

# Streaming

> Receive generated text incrementally from the Responses API.

## Stream text as it is generated

Set `stream` to `true` to receive server-sent events instead of waiting for the full response.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  import { SDK } from '@meetkai/mka1';
  import { CreateAcceptEnum } from '@meetkai/mka1/sdk/responses';

  const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: 'Write three release notes bullets for our docs update.',
      stream: true,
    },
  }, { acceptHeaderOverride: CreateAcceptEnum.textEventStream });
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai';

  const openai = new OpenAI({
    apiKey: '<mka1-api-key>',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
    defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  const stream = await openai.responses.create({
    model: 'auto',
    input: 'Write three release notes bullets for our docs update.',
    stream: true,
  });

  for await (const event of stream) {
    if (event.type === 'response.output_text.delta') {
      process.stdout.write(event.delta);
    }
  }
  ```

  ```python Python SDK theme={null}
  from meetkai_mka1 import SDK

  sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

  stream = sdk.llm.responses.create(
      model="auto",
      input="Write three release notes bullets for our docs update.",
      stream=True,
  )

  for event in stream:
      if event.data.type == "response.output_text.delta":
          print(event.data.delta, end="", flush=True)
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Write three release notes bullets for our docs update."),
      Stream = true,
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create \
    --model auto \
    --input '"Write three release notes bullets for our docs update."' \
    --stream
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": "Write three release notes bullets for our docs update.",
      "stream": true
    }'
  ```
</CodeGroup>

Use streaming when you want to render partial output as it arrives.

## Long-running requests

Use [background responses](/docs/background-responses) when work must continue after the initial request returns.