Speech

Use the MKA1 API speech endpoints when you need file-based speech-to-text or text-to-speech. For real-time, bidirectional voice sessions, use Advanced voice mode.

Choose the right endpoint

Use case	Endpoint	Notes
Transcribe a recorded file	Speech-to-text transcription	Upload audio with `multipart/form-data`
Generate a WAV file from text	Text-to-speech	Best for complete file generation
Start playback as soon as audio arrives	Streaming text-to-speech	Best for low-latency playback

Transcribe audio

Send an audio file to the transcription endpoint when you want text output from a recorded file. If your app acts on behalf of an end user, also send X-On-Behalf-Of. Supported audio formats: FLAC, MP3, MP4, MPEG, MPGA, M4A, OGG, WAV, WebM. To save the transcription (and input audio) to history, set store=true.

mka1 llm speech transcribe \
  --file ./episode.wav \
  --language en \
  --prompt 'This is a technical podcast about machine learning.' \
  --temperature 0.2 \
  --store \
  -H 'X-On-Behalf-Of: <end-user-id>'

import { SDK } from '@meetkai/mka1';
import { openAsBlob } from 'node:fs';

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

const result = await mka1.llm.speech.transcribe({
  xOnBehalfOf: '<end-user-id>', // optional — attribute the request to one of your end users
  language: 'en',
  prompt: 'This is a technical podcast about machine learning.',
  temperature: 0.2,
  store: true,
  requestBody: {
    file: await openAsBlob('episode.wav'),
  },
});

console.log(result.text);
console.log(result.language);
console.log(result.confidence);

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;

var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

var result = await sdk.Llm.Speech.TranscribeAsync(new TranscribeRequest()
{
    Language = "en",
    Prompt = "This is a technical podcast about machine learning.",
    Temperature = 0.2,
    Store = true,
    Body = new TranscribeRequestBody()
    {
        File = new TranscribeFile()
        {
            FileName = "episode.wav",
            Content = File.ReadAllBytes("episode.wav"),
        },
    },
});

Console.WriteLine(result.TranscriptionResponse!.Text);
Console.WriteLine(result.TranscriptionResponse!.Language);
Console.WriteLine(result.TranscriptionResponse!.Confidence);

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

result = sdk.llm.speech.transcribe(
    file={"file_name": "episode.wav", "content": open("episode.wav", "rb")},
    language="en",
    prompt="This is a technical podcast about machine learning.",
    temperature=0.2,
    store=True,
)

print(result.text)
print(result.language)
print(result.confidence)

curl 'https://apigw.mka1.com/api/v1/llm/speech/transcriptions?language=en&prompt=This%20is%20a%20technical%20podcast%20about%20machine%20learning.&temperature=0.2&store=true' \
  --request POST \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --form 'file=@episode.wav'

The response includes the transcript text plus detected language and confidence:

{
  "text": "Hello! We're excited to show you our native speech capabilities.",
  "language": "en",
  "confidence": 0.8429018476208717
}

Separate speakers in one transcript

If you need diarization, enable speaker data in the transcription request. When enabled, the response can include a speakers array with speaker-labeled segments and timing metadata.

For include_speaker_data, upload WAV or PCM audio for non-streaming transcription. Other audio formats return 400 BAD_REQUEST with the message Speaker diarization currently requires WAV/PCM audio for non-streaming transcription.

const result = await mka1.llm.speech.transcribe({
  xOnBehalfOf: '<end-user-id>',
  language: 'en',
  includeSpeakerData: true,
  prompt: 'This is a short podcast clip about AI product updates.',
  temperature: 0.2,
  requestBody: {
    file: await openAsBlob('panel.wav'),
  },
});

console.log(result.speakers);

Example response with speaker separation:

{
  "text": "Welcome back to the show. Today we're looking at how speech APIs fit into production apps. We'll keep it practical and focus on latency, accuracy, and speaker turns.",
  "language": "en",
  "confidence": 0.91177404,
  "speakers": [
    {
      "speaker": "Speaker-1",
      "text": "Welcome back to the show.",
      "confidence": 0.91177404,
      "offset_ms": 80,
      "duration_ms": 1280
    },
    {
      "speaker": "Speaker-2",
      "text": "Today we're looking at how speech APIs fit into production apps.",
      "confidence": 0.91177404,
      "offset_ms": 1540,
      "duration_ms": 3380
    },
    {
      "speaker": "Speaker-1",
      "text": "We'll keep it practical and focus on latency, accuracy, and speaker turns.",
      "confidence": 0.91177404,
      "offset_ms": 5220,
      "duration_ms": 3660
    }
  ]
}

Use the top-level text field when you need a single merged transcript. Use speakers when you need captions, turn-taking, or downstream speaker analytics.

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.

mka1 llm speech speak \
  --text 'Welcome to the MKA1 API speech guide.' \
  --language en \
  --store \
  --output-file speech.wav

import { writeFileSync } from 'node:fs';

const result = await mka1.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);

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;

var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

var result = await sdk.Llm.Speech.SpeakAsync(new TextToSpeechRequest()
{
    Text = "Welcome to the MKA1 API speech guide.",
    Language = TextToSpeechRequestLanguage.En,
    Store = true,
});

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

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)

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

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.

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

const result = await mka1.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);

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;

var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

var result = await sdk.Llm.Speech.SpeakStreamingAsync(new 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;
File.WriteAllBytes("speech.mp3", audioBytes!);

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)

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

Next steps

Review the Speech-to-text transcription reference for request and response details
Review the Text-to-speech reference for WAV generation
Review the Streaming text-to-speech reference for low-latency output
Use Advanced voice mode for real-time conversations

Getting started

Responses

Features

Compute

CLI

Recipes

Benchmarks

Infrastructure

Choose the right endpoint

Transcribe audio

Separate speakers in one transcript

Generate speech

Stream speech for lower latency

Next steps

​Choose the right endpoint

​Transcribe audio

​Separate speakers in one transcript

​Generate speech

​Stream speech for lower latency

​Next steps

Choose the right endpoint

Transcribe audio

Separate speakers in one transcript

Generate speech

Stream speech for lower latency

Next steps