interface TurnCredentials {
  username: number
  password: string
  ttl: number
  uris: string[]
}

const credentials: TurnCredentials = await $fetch('/api/turn-credentials')

import requests

BASE_URL = "$BASE_URL"
session = requests.Session()
# First authenticate to get session cookie
session.post(f"$BASE_URL/auth/login", json={"email": "...", "password": "..."})

response = session.get(f"$BASE_URL/api/turn-credentials")
credentials = response.json()

const baseURL = "$BASE_URL"

// Use http.Client with CookieJar for session management
jar, _ := cookiejar.New(nil)
client := &http.Client{Jar: jar}

// First authenticate to get session cookie
// ...

resp, _ := client.Get(baseURL + "/api/turn-credentials")
defer resp.Body.Close()

var credentials struct {
    Username int      `json:"username"`
    Password string   `json:"password"`
    TTL      int      `json:"ttl"`
    URIs     []string `json:"uris"`
}
json.NewDecoder(resp.Body).Decode(&credentials)

use reqwest::Client;
use serde::Deserialize;

#[derive(Deserialize)]
struct TurnCredentials {
    username: i64,
    password: String,
    ttl: i32,
    uris: Vec<String>,
}

// Client with cookie store for session management
let client = Client::builder()
    .cookie_store(true)
    .build()?;

const BASE_URL: &str = "$BASE_URL";

// First authenticate to get session cookie
// ...

let credentials: TurnCredentials = client
    .get(format!("{}/api/turn-credentials", BASE_URL))
    .send()
    .await?
    .json()
    .await?;

const credentials = await $fetch('/api/turn-credentials')

const peerConnection = new RTCPeerConnection({
  iceServers: [
    { urls: 'stun:stun.cloudflare.com:3478' },
    {
      urls: 'turns:turn.cliqer.io:443',
      username: credentials.username.toString(),
      credential: credentials.password
    }
  ]
})

peerConnection.onicecandidate = (event) => {
  if (event.candidate) {
    ws.send(JSON.stringify({
      type: 'webrtcSignal',
      payload: {
        room: roomId,
        signal: { type: 'candidate', candidate: event.candidate }
      }
    }))
  }
}

# Python WebRTC using aiortc
import asyncio
from aiortc import RTCPeerConnection, RTCConfiguration, RTCIceServer
import requests

BASE_URL = "$BASE_URL"
session = requests.Session()
# Authenticate first (session cookie required)
credentials = session.get(f"$BASE_URL/api/turn-credentials").json()

config = RTCConfiguration(iceServers=[
    RTCIceServer(urls="stun:stun.cloudflare.com:3478"),
    RTCIceServer(
        urls="turns:turn.cliqer.io:443",
        username=str(credentials["username"]),
        credential=credentials["password"]
    )
])

pc = RTCPeerConnection(configuration=config)

// Go WebRTC using pion/webrtc
import "github.com/pion/webrtc/v3"

config := webrtc.Configuration{
    ICEServers: []webrtc.ICEServer{
        {URLs: []string{"stun:stun.cloudflare.com:3478"}},
        {
            URLs:       []string{"turns:turn.cliqer.io:443"},
            Username:   fmt.Sprintf("%d", credentials.Username),
            Credential: credentials.Password,
        },
    },
}

peerConnection, _ := webrtc.NewPeerConnection(config)

<?php
// PHP typically doesn't run WebRTC directly
// Fetch credentials server-side with authenticated session and pass to frontend
// Note: Requires valid session cookie from authenticated user

// Return to frontend for browser WebRTC
header('Content-Type: application/json');
echo json_encode([
    'iceServers' => [
        ['urls' => 'stun:stun.cloudflare.com:3478'],
        [
            'urls' => 'turns:turn.cliqer.io:443',
            'username' => (string)$credentials['username'],
            'credential' => $credentials['password']
        ]
    ]
]);

// Rust WebRTC using webrtc-rs
use webrtc::api::APIBuilder;
use webrtc::ice_transport::ice_server::RTCIceServer;
use webrtc::peer_connection::configuration::RTCConfiguration;

let config = RTCConfiguration {
    ice_servers: vec![
        RTCIceServer {
            urls: vec!["stun:stun.cloudflare.com:3478".to_string()],
            ..Default::default()
        },
        RTCIceServer {
            urls: vec!["turns:turn.cliqer.io:443".to_string()],
            username: credentials.username.to_string(),
            credential: credentials.password.clone(),
            ..Default::default()
        },
    ],
    ..Default::default()
};

let api = APIBuilder::new().build();
let peer_connection = api.new_peer_connection(config).await?;

// Non-initiator signals ready
ws.send(JSON.stringify({
  event: 'message',
  payload: {
    type: 'webrtcSignal',
    payload: {
      room: 'ABC123',
      signal: { type: 'ready' }
    }
  }
}))

// Initiator sends offer
ws.send(JSON.stringify({
  event: 'message',
  payload: {
    type: 'webrtcSignal',
    payload: {
      room: 'ABC123',
      signal: {
        type: 'offer',
        sdp: peerConnection.localDescription?.sdp
      }
    }
  }
}))

// Handle incoming signals
ws.onmessage = (event) => {
  const msg = JSON.parse(event.data)
  if (msg.type === 'webrtcSignal') {
    const { signal, from } = msg.payload
    
    switch (signal.type) {
      case 'ready':
        // Create and send offer (if initiator)
        break
      case 'offer':
        await peerConnection.setRemoteDescription(signal)
        const answer = await peerConnection.createAnswer()
        await peerConnection.setLocalDescription(answer)
        // Send answer back
        break
      case 'answer':
        await peerConnection.setRemoteDescription(signal)
        break
      case 'candidate':
        await peerConnection.addIceCandidate(signal.candidate)
        break
    }
  }
}

import websocket
import json

WS_URL = "wss://v2.cliqer.io"  # wss:// version of BASE_URL
ws = websocket.WebSocket()
ws.connect(f"wss://v2.cliqer.io/ws")

# Non-initiator signals ready
ws.send(json.dumps({
    "event": "message",
    "payload": {
        "type": "webrtcSignal",
        "payload": {
            "room": "ABC123",
            "signal": {"type": "ready"}
        }
    }
}))

# Initiator sends offer
ws.send(json.dumps({
    "event": "message",
    "payload": {
        "type": "webrtcSignal",
        "payload": {
            "room": "ABC123",
            "signal": {"type": "offer", "sdp": local_description}
        }
    }
}))

import "github.com/gorilla/websocket"

const wsURL = "wss://v2.cliqer.io" // wss:// version of BASE_URL
conn, _, _ := websocket.DefaultDialer.Dial(wsURL + "/ws", nil)

// Non-initiator signals ready
conn.WriteJSON(map[string]interface{}{
    "event": "message",
    "payload": map[string]interface{}{
        "type": "webrtcSignal",
        "payload": map[string]interface{}{
            "room":   "ABC123",
            "signal": map[string]string{"type": "ready"},
        },
    },
})

// Initiator sends offer
conn.WriteJSON(map[string]interface{}{
    "event": "message",
    "payload": map[string]interface{}{
        "type": "webrtcSignal",
        "payload": map[string]interface{}{
            "room":   "ABC123",
            "signal": map[string]string{"type": "offer", "sdp": localSDP},
        },
    },
})

use tokio_tungstenite::connect_async;
use futures_util::SinkExt;
use serde_json::json;

const WS_URL: &str = "wss://v2.cliqer.io"; // wss:// version of BASE_URL
let (mut ws, _) = connect_async(format!("{}/ws", WS_URL)).await?;

// Non-initiator signals ready
ws.send(json!({
    "event": "message",
    "payload": {
        "type": "webrtcSignal",
        "payload": {
            "room": "ABC123",
            "signal": {"type": "ready"}
        }
    }
}).to_string().into()).await?;

// Initiator sends offer
ws.send(json!({
    "event": "message",
    "payload": {
        "type": "webrtcSignal",
        "payload": {
            "room": "ABC123",
            "signal": {"type": "offer", "sdp": local_sdp}
        }
    }
}).to_string().into()).await?;