API Documentation

// JavaScript Example
const response = await fetch('/api/tts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
    text: 'Hello, this is a test text',
    voice: 'x5_lingfeiyi_flow',
    speed: 60,
    volume: 80,
    pitch: 50,
    streamMode: false
  })
});

if (response.ok) {
  const audioData = await response.arrayBuffer();
  const audioBlob = new Blob([audioData], { type: 'audio/mpeg' });
  const audioUrl = URL.createObjectURL(audioBlob);
  
  // Play audio
  const audio = new Audio(audioUrl);
  audio.play();
} else {
  const error = await response.json();
  console.error('Synthesis failed:', error);
}

curl -X POST https://your-domain.com/api/tts \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{
    "text": "Hello, this is a test text",
    "voice": "x5_lingfeiyi_flow",
    "speed": 60,
    "volume": 80,
    "pitch": 50
  }' \
  --output audio.mp3

// Step 1: Get WebSocket URL (Usage billed on this request)
const getStreamUrl = async () => {
  const text = 'Hello, this is a streaming test with a direct connection.';
  const voice = 'x5_lingfeiyi_flow';
  const speed = 50;
  const volume = 80;
  const pitch = 50;

  const response = await fetch('/api/tts-stream?' + new URLSearchParams({
    text,
    voice,
    speed: String(speed),
    volume: String(volume),
    pitch: String(pitch),
  }), {
    headers: {
      'Authorization': 'Bearer YOUR_JWT_TOKEN'
    }
  });

  if (response.ok) {
    const data = await response.json();
    const wsUrl = data.wsUrl;
    
    // Step 2: Connect to WebSocket and send synthesis parameters
    const socket = new WebSocket(wsUrl);
    
    socket.onopen = () => {
      console.log('WebSocket connection established.');
      // Based on official documentation, construct and send the request JSON
      const requestData = {
        header: {
          app_id: "73d88ee4", // Use this fixed app_id for this service
          status: 2, // 2 indicates this is the final and only chunk of text
        },
        parameter: {
          tts: {
            vcn: voice,
            speed: speed,
            volume: volume,
            pitch: pitch,
            audio: {
              encoding: "lame",
              sample_rate: 24000,
              channels: 1,
              bit_depth: 16,
              frame_size: 0
            }
          }
        },
        payload: {
          text: {
            encoding: "utf8",
            compress: "raw",
            format: "plain",
            status: 2, // 2 indicates the final text chunk for this request
            // Text must be base64 encoded
            text: btoa(unescape(encodeURIComponent(text)))
          }
        }
      };
      
      socket.send(JSON.stringify(requestData));
    };

    socket.onmessage = (event) => {
      // The server will send back audio data, likely in a JSON object.
      // The specific format depends on the service implementation.
      console.log('Received data:', event.data);
      // Example of handling a JSON response with base64 audio:
      // const response = JSON.parse(event.data);
      // if (response.type === 'audio' && response.data) {
      //   const audioChunk = atob(response.data);
      //   // Your logic to play or buffer the audio chunk
      // }
    };

    socket.onclose = (event) => {
      console.log('WebSocket connection closed.', event.code, event.reason);
    };

    socket.onerror = (error) => {
      console.error('WebSocket error:', error);
    };

  } else {
    const error = await response.json();
    console.error('Failed to get WebSocket URL:', error);
  }
};

getStreamUrl();

// Create an <audio> element in your page
audioElement = new Audio();

await (async () => {
  const response = await fetch('/api/tts-proxy', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_JWT_TOKEN'
    },
    body: JSON.stringify({
      text: 'Hello via HTTP streaming!',
      voice: 'x5_lingfeiyi_flow'
    })
  });

  if (!response.ok || !response.body) throw new Error('Request failed');

  const mediaSource = new MediaSource();
  audioElement.src = URL.createObjectURL(mediaSource);
  mediaSource.addEventListener('sourceopen', async () => {
    const sourceBuffer = mediaSource.addSourceBuffer('audio/mpeg');
    const reader = response.body.getReader();
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      sourceBuffer.appendBuffer(value);
    }
    mediaSource.endOfStream();
    audioElement.play();
  });
})();