> Для получения чистого Markdown любой страницы добавьте .md к URL‑адресу страницы.  
> Для полного индекса документации см. https://api.vega.chat/docs/llms.txt.  
> Для полного содержания документации см. https://api.vega.chat/docs/llms-full.txt.  
> Для интеграции AI‑клиентов (Claude Code, Cursor и др.) подключитесь к MCP‑серверу по адресу https://api.vega.chat/docs/_mcp/server.

# Аудио

VEGA поддерживает как отправку аудиофайлов совместимым моделям, так и получение аудиоответов через API. Это руководство охватывает работу с аудиовходами и аудиовыходами.

## Аудиовходы

Отправляйте аудиофайлы совместимым моделям для транскрипции, анализа и обработки. Запросы аудиовхода используют API `/api/v1/chat/completions` с типом содержимого `input_audio`. Аудиофайлы должны быть закодированы в base64 и включать указание формата.

**Примечание**: Аудиофайлы должны быть **закодированы в base64** — прямые URL‑адреса для аудиоконтента не поддерживаются.

Вы можете искать модели, поддерживающие аудиовход, отфильтровав по модальности аудиовхода на нашей [странице моделей](/models?fmt=cards\&input_modalities=audio).

### Отправка аудиофайлов

Вот как отправить аудиофайл для обработки:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';
import fs from "fs/promises";

const client = new OpenRouter({
  apiKey: '{{API_KEY_REF}}',
});

async function encodeAudioToBase64(audioPath: string): Promise<string> {
  const audioBuffer = await fs.readFile(audioPath);
  return audioBuffer.toString("base64");
}

// Чтение и кодирование аудиофайла
const audioPath = "path/to/your/audio.wav";
const base64Audio = await encodeAudioToBase64(audioPath);

const result = await client.chat.send({
  model: "{{MODEL}}",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "Please transcribe this audio file.",
        },
        {
          type: "input_audio",
          inputAudio: {
            data: base64Audio,
            format: "wav",
          },
        },
      ],
    },
  ],
  stream: false,
});

console.log(result);
```

```python
import requests
import json
import base64

def encode_audio_to_base64(audio_path):
    with open(audio_path, "rb") as audio_file:
        return base64.b64encode(audio_file.read()).decode('utf-8')

url = "https://api.vega.chat/api/v1/chat/completions"
headers = {
    "Authorization": f"Bearer {API_KEY_REF}",
    "Content-Type": "application/json"
}

# Чтение и кодирование аудиофайла
audio_path = "path/to/your/audio.wav"
base64_audio = encode_audio_to_base64(audio_path)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Please transcribe this audio file."
            },
            {
                "type": "input_audio",
                "input_audio": {
                    "data": base64_audio,
                    "format": "wav"
                }
            }
        ]
    }
]

payload = {
    "model": "{{MODEL}}",
    "messages": messages
}

response = requests.post(url, headers=headers, json=payload)
print(response.json())
```

```typescript title="TypeScript (fetch)"
import fs from "fs/promises";

async function encodeAudioToBase64(audioPath: string): Promise<string> {
  const audioBuffer = await fs.readFile(audioPath);
  return audioBuffer.toString("base64");
}

// Чтение и кодирование аудиофайла
const audioPath = "path/to/your/audio.wav";
const base64Audio = await encodeAudioToBase64(audioPath);

const response = await fetch("https://api.vega.chat/api/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY_REF}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "{{MODEL}}",
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Please transcribe this audio file.",
          },
          {
            type: "input_audio",
            input_audio: {
              data: base64Audio,
              format: "wav",
            },
          },
        ],
      },
    ],
  }),
});

const data = await response.json();
console.log(data);
```

### Поддерживаемые форматы аудиовхода

Поддерживаемые форматы аудио зависят от провайдера. Распространённые форматы включают:

* `wav` — WAV‑аудио  
* `mp3` — MP3‑аудио  
* `aiff` — AIFF‑аудио  
* `aac` — AAC‑аудио  
* `ogg` — OGG Vorbis‑аудио  
* `flac` — FLAC‑аудио  
* `m4a` — M4A‑аудио  
* `pcm16` — PCM16‑аудио  
* `pcm24` — PCM24‑аудио  

**Примечание:** Проверьте документацию вашей модели, чтобы убедиться, какие аудиоформаты поддерживаются. Не все модели поддерживают все форматы.

## Аудиовыход

VEGA поддерживает получение аудиоответов от моделей, обладающих возможностями аудиовыхода. Чтобы запросить аудиовыход, включите параметры `modalities` и `audio` в ваш запрос.

Вы можете искать модели, поддерживающие аудиовыход, отфильтровав по модальности аудиовыхода на нашей [странице моделей](/models?fmt=cards\&output_modalities=audio).

### Запрос аудиовыхода

Чтобы получить аудиовыход, установите `modalities` в `["text", "audio"]` и задайте конфигурацию `audio` с желаемым голосом и форматом:

```python
import requests
import json
import base64

url = "https://api.vega.chat/api/v1/chat/completions"
headers = {
    "Authorization": f"Bearer {API_KEY_REF}",
    "Content-Type": "application/json"
}

payload = {
    "model": "{{MODEL}}",
    "messages": [
        {
            "role": "user",
            "content": "Say hello in a friendly tone."
        }
    ],
    "modalities": ["text", "audio"],
    "audio": {
        "voice": "alloy",
        "format": "wav"
    },
    "stream": True
}

# Аудиовыход требует потоковой передачи — ответ приходит в виде SSE‑чанков
response = requests.post(url, headers=headers, json=payload, stream=True)

audio_data_chunks = []
transcript_chunks = []

for line in response.iter_lines():
    if not line:
        continue
    decoded = line.decode("utf-8")
    if not decoded.startswith("data: "):
        continue
    data = decoded[len("data: "):]
    if data.strip() == "[DONE]":
        break
    chunk = json.loads(data)
    delta = chunk["choices"][0].get("delta", {})
    audio = delta.get("audio", {})
    if audio.get("data"):
        audio_data_chunks.append(audio["data"])
    if audio.get("transcript"):
        transcript_chunks.append(audio["transcript"])

transcript = "".join(transcript_chunks)
print(f"Transcript: {transcript}")

# Объединяем и декодируем base64‑чанки аудио, затем сохраняем
full_audio_b64 = "".join(audio_data_chunks)
audio_bytes = base64.b64decode(full_audio_b64)
with open("output.wav", "wb") as f:
    f.write(audio_bytes)
```

```typescript title="TypeScript (fetch)"
const response = await fetch("https://api.vega.chat/api/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY_REF}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "{{MODEL}}",
    messages: [
      {
        role: "user",
        content: "Say hello in a friendly tone.",
      },
    ],
    modalities: ["text", "audio"],
    audio: {
      voice: "alloy",
      format: "wav",
    },
    stream: true,
  }),
});

// Аудиовыход требует потоковой передачи — парсим SSE‑чанки
const reader = response.body!.getReader();
const decoder = new TextDecoder();

const audioDataChunks: string[] = [];
const transcriptChunks: string[] = [];
let buffer = "";

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop()!; // оставляем неполную строку в буфере

  for (const line of lines) {
    if (!line.startsWith("data: ")) continue;
    const data = line.slice("data: ".length).trim();
    if (data === "[DONE]") break;

    const chunk = JSON.parse(data);
    const audio = chunk.choices?.[0]?.delta?.audio;
    if (audio?.data) audioDataChunks.push(audio.data);
    if (audio?.transcript) transcriptChunks.push(audio.transcript);
  }
}

const transcript = transcriptChunks.join("");
console.log(`Transcript: ${transcript}`);

// Объединённые audioDataChunks образуют полное base64‑закодированное аудио
const fullAudioB64 = audioDataChunks.join("");
```

### Формат потоковых чанков

Аудиовыход требует потоковой передачи (`stream: true`). Аудиоданные и транскрипт доставляются постепенно через поле `delta.audio` в каждом чанке:

```json
{
  "choices": [
    {
      "delta": {
        "audio": {
          "data": "<base64-encoded audio chunk>",
          "transcript": "Hello"
        }
      }
    }
  ]
}
```

### Параметры аудиоконфигурации

Параметр `audio` принимает следующие опции:

| Параметр | Описание |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `voice`  | Голос, используемый для генерации аудио (например, `alloy`, `echo`, `fable`, `onyx`, `nova`, `shimmer`). Доступные голоса зависят от модели. |
| `format` | Формат аудио для вывода (например, `wav`, `mp3`, `flac`, `opus`, `pcm16`). Доступные форматы зависят от модели. |