curl -X POST https://api.kallglot.com/v1/sessions \
  -H "Authorization: Bearer sk_live_your_api_key" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"mode": "bidirectional_translation"}'

curl -X POST https://api.kallglot.com/v1/sessions \
  -H "Authorization: Bearer sk_live_your_api_key" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "mode": "bidirectional_translation",
    "source_language": "de",
    "target_language": "en",
    "routing": {
      "phone_number": "+14155551234"
    }
  }'

import os
import uuid
import requests

API_KEY = os.environ.get('KALLGLOT_API_KEY')

response = requests.post(
    'https://api.kallglot.com/v1/sessions',
    headers={
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json',
        'Idempotency-Key': str(uuid.uuid4())
    },
    json={
        'mode': 'bidirectional_translation',
        # Languages optional - omit for auto-detection
        'source_language': 'de',
        'target_language': 'en'
    }
)

if response.status_code == 201:
    session = response.json()
    print(f"Session ID: {session['id']}")
    print(f"WebSocket URL: {session['stream']['url']}")
    print(f"Token: {session['stream']['token']}")
else:
    error = response.json()
    print(f"Error: {error['error']['message']}")

const API_KEY = process.env.KALLGLOT_API_KEY;

const response = await fetch('https://api.kallglot.com/v1/sessions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
    'Idempotency-Key': crypto.randomUUID()
  },
  body: JSON.stringify({
    mode: 'bidirectional_translation',
    // Languages optional - omit for auto-detection
    source_language: 'de',
    target_language: 'en'
  })
});

const data = await response.json();

if (response.ok) {
  console.log('Session ID:', data.id);
  console.log('WebSocket URL:', data.stream.url);
  console.log('Token:', data.stream.token);
} else {
  console.error('Error:', data.error.message);
}

require 'net/http'
require 'json'
require 'securerandom'

uri = URI('https://api.kallglot.com/v1/sessions')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = "Bearer #{ENV['KALLGLOT_API_KEY']}"
request['Content-Type'] = 'application/json'
request['Idempotency-Key'] = SecureRandom.uuid
request.body = {
  mode: 'bidirectional_translation',
  source_language: 'de',
  target_language: 'en'
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
session = JSON.parse(response.body)
puts session['stream']['url']

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"

    "github.com/google/uuid"
)

func main() {
    payload := map[string]string{
        "mode": "bidirectional_translation",
        // Languages optional - omit for auto-detection
        "source_language": "de",
        "target_language": "en",
    }
    body, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://api.kallglot.com/v1/sessions", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("KALLGLOT_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Idempotency-Key", uuid.NewString())

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)

    if resp.StatusCode == 201 {
        stream := result["stream"].(map[string]any)
        fmt.Printf("Session ID: %s\n", result["id"])
        fmt.Printf("WebSocket URL: %s\n", stream["url"])
    } else {
        errObj := result["error"].(map[string]any)
        fmt.Printf("Error: %s\n", errObj["message"])
    }
}

{
  "id": "sess_01HXYZ123456789",
  "object": "session",
  "status": "created",
  "mode": "bidirectional_translation",
  "provider": "twilio",
  "phone_number": "+14155551234",
  "source_language": null,
  "target_language": null,
  "stream": {
    "url": "wss://api.kallglot.com/v1/sessions/sess_01HXYZ123456789/connect",
    "token": "kst_live_xxxxxxxxxxxxxxxx",
    "expires_at": "2026-03-26T12:00:00Z"
  },
  "recording": {
    "enabled": false
  },
  "metadata": null,
  "created_at": "2026-03-26T11:00:00Z"
}

{
  "id": "sess_01HXYZ123456789",
  "object": "session",
  "status": "created",
  "mode": "bidirectional_translation",
  "provider": "twilio",
  "phone_number": "+14155551234",
  "source_language": "de",
  "target_language": "en",
  "stream": {
    "url": "wss://api.kallglot.com/v1/sessions/sess_01HXYZ123456789/connect",
    "token": "kst_live_xxxxxxxxxxxxxxxx",
    "expires_at": "2026-03-26T12:00:00Z"
  },
  "recording": {
    "enabled": false
  },
  "metadata": null,
  "created_at": "2026-03-26T11:00:00Z"
}

{
  "error": {
    "code": "api_key_invalid",
    "message": "Invalid API key",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": "insufficient_api_credits",
    "message": "API credits exhausted. Purchase more credits to continue.",
    "type": "payment_error"
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "source_language must be a valid ISO 639-1 code",
    "type": "validation_error",
    "param": "source_language"
  }
}