Skip to main content
GET
/
realtime
Python WebSocket Client
import asyncio
import websockets
import json
import base64
import os

async def transcribe_audio():
    api_key = os.environ.get("TOGETHER_API_KEY")
    url = "wss://api.together.ai/v1/realtime?model=openai/whisper-large-v3&input_audio_format=pcm_s16le_16000"

    headers = {
        "Authorization": f"Bearer {api_key}"
    }

    async with websockets.connect(url, additional_headers=headers) as ws:
        # Read audio file
        with open("audio.wav", "rb") as f:
            audio_data = f.read()

        # Send audio in chunks with delay to simulate real-time
        chunk_size = 8192
        bytes_per_second = 16000 * 2  # 16kHz * 2 bytes (16-bit)
        delay_per_chunk = chunk_size / bytes_per_second

        for i in range(0, len(audio_data), chunk_size):
            chunk = audio_data[i:i+chunk_size]
            base64_chunk = base64.b64encode(chunk).decode('utf-8')
            await ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": base64_chunk
            }))
            # Simulate real-time streaming
            if i + chunk_size < len(audio_data):
                await asyncio.sleep(delay_per_chunk)

        # Commit the audio buffer
        await ws.send(json.dumps({
            "type": "input_audio_buffer.commit"
        }))

        # Receive transcription results
        async for message in ws:
            data = json.loads(message)
            if data["type"] == "conversation.item.input_audio_transcription.delta":
                print(f"Partial: {data['delta']}")
            elif data["type"] == "conversation.item.input_audio_transcription.completed":
                print(f"Final: {data['transcript']}")
                break
            elif data["type"] == "conversation.item.input_audio_transcription.failed":
                error = data.get("error", {})
                print(f"Error: {error.get('message')}")
                break

asyncio.run(transcribe_audio())
import WebSocket from 'ws';
import fs from 'fs';

const apiKey = process.env.TOGETHER_API_KEY;
const url = 'wss://api.together.ai/v1/realtime?model=openai/whisper-large-v3&input_audio_format=pcm_s16le_16000';

const ws = new WebSocket(url, {
  headers: {
    'Authorization': `Bearer ${apiKey}`
  }
});

ws.on('open', async () => {
  console.log('WebSocket connection established!');

  // Read audio file
  const audioData = fs.readFileSync('audio.wav');

  // Send audio in chunks with delay to simulate real-time
  const chunkSize = 8192;
  const bytesPerSecond = 16000 * 2;  // 16kHz * 2 bytes (16-bit)
  const delayPerChunk = (chunkSize / bytesPerSecond) * 1000;  // Convert to ms

  for (let i = 0; i < audioData.length; i += chunkSize) {
    const chunk = audioData.slice(i, i + chunkSize);
    const base64Chunk = chunk.toString('base64');
    ws.send(JSON.stringify({
      type: 'input_audio_buffer.append',
      audio: base64Chunk
    }));

    // Simulate real-time streaming
    if (i + chunkSize < audioData.length) {
      await new Promise(resolve => setTimeout(resolve, delayPerChunk));
    }
  }

  // Commit audio buffer
  ws.send(JSON.stringify({
    type: 'input_audio_buffer.commit'
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());

  if (message.type === 'conversation.item.input_audio_transcription.delta') {
    console.log(`Partial: ${message.delta}`);
  } else if (message.type === 'conversation.item.input_audio_transcription.completed') {
    console.log(`Final: ${message.transcript}`);
    ws.close();
  } else if (message.type === 'conversation.item.input_audio_transcription.failed') {
    const errorMessage = message.error?.message ?? message.message ?? 'Unknown error';
    console.error(`Error: ${errorMessage}`);
    ws.close();
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});
curl --request GET \
  --url https://api.together.ai/v1/realtime \
  --header 'Authorization: Bearer <token>'
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.together.ai/v1/realtime",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.together.ai/v1/realtime"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
HttpResponse<String> response = Unirest.get("https://api.together.ai/v1/realtime")
  .header("Authorization", "Bearer <token>")
  .asString();
require 'uri'
require 'net/http'

url = URI("https://api.together.ai/v1/realtime")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

Authorizations

​
Authorization
string
header
default:default
required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Query Parameters

​
model
string
required

The Whisper model to use for transcription

​
input_audio_format
enum<string>
default:pcm_s16le_16000
required

Audio format specification. Currently supports 16-bit PCM at 16kHz sample rate.

Available options:
pcm_s16le_16000

Response

101

Switching Protocols - WebSocket connection established successfully.

Error message format:

{
  "type": "conversation.item.input_audio_transcription.failed",
  "error": {
    "message": "Error description",
    "type": "invalid_request_error",
    "param": null,
    "code": "error_code"
  }
}