Real-Time Speech to Text: APIs, Applications, and Future Trends

1const audioContext = new (window.AudioContext || window.webkitAudioContext)();
2const analyser = audioContext.createAnalyser();
3const microphone = audioContext.createMediaStreamSource(stream);
4microphone.connect(analyser);
5
6const websocket = new WebSocket('wss://your-websocket-endpoint');
7
8websocket.onopen = () => {
9  console.log('WebSocket connection established');
10};
11
12websocket.onclose = () => {
13    console.log('Websocket connection closed');
14};
15
16websocket.onerror = (error) => {
17  console.error('WebSocket error:', error);
18};
19
20const bufferLength = analyser.frequencyBinCount;
21const dataArray = new Float32Array(bufferLength);
22
23function sendAudioData() {
24  analyser.getFloatTimeDomainData(dataArray);
25
26  // Convert Float32Array to a suitable format for WebSocket transmission (e.g., Blob or ArrayBuffer)
27  const audioBlob = new Blob([dataArray.buffer], { type: 'audio/webm;codecs=opus' });
28
29  if (websocket.readyState === WebSocket.OPEN) {
30    websocket.send(audioBlob);
31  }
32
33  requestAnimationFrame(sendAudioData);
34}
35
36sendAudioData();

1import asyncio
2import deepgram
3
4# Your Deepgram API Key
5DEEPGRAM_API_KEY = "YOUR_DEEPGRAM_API_KEY"
6
7# Path to the audio file you want to transcribe
8AUDIO_FILE = 'path/to/your/audio.wav'
9
10async def main():
11    try:
12        # Initialize the Deepgram SDK
13        dg_client = deepgram.Deepgram(DEEPGRAM_API_KEY)
14
15        # Create a websocket connection to Deepgram
16        websocket = await dg_client.listen.asyncer.connect(
17            {'model': 'nova-2', 'punctuate': True, 'language': 'en-US'}
18        )
19
20        # Function to send audio data
21        async def send_audio(file_path):
22            with open(file_path, 'rb') as file:
23                while True:
24                    data = file.read(1024)  # Read in chunks
25                    if not data:
26                        break
27                    await websocket.send(data)
28            await websocket.send(bytes('', 'utf-8')) # Sending empty bytes closes stream
29
30        # Define the handler for transcriptions
31        async def on_message(self, result, **kwargs):
32            sentence = result.channel.alternatives[0].transcript
33            if len(sentence) == 0:
34                return
35            print(f"Transcription: {sentence}")
36
37        #Set handlers
38        websocket.on("Transcript", on_message)
39        websocket.on("Metadata", lambda self, result, **kwargs : print(f"Metadata : {result}"))
40        websocket.on("UtteranceEnd", lambda self, result, **kwargs : print(f"UtteranceEnd: {result}"))
41
42        # Send the audio file
43        await send_audio(AUDIO_FILE)
44
45        # Indicate that we've finished sending data
46        await websocket.close()
47
48    except Exception as e:
49        print(f"Could not open socket: {e}")
50
51asyncio.run(main())

1const WebSocket = require('ws');
2
3// Replace with your actual API key and other configuration
4const apiKey = 'YOUR_NEURALSPACE_API_KEY';
5const audioFilePath = 'path/to/your/audio.wav';
6const apiUrl = 'wss://api.neuralspace.ai/v1/asr/ws';
7
8// Function to convert audio file to base64 string
9const fs = require('fs');
10const audioFile = fs.readFileSync(audioFilePath);
11const audioBase64 = Buffer.from(audioFile).toString('base64');
12
13// Create WebSocket connection
14const ws = new WebSocket(apiUrl, {
15  headers: {
16    'X-API-Key': apiKey,
17  },
18});
19
20// Handle WebSocket events
21ws.on('open', () => {
22  console.log('Connected to NeuralSpace ASR WebSocket');
23
24  // Prepare the start message
25  const startMessage = JSON.stringify({
26    message: 'START',
27    encoding: 'wav',
28    sample_rate: 16000, // Adjust as needed
29    language: 'en',
30  });
31  ws.send(startMessage);
32
33    // Send audio data
34    const audioMessage = JSON.stringify({
35        message: 'AUDIO',
36        audio: audioBase64,
37    });
38  ws.send(audioMessage);
39
40  // Send the stop message
41  const stopMessage = JSON.stringify({
42    message: 'STOP',
43  });
44  ws.send(stopMessage);
45});
46
47ws.on('message', (data) => {
48  const response = JSON.parse(data);
49  console.log('Received message:', response);
50});
51
52ws.on('close', () => {
53  console.log('Disconnected from NeuralSpace ASR WebSocket');
54});
55
56ws.on('error', (error) => {
57  console.error('WebSocket error:', error);
58});

1import asyncio
2import websockets
3import json
4
5async def stt_client(api_url, api_key, audio_queue):
6    async with websockets.connect(api_url, extra_headers={'X-API-Key': api_key}) as websocket:
7        # Start message
8        start_message = json.dumps({
9            "message": "START",
10            "encoding": "pcm",
11            "sample_rate": 16000,
12            "language": "en"
13        })
14        await websocket.send(start_message)
15
16        try:
17            while True:
18                audio_data = await audio_queue.get()
19                if audio_data is None:
20                    break  # Signal to close
21
22                audio_message = json.dumps({
23                    "message": "AUDIO",
24                    "audio": audio_data.decode('latin-1')
25                })
26                await websocket.send(audio_message)
27
28                result = await websocket.recv()
29                result_json = json.loads(result)
30                print("Transcription Result:", result_json)
31
32        except websockets.exceptions.ConnectionClosedError as e:
33            print(f"Connection closed unexpectedly: {e}")
34        except Exception as e:
35            print(f"An error occurred: {e}")
36        finally:
37            # Stop message
38            stop_message = json.dumps({
39                "message": "STOP"
40            })
41            await websocket.send(stop_message)
42            print("Client finished")
43
44# Example Usage (Conceptual): Assumes you have an audio feed
45# audio_queue = asyncio.Queue()
46# asyncio.run(stt_client("wss://your-api-endpoint", "YOUR_API_KEY", audio_queue))
47# While capturing audio, push the PCM data into audio_queue
48# To signal the client to stop: await audio_queue.put(None)