Real-Time WebSocket API

wss://api.tryhamsa.com/v1/realtime/ws?api_key=YOUR_API_KEY

X-Api-Key: YOUR_API_KEY

const ws = new WebSocket('wss://api.tryhamsa.com/v1/realtime/ws?api_key=YOUR_API_KEY');

const audioChunks = [];

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'tts',
    payload: {
      text: 'مرحبا بك',
      speaker: 'Amjad',
      dialect: 'pls',
      languageId: 'ar',
      mulaw: false,
      expressiveness: 1
    }
  }));
};

ws.onmessage = (event) => {
  if (event.data instanceof Blob) {
    // Binary audio chunk
    audioChunks.push(event.data);
  } else {
    const message = JSON.parse(event.data);

    if (message.type === 'end') {
      // Combine all chunks into final audio
      const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
      const audioUrl = URL.createObjectURL(audioBlob);
      const audio = new Audio(audioUrl);
      audio.play();
    }
  }
};

import asyncio
import websockets
import json

async def tts_stream():
    uri = "wss://api.tryhamsa.com/v1/realtime/ws?api_key=YOUR_API_KEY"

    async with websockets.connect(uri) as ws:
        # Send TTS request
        await ws.send(json.dumps({
            "type": "tts",
            "payload": {
                "text": "مرحبا بك",
                "speaker": "Amjad",
                "dialect": "pls",
                "languageId": "ar",
                "mulaw": False,
                "expressiveness": 1
            }
        }))

        audio_chunks = []

        async for message in ws:
            if isinstance(message, bytes):
                audio_chunks.append(message)
            else:
                data = json.loads(message)
                if data["type"] == "end":
                    # Save audio file
                    with open("output.wav", "wb") as f:
                        f.write(b"".join(audio_chunks))
                    break

asyncio.run(tts_stream())

const ws = new WebSocket('wss://api.tryhamsa.com/v1/realtime/ws?api_key=YOUR_API_KEY');

ws.onopen = async () => {
  // Get audio from microphone
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const mediaRecorder = new MediaRecorder(stream);
  const chunks = [];

  mediaRecorder.ondataavailable = (e) => chunks.push(e.data);

  mediaRecorder.onstop = async () => {
    const blob = new Blob(chunks);
    const buffer = await blob.arrayBuffer();
    const base64 = btoa(String.fromCharCode(...new Uint8Array(buffer)));

    ws.send(JSON.stringify({
      type: 'stt',
      payload: {
        audioBase64: base64,
        language: 'ar',
        isEosEnabled: true,
        eosThreshold: 0.3
      }
    }));
  };

  mediaRecorder.start();
  setTimeout(() => mediaRecorder.stop(), 3000); // Record 3 seconds
};

ws.onmessage = (event) => {
  if (typeof event.data === 'string') {
    try {
      const json = JSON.parse(event.data);
      if (json.type === 'error') {
        console.error('Error:', json.payload.message);
      }
    } catch {
      // Plain text transcription result
      console.log('Transcription:', event.data);
    }
  }
};

import asyncio
import websockets
import json
import base64

async def stt_transcribe():
    uri = "wss://api.tryhamsa.com/v1/realtime/ws?api_key=YOUR_API_KEY"

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

        audio_base64 = base64.b64encode(audio_data).decode()

        # Send STT request
        await ws.send(json.dumps({
            "type": "stt",
            "payload": {
                "audioBase64": audio_base64,
                "language": "ar",
                "isEosEnabled": True,
                "eosThreshold": 0.3
            }
        }))

        # Receive transcription
        response = await ws.recv()
        print(f"Transcription: {response}")

asyncio.run(stt_transcribe())