curl --location --request POST 'https://verbumapi.onemeta.ai:3001/login' \
--form 'name="my-user-name"' \
--form 'password="my-user-password"'
                            
                        

                            
const form = new FormData();
form.append('name', '"my-user-name"');
form.append('password', '"my-user-password"');

fetch('https://verbumapi.onemeta.ai:3001/login', {
    method: 'POST',
    body: form
});
                            
                        

                            
func chilkatTest() {
    let rest = CkoRest()
    var success: Bool

    // URL: https://verbumapi.onemeta.ai:3001/login
    var bTls: Bool = true
    var port: Int = 3001
    var bAutoReconnect: Bool = true
    success = rest.Connect("verbumapi.onemeta.ai", port: port, tls: bTls, autoReconnect: bAutoReconnect)
    if success != true {
        print("ConnectFailReason: \(rest.ConnectFailReason.intValue)")
        print("\(rest.LastErrorText)")
        return
    }

    // Note: The above code does not need to be repeatedly called for each REST request.
    // The rest object can be setup once, and then many requests can be sent.  Chilkat will automatically
    // reconnect within a FullRequest* method as needed.  It is only the very first connection that is explicitly
    // made via the Connect method.

    rest.PartSelector = "1"
    rest.AddHeader("Content-Disposition", value: "form-data; name=\"my-user-name\"")
    rest.SetMultipartBodyString("")

    rest.PartSelector = "2"
    rest.AddHeader("Content-Disposition", value: "form-data; name=\"password\"")
    rest.SetMultipartBodyString("my-user-password")

    rest.PartSelector = "0"

    rest.PartSelector = "0"
    rest.AddHeader("Content-Type", value: "multipart/form-data")

    var strResponseBody: String? = rest.FullRequestMultipart("POST", uriPath: "/login")
    if rest.LastMethodSuccess != true {
        print("\(rest.LastErrorText)")
        return
    }

    var respStatusCode: Int = rest.ResponseStatusCode.intValue
    print("response status code = \(respStatusCode)")
    if respStatusCode >= 400 {
        print("Response Status Code = \(respStatusCode)")
        print("Response Header:")
        print("\(rest.ResponseHeader)")
        print("Response Body:")
        print("\(strResponseBody!)")
        return
    }

    let jsonResponse = CkoJsonObject()
    jsonResponse.Load(strResponseBody)

}
                            
                        

                            
let sampleRate = 16000;
let bitsPerSample = 16;
let channelCount = 1;

// Request access to the microphone
navigator.mediaDevices.getUserMedia({ audio: true }).then(stream => {
  let context = new AudioContext({ sampleRate });
  let source = context.createMediaStreamSource(stream);
  let processor = context.createScriptProcessor(4096, 1, 1);

  let samples = [];
  processor.onaudioprocess = event => {
    let input = event.inputBuffer.getChannelData(0);
    for (let i = 0; i < input.length; i++) {
      let sample = Math.round(input[i] * 0x7FFF);
      samples.push(sample);
    }
  };

  source.connect(processor);
  processor.connect(context.destination);


  // Connect to a WebSocket
  let socket = new WebSocket("wss://verbumapi.onemeta.ai:3001/ws/{your-verbum-token}");

  socket.binaryType = 'arraybuffer';

  socket.onopen = () => {
    // set language to spanish Argentina
    const data_to_send = `{
      "speechLanguage": "es-AR"
    }`;
    socket.send(data_to_send);
    // Start sending audio data to the server
    let chunkSize = sampleRate * channelCount * bitsPerSample / 8;
    let intervalId = setInterval(() => {
      if (samples.length >= chunkSize) {
        let chunk = samples.splice(0, chunkSize);

        // Encode chunk as a little-endian, 16-bit, signed integer array
        let buffer = new ArrayBuffer(chunk.length * 2);
        let view = new DataView(buffer);
        for (let i = 0; i < chunk.length; i++) {
          view.setInt16(i * 2, chunk[i], true /* little endian */);
        }

        // Send chunk to the WebSocket server
        socket.send(buffer);
      }
    }, 20);

    socket.onmessage = event => {
      // Get data after receiving from WebSocket
      console.log("Data after receiving: ", event.data);
      console.log(event.data);
    };

    // Stop sending audio data and close the WebSocket after 10 seconds
    setTimeout(() => {
      clearInterval(intervalId);
      socket.close();
      processor.disconnect();
      source.disconnect();
      context.close();
    }, 10000);
  };
});
                            
                        

                            
import AVFoundation
import Foundation
import Starscream // import the WebSocket library

let sampleRate = 16000
let bitsPerSample = 16
let channelCount = 1

// Request access to the microphone
let session = AVAudioSession.sharedInstance()
session.requestRecordPermission { granted in
    if granted {
        do {
            let context = try AVAudioContext()
            let input = context.makeNode(ofType: .input)

            let settings = [
                AVFormatIDKey: kAudioFormatLinearPCM,
                AVSampleRateKey: sampleRate,
                AVNumberOfChannelsKey: channelCount,
                AVLinearPCMBitDepthKey: bitsPerSample,
                AVLinearPCMIsBigEndianKey: false,
                AVLinearPCMIsFloatKey: false
            ]
            input.installTap(onBus: 0, bufferSize: 4096, format: AVAudioFormat(settings: settings)!) { buffer, time in
                let samples = buffer.int16ChannelData![0]
                var output = [Int16]()
                for i in 0..= chunkSize {
                    let chunk = Array(output.prefix(chunkSize))
                    let data = Data(bytes: chunk, count: chunk.count * MemoryLayout.stride)
                    let buffer = data.withUnsafeBytes { buffer in
                        return UnsafeMutableRawPointer(mutating: buffer.baseAddress!).assumingMemoryBound(to: UInt8.self)
                    }

                    // Send chunk to the WebSocket server
                    socket.write(data: buffer, completion: nil)
                }
            }

            try session.setActive(true)
            try context.startRendering()
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
}

// Connect to a WebSocket
let socket = WebSocket(request: URLRequest(url: URL(string: "wss://verbumapi.onemeta.ai:3001/ws/{your-verbum-token}")!))
socket.onConnect = {
    // set language to spanish Argentina
    let dataToSend = """
        {
          "speechLanguage": "es-AR"
        }
        """
    socket.write(string: dataToSend)
    // Start sending audio data to the server
    let intervalId = Timer.scheduledTimer(withTimeInterval: 0.02, repeats: true) { _ in
        // the onaudioprocess event is simulated here by the Timer
    }

    socket.onData = { data in
        // Get data after receiving from WebSocket
        let message = String(data: data, encoding: .utf8)!
        print("Data after receiving: ", message)
    }

    // Stop sending audio data and close the WebSocket after 10 seconds
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        intervalId.invalidate()
        socket.disconnect()
        do {
            try AVAudioSession.sharedInstance().setActive(false)
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
}

socket.connect()
                              
                            
                        

                            
import asyncio
import websockets
import pyaudio
import struct

# Audio config
SAMPLE_RATE = 16000
BIT_DEPTH = 16
CHANNELS = 1
CHUNK_SIZE = 4096

# Connect to WebSocket
async with websockets.connect('wss://verbumapi.onemeta.ai:3001/ws/{your-verbum-token}') as websocket:
    # Set speech language to Spanish Argentina
    speech_language = {'speechLanguage': 'es-AR'}
    await websocket.send(str(speech_language))

    # Setup audio stream
    audio = pyaudio.PyAudio()
    stream = audio.open(format=audio.get_format_from_width(BIT_DEPTH // 8),
                        channels=CHANNELS,
                        rate=SAMPLE_RATE,
                        input=True,
                        frames_per_buffer=CHUNK_SIZE)

    # Read audio stream and send to WebSocket
    while True:
        try:
            data = stream.read(CHUNK_SIZE)
            if len(data) == CHUNK_SIZE * 2:
                # Encode chunk as a little-endian, 16-bit, signed integer array
                buffer = struct.pack(f"<{CHUNK_SIZE // 2}h", *struct.unpack(f"{CHUNK_SIZE // 2}h", data))

                # Send chunk to the WebSocket server
                await websocket.send(buffer)
        except KeyboardInterrupt:
            # Stop sending audio data and close the WebSocket
            stream.stop_stream()
            stream.close()
            audio.terminate()
            await websocket.close()
            break

                              
                            
                        

                            
using System;
using System.IO;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NAudio.Wave;

class Program
{
    static async Task Main(string[] args)
    {
        const int SampleRate = 16000;
        const int BitsPerSample = 16;
        const int ChannelCount = 1;
        const int ChunkSize = 4096;

        // Request access to the microphone
        var waveInEvent = new WaveInEvent
        {
            WaveFormat = new WaveFormat(SampleRate, BitsPerSample, ChannelCount),
            BufferMilliseconds = (int)(ChunkSize * 1000.0 / (SampleRate * BitsPerSample / 8.0)),
            NumberOfBuffers = 3,
        };

        var samples = new byte[ChunkSize];
        waveInEvent.DataAvailable += (sender, eventArgs) =>
        {
            var buffer = new byte[eventArgs.BytesRecorded];
            Buffer.BlockCopy(eventArgs.Buffer, 0, buffer, 0, eventArgs.BytesRecorded);
            for (var i = 0; i < buffer.Length; i += 2)
            {
                var sample = BitConverter.ToInt16(buffer, i);
                samples[i / 2] = (byte)(sample & 0xFF);
                samples[i / 2 + 1] = (byte)(sample >> 8);
            }
        };

        waveInEvent.StartRecording();

        // Connect to a WebSocket
        var webSocket = new ClientWebSocket();
        await webSocket.ConnectAsync(new Uri("wss://verbumapi.onemeta.ai:3001/ws/{your-verbum-token}"), CancellationToken.None);

        // Set language to Spanish Argentina
        var language = new { speechLanguage = "es-AR" };
        await SendWebSocketMessage(webSocket, language);

        // Start sending audio data to the server
        var sendInterval = TimeSpan.FromMilliseconds(20);
        while (webSocket.State == WebSocketState.Open)
        {
            await Task.Delay(sendInterval);

            var chunk = samples[..ChunkSize];
            var messageBytes = new byte[ChunkSize * 2];
            Buffer.BlockCopy(chunk, 0, messageBytes, 0, ChunkSize);
            for (var i = 0; i < ChunkSize * 2; i += 2)
            {
                var sample = BitConverter.ToInt16(messageBytes, i);
                messageBytes[i] = (byte)(sample & 0xFF);
                messageBytes[i + 1] = (byte)(sample >> 8);
            }

            await SendWebSocketMessage(webSocket, messageBytes);
        }

        waveInEvent.StopRecording();
    }

    static async Task SendWebSocketMessage(ClientWebSocket webSocket, object message)
    {
        var messageString = JsonSerializer.Serialize(message);
        var messageBytes = Encoding.UTF8.GetBytes(messageString);
        await webSocket.SendAsync(new ArraySegment(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None);
    }

    static async Task SendWebSocketMessage(ClientWebSocket webSocket, byte[] message)
    {
        await webSocket.SendAsync(new ArraySegment(message), WebSocketMessageType.Binary, true, CancellationToken.None);
    }
}