Name: Moonshot AI Kimi-Audio 7B Instruct Speech-to-Text and Audio Understanding API
Brand: magicapi
SKU: api-magicapi-universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎧 Speech-to-Text and Audio Understanding API (Moonshot AI Kimi-Audio 7B Instruct)

## Overview
Kimi-Audio-7B-Instruct is Moonshot AI's audio model, packaged here by zsxkib. Its developer describes it as combining speech recognition (ASR), audio reasoning, audio captioning, emotion sensing and speech generation in one universal model.

Send an `audio` file and, optionally, a text `prompt` that tells the model what to do with it. Choose text output, audio output or both with `output_type`. The response is an object with the text answer in `json_str` and a generated file URL in `media_path`.

## Features
- **Speech to text**: transcribe speech; the field description suggests prompts such as "Please convert this audio to text" (or the same instruction in Chinese).
- **Instructions about audio**: the optional `prompt` guides the model for reasoning, captioning or emotion questions about the clip.
- **Text, audio or both**: `output_type` is `text`, `audio` or `both` (default).
- **Separate sampling for text and audio**: temperature, top-k, repetition penalty and repetition window for text (`text_*`) and for audio (`audio_*`).
- **Deterministic text by default**: `text_temperature` defaults to `0`.

## Use Cases
1. **Transcription**: turn recorded speech, voice notes or interviews into text.
2. **Audio question answering**: ask what happens in a clip, what is said or how the speaker sounds.
3. **Audio captioning**: describe the content of a recording in a sentence.
4. **Spoken replies**: set `output_type` to `audio` or `both` to get a generated audio response to the input clip.

## Visual Examples
### Example Input
Audio: [Listen to the example input audio](https://blog.api.market/wp-content/uploads/2026/10/granite-speech-3-3-8b-input-api-market.wav)

Prompt: "Transcribe this audio, then summarize it in one sentence."

Settings: `output_type` `text`, `return_json` `true`, `text_temperature` `0`, `text_top_k` `5`, `text_repetition_penalty` `1`, `text_repetition_window_size` `16`, and the audio sampling fields at their defaults (`audio_temperature` `0.8`, `audio_top_k` `10`, `audio_repetition_penalty` `1`, `audio_repetition_window_size` `64`).

### Example Output
```json
{
  "json_str": "after his nap timothy lazily stretched first one gray velvet foot then another strolled indolently to his plate turning over the food carefully selecting choice bits nosing out that which he scorned upon the clean hearth",
  "media_path": null
}
```

The model returned the transcript only (lowercase, no punctuation) and no summary. `media_path` is `null` because the request asked for text output.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `audio` | string (URL) | Yes |  |  | Input audio file for processing. Can be used for speech-to-text (ASR) or audio-to-audio generation |
| `prompt` | string | No | none |  | Optional text prompt to guide the model. For ASR, use prompts like "Please convert this audio to text" |
| `output_type` | string | No | `both` | `audio`, `text`, `both` | Type of output to generate: `audio` for audio only, `text` for transcription only, or `both` for both audio and text responses |
| `return_json` | boolean | No | `true` |  | Return text results in JSON format instead of a text file |
| `audio_temperature` | number | No | `0.8` |  | Temperature for audio generation. Higher values (0.8-1.0) increase creativity but may reduce coherence |
| `audio_top_k` | integer | No | `10` |  | Top-k for audio generation. Limits the token selection to the k most likely tokens |
| `text_temperature` | number | No | `0` |  | Temperature for text generation. Lower values (0.0-0.5) increase factual accuracy |
| `text_top_k` | integer | No | `5` |  | Top-k for text generation. Limits the token selection to the k most likely tokens |
| `audio_repetition_penalty` | number | No | `1` |  | Repetition penalty for audio. Values above 1.0 discourage repetition in audio generation |
| `audio_repetition_window_size` | integer | No | `64` |  | Window size for audio repetition penalty calculation |
| `text_repetition_penalty` | number | No | `1` |  | Repetition penalty for text. Values above 1.0 discourage repetition in text generation |
| `text_repetition_window_size` | integer | No | `16` |  | Window size for text repetition penalty calculation |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0022 per API unit.
- **1 API unit = 1 successful request with up to 2 seconds of processing.** A longer job bills one more unit for each started block of 2 seconds (for example, 5 seconds of processing is 3 units, $0.0066).
- Longer audio clips take longer to process.
- **Example cost**: the example request took 11.69 seconds of processing, which is 6 units, so $0.0132.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 2 seconds and an overall timeout of 600 seconds (10 minutes) work well. The first request after a quiet period can wait a few minutes before processing starts; that waiting time is not billed.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "7500b32387695e89da3d09271850319ba027969f0c714dfc226361609ff29f2b",
    "input": {
      "audio": "https://blog.api.market/wp-content/uploads/2026/10/granite-speech-3-3-8b-input-api-market.wav",
      "prompt": "Transcribe this audio, then summarize it in one sentence.",
      "output_type": "text",
      "return_json": true,
      "text_temperature": 0,
      "text_top_k": 5,
      "text_repetition_penalty": 1,
      "text_repetition_window_size": 16,
      "audio_temperature": 0.8,
      "audio_top_k": 10,
      "audio_repetition_penalty": 1,
      "audio_repetition_window_size": 64
    }
  }'
```

Response (201 Created):
```json
{
  "id": "c1qp6pk2k9rmy0d1mvr9ap8spg",
  "version": "7500b32387695e89da3d09271850319ba027969f0c714dfc226361609ff29f2b",
  "status": "starting",
  "created_at": "2026-11-04T14:22:14.170Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "c1qp6pk2k9rmy0d1mvr9ap8spg",
  "status": "succeeded",
  "output": {
    "json_str": "after his nap timothy lazily stretched first one gray velvet foot then another strolled indolently to his plate turning over the food carefully selecting choice bits nosing out that which he scorned upon the clean hearth",
    "media_path": null
  },
  "error": null,
  "created_at": "2026-11-04T14:22:14.170Z",
  "started_at": "2026-11-04T14:25:40.227Z",
  "completed_at": "2026-11-04T14:25:51.914Z"
}
```

`output` is an object. `json_str` holds the text answer as a string. `media_path` is the URL of a generated file when the request produces one (audio output) and `null` otherwise.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `audio` or an `output_type` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "7500b32387695e89da3d09271850319ba027969f0c714dfc226361609ff29f2b", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 2000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "audio": "https://blog.api.market/wp-content/uploads/2026/10/granite-speech-3-3-8b-input-api-market.wav",
  "prompt": "Transcribe this audio, then summarize it in one sentence.",
  "output_type": "text",
  "return_json": true,
  "text_temperature": 0,
  "text_top_k": 5,
  "text_repetition_penalty": 1,
  "text_repetition_window_size": 16,
  "audio_temperature": 0.8,
  "audio_top_k": 10,
  "audio_repetition_penalty": 1,
  "audio_repetition_window_size": 64
}).then((output) => console.log(output.json_str));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/universal-audio-interaction-api-zsxkib-kimi-audio-7b-instruct"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "7500b32387695e89da3d09271850319ba027969f0c714dfc226361609ff29f2b", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 2
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


output = create_and_wait_for_prediction({
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/granite-speech-3-3-8b-input-api-market.wav",
    "prompt": "Transcribe this audio, then summarize it in one sentence.",
    "output_type": "text",
    "return_json": True,
    "text_temperature": 0,
    "text_top_k": 5,
    "text_repetition_penalty": 1,
    "text_repetition_window_size": 16,
    "audio_temperature": 0.8,
    "audio_top_k": 10,
    "audio_repetition_penalty": 1,
    "audio_repetition_window_size": 64
})
print(output["json_str"])
```

## FAQ
- **How do I get a plain transcript?**
  - Send the `audio`, set `output_type` to `text` and use a prompt such as "Please convert this audio to text". The transcript comes back in `output.json_str`.
- **Does it follow multi-step prompts?**
  - Not reliably. In our test, a prompt asking for a transcript and a one-sentence summary returned only the transcript. Send one instruction per request.
- **Why is `media_path` null?**
  - `media_path` only holds a file when the model produces audio. Set `output_type` to `audio` or `both` for a spoken response. The default `output_type` is `both`, so set `text` when you only need text.
- **How much does a request cost?**
  - $0.0022 for each started block of 2 seconds of processing. The example clip took 11.69 seconds, so it cost 6 units ($0.0132).
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page.


Transcribe audio and give instructions about a clip with Moonshot AI's Kimi-Audio-7B-Instruct, with text, audio or both as output. $0.0022 per 2 seconds of processing, pay as you go.