Documentation.

import asyncio, json, pyaudio, websockets

API_KEY = "vsip_YOUR_KEY_HERE"

async def main():
    uri = "wss://api.vsip.io/v1/stream"
    headers = {"Authorization": f"Bearer {API_KEY}"}

    async with websockets.connect(uri, additional_headers=headers) as ws:
        print(json.loads(await ws.recv()))  # session_start

        p = pyaudio.PyAudio()
        mic = p.open(format=pyaudio.paInt16, channels=1, rate=16000,
                     input=True, frames_per_buffer=1600)

        async def send_audio():
            while True:
                await ws.send(mic.read(1600, exception_on_overflow=False))
                await asyncio.sleep(0)

        asyncio.create_task(send_audio())

        async for raw in ws:
            event = json.loads(raw)
            if event["type"] in ("turn_start", "turn_end", "barge_in",
                                 "speaker_verification"):
                print(event)

asyncio.run(main())

Authorization: Bearer vsip_YOUR_API_KEY

wss://api.vsip.io/v1/stream?tick_ms=80&session_id=call-abc-123

pip install vsip-sdk              # typed client + VoiceSession
pip install "vsip-sdk[pipecat]"  # + drop-in Pipecat processor
# distribution is vsip-sdk; the import package is still 'vsip'

from vsip import VSIPClient, VoiceSession, Turn, int16_to_wav

client = VSIPClient(api_key="vsip_...", url="wss://api.vsip.io/v1/stream")

async def on_turn(turn: Turn):
    if not turn.should_respond:      # verified: not your enrolled user
        return
    text  = await my_stt(int16_to_wav(turn.audio))
    reply = await my_llm(text, interrupted=turn.interrupted_agent)
    await session.speak_gate()       # never talk over an open turn
    await client.agent_speaking()
    await my_tts_play(reply)         # stop this in on_barge_in
    await client.agent_idle()

session = VoiceSession(client, on_turn=on_turn,
                       on_barge_in=lambda e: my_tts_stop())

async with client:
    await session.start()
    async for frame in mic_frames():  # 16kHz mono int16 PCM
        await session.send_audio(frame)

from vsip import VSIPClient
from vsip.adapters.pipecat import VSIPProcessor

vsip = VSIPProcessor(VSIPClient(api_key="vsip_...", url="wss://.../v1/stream"))

pipeline = Pipeline([
    transport.input(),
    stt,
    vsip,              # ← identity-gated barge-in + verification gating
    context_aggregator,
    llm,
    tts,
    transport.output(),
])

from livekit.agents import AgentSession
from vsip import VSIPClient
from vsip.adapters.livekit import VSIPVAD

vsip_vad = VSIPVAD(VSIPClient(api_key="vsip_...", url="wss://.../v1/stream"))

session = AgentSession(vad=vsip_vad, stt=..., llm=..., tts=...)

from vsip import VSIPClient
from vsip.adapters.twilio import TwilioBridge

client = VSIPClient(api_key="vsip_...", url="wss://.../v1/stream",
                    audio_format="mulaw8k")
bridge = TwilioBridge(client, on_turn_end=..., on_verification=...)
await bridge.run(ws.iter_text(), send=ws.send_text)  # FastAPI/Starlette WS

import { VSIPClient, VoiceSession, type Turn } from "vsip-sdk";

const client = new VSIPClient({ apiKey: "vsip_...", url: "wss://.../v1/stream" });
const session = new VoiceSession(client, {
  onTurn: (t: Turn) => { if (t.shouldRespond) respond(t.audio); },
  onBargeIn: () => myTts.stop(),
});
await client.connect();
session.start();

from vsip import ProfilesClient

profiles = ProfilesClient(api_key="vsip_...", base_url="https://api.vsip.io")

# enroll (>=3s clean speech; wav/mp3/int16/float32/mulaw8k)
p = await profiles.enroll("alice", wav_bytes, audio_format="wav",
                          consent_obtained=True, retention_days=365)

# 1:1 verify
r = await profiles.verify(p["profile_id"], sample_bytes, audio_format="wav")
# -> {"match": true, "score": 0.82, "threshold": 0.75, ...}

# 1:N identify
who = await profiles.identify(sample_bytes, audio_format="wav")