> ## 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.

# Text to speech

> Synthesize speech or stream audio as it is generated.

This standalone API speaks text supplied by your application. For speech generated as part of a model reply, see [Audio responses](/docs/audio-responses).

## Generate speech

Use the standard text-to-speech endpoint when you want a complete WAV file.
The response body is binary audio, and the response headers include `X-Language-Code`.

To save the generated audio to history, set `store=true`. When stored, the response also includes `X-Tts-Id`, and persistence completes before the response returns.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  import { SDK } from '@meetkai/mka1';
  import { writeFileSync } from 'node:fs';

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

  const result = await sdk.llm.speech.speak({
    xOnBehalfOf: '<end-user-id>',
    textToSpeechRequest: {
      text: 'Welcome to the MKA1 API speech guide.',
      language: 'en',
      store: true,
    },
  });

  const audioBuffer = Buffer.from(await new Response(result.result).arrayBuffer());
  const languageCode = result.headers['x-language-code']?.[0];
  const ttsId = result.headers['x-tts-id']?.[0];

  writeFileSync('speech.wav', audioBuffer);
  console.log(languageCode);
  console.log(ttsId);
  ```

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

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

  result = sdk.llm.speech.speak(
      text="Welcome to the MKA1 API speech guide.",
      language="en",
      store=True,
  )

  with open("speech.wav", "wb") as f:
      f.write(result.body)
  ```

  ```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 result = await sdk.Llm.Speech.SpeakAsync(new MeetKai.MKA1.Types.Components.TextToSpeechRequest()
  {
      Text = "Welcome to the MKA1 API speech guide.",
      Language = TextToSpeechRequestLanguage.En,
      Store = true,
  });

  System.IO.File.WriteAllBytes("speech.wav", result.Bytes!);
  ```

  ```bash CLI theme={null}
  mka1 llm speech speak \
    --text 'Welcome to the MKA1 API speech guide.' \
    --language en \
    --store \
    --output-file speech.wav
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/speech/tts \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "text": "Welcome to the MKA1 API speech guide.",
      "language": "en",
      "store": true
    }' \
    --output speech.wav
  ```
</CodeGroup>

## Stream speech for lower latency

Use streaming text-to-speech when you want playback to start before the full audio file is ready.
Choose `mp3` for smaller payloads or `pcm` for uncompressed audio (returned as `audio/wav`).

To save the generated audio to history, set `store=true`. When stored, the response includes `X-Tts-Id`. History persistence for streaming is best-effort and completes shortly after the stream ends, so an immediate lookup by `X-Tts-Id` can briefly return `404`. If persistence fails or is skipped (for example, if the audio exceeds the 25MB history cap), the id is never assigned and lookups keep returning `404`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.llm.speech.speakStreaming({
    xOnBehalfOf: '<end-user-id>',
    textToSpeechStreamingRequest: {
      text: 'Start speaking this response as soon as audio is ready.',
      language: 'en',
      format: 'mp3',
      store: true,
    },
  });

  const contentType = result.headers['content-type']?.[0];
  const languageCode = result.headers['x-language-code']?.[0];
  const ttsId = result.headers['x-tts-id']?.[0];

  console.log(contentType);
  console.log(languageCode);
  console.log(ttsId);
  ```

  ```python Python SDK theme={null}
  result = sdk.llm.speech.speak_streaming(
      text="Start speaking this response as soon as audio is ready.",
      language="en",
      format_="mp3",
      store=True,
  )

  with open("speech.mp3", "wb") as f:
      f.write(result.body)
  ```

  ```csharp C# SDK theme={null}
  var result = await sdk.Llm.Speech.SpeakStreamingAsync(new MeetKai.MKA1.Types.Components.TextToSpeechStreamingRequest()
  {
      Text = "Start speaking this response as soon as audio is ready.",
      Language = TextToSpeechStreamingRequestLanguage.En,
      Format = TextToSpeechStreamingRequestFormat.Mp3,
      Store = true,
  });

  // Response contains either MP3 or WAV bytes depending on format
  var audioBytes = result.TwoHundredAudioMpegBytes ?? result.TwoHundredAudioWavBytes;
  System.IO.File.WriteAllBytes("speech.mp3", audioBytes!);
  ```

  ```bash CLI theme={null}
  mka1 llm speech speak-streaming \
    --text 'Start speaking this response as soon as audio is ready.' \
    --language en \
    --format mp3 \
    --store \
    --output-file speech.mp3
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/speech/tts/stream \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "text": "Start speaking this response as soon as audio is ready.",
      "language": "en",
      "format": "mp3",
      "store": true
    }' \
    --output speech.mp3
  ```
</CodeGroup>

## Supported languages

Set `language` to the language of your text, or leave it as `auto` (the default) to detect it from the text. Both endpoints accept these ISO 639-1 codes:

| Code | Language |
| - | - |
| `en` | English |
| `zh` | Chinese |
| `hi` | Hindi |
| `es` | Spanish |
| `ar` | Arabic |
| `bn` | Bengali |
| `pt` | Portuguese |
| `ru` | Russian |
| `ja` | Japanese |
| `pa` | Punjabi |
| `de` | German |
| `ko` | Korean |
| `fr` | French |
| `tr` | Turkish |
| `it` | Italian |
| `th` | Thai |
| `pl` | Polish |
| `nl` | Dutch |
| `id` | Indonesian |
| `vi` | Vietnamese |
| `ur` | Urdu |

Any other `language` value returns `400 Bad Request`.

With `auto`, `X-Language-Code` reports the language the API detected. If that language is not in the table, the request still succeeds: the text is spoken with the English voice, and `X-Language-Code` is `en`. If your text may be in an unsupported language, check `X-Language-Code` before you use the audio.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.