iPipe Developer Platform

npm install @ipipe/web-sdk @ipipe/server-sdk

import { iPipe } from "@ipipe/web-sdk";

// 1. Create client instance
const client = iPipe.createClient({ mode: "rtc", codec: "vp8" });

// 2. Listen to remote participant streams
client.on("user-published", async (user, mediaType) => {
  const remoteTrack = await client.subscribe(user, mediaType);
  if (mediaType === "video") {
    remoteTrack.play("remote-video-container");
  } else {
    remoteTrack.play();
  }
});

// 3. Create local camera & microphone tracks
const localAudio = await iPipe.createMicrophoneAudioTrack();
const localVideo = await iPipe.createCameraVideoTrack();
localVideo.play("local-video-container");

// 4. Join channel and publish local streams
await client.join("rtc_cloud_demo_app_prod_001", "room_alpha", token, "user_101");
await client.publish([localAudio, localVideo]);

const client = iPipe.createClient({
  mode: "rtc",       // "rtc" (one-to-one or group) | "live" (interactive broadcast)
  codec: "vp8",      // "vp8" | "h264" | "vp9"
  serverUrl: "ws://localhost:8088/ws" // Optional custom signaling endpoint
});

// Create local tracks
const micTrack = await iPipe.createMicrophoneAudioTrack({ AEC: true, ANS: true });
const camTrack = await iPipe.createCameraVideoTrack({ encoderConfig: "720p_2" });

// Render camera in DOM container
camTrack.play("local-camera-wrapper", { fit: "cover", mirror: true });

// Toggle mute state dynamically on button click
let isMuted = false;
document.getElementById("btnMute").onclick = async () => {
  isMuted = !isMuted;
  await micTrack.setMuted(isMuted);
  console.log("Mic Muted:", micTrack.isMuted());
};

// Clean up tracks when session ends
function cleanup() {
  camTrack.close();
  micTrack.close();
}

// 1. Create WebRTC Client in Audio-Only Mode
const audioClient = iPipe.createClient({ mode: "rtc", codec: "opus" });

// 2. Capture Studio Microphone with DSP Filters (AEC, ANS, AGC)
const micTrack = await iPipe.createMicrophoneAudioTrack({
  AEC: true, // Acoustic Echo Cancellation
  ANS: true, // Active Noise Suppression
  AGC: true  // Automatic Gain Control
});

// 3. Listen to remote participants and play incoming audio
audioClient.on("user-published", async (user, mediaType) => {
  if (mediaType === "audio") {
    const remoteAudio = await audioClient.subscribe(user, "audio");
    remoteAudio.play(); // Direct speakerphone playback
  }
});

// 4. Voice Activity Detection (VAD) Spectrum Volume Indicator
setInterval(() => {
  const volume = micTrack.getVolumeLevel(); // 0 to 100
  if (volume > 20) {
    console.log("Speaking active! Volume level:", volume);
  }
}, 100);

// 5. Join Room and Publish Audio Stream
await audioClient.join("app_id", "voice_room_101", token, "user_42");
await audioClient.publish([micTrack]);

const client = iPipe.createClient({ mode: "rtc" });

// Handle remote streams
client.on("user-published", async (user, mediaType) => {
  const remoteTrack = await client.subscribe(user, mediaType);
  if (mediaType === "video") {
    remoteTrack.play(`remote-player-${user.uid}`);
  } else {
    remoteTrack.play();
  }
});

// Remove UI when remote peer leaves
client.on("user-left", (user, reason) => {
  console.log(`User ${user.uid} left channel. Reason:`, reason);
  const container = document.getElementById(`remote-player-${user.uid}`);
  if (container) container.remove();
});

// Telemetry & Network Health monitoring
client.on("network-quality", ({ uplinkNetworkQuality, stats }) => {
  console.log(`RTT: ${stats.rttMs}ms, Bitrate: ${stats.bitrateKbps}kbps, Quality: ${uplinkNetworkQuality}`);
});

// Proactive Token Refresh
client.on("token-privilege-will-expire", async () => {
  const res = await fetch("/api/v1/tokens/rtc", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ channel: "room_alpha" })
  });
  const { token: newToken } = await res.json();
  await client.renewToken(newToken);
  console.log("iPipe Token renewed successfully.");
});

// 1. Populate Camera Dropdown
const cameras = await iPipe.getCameras();
const camSelect = document.getElementById("cameraSelect");

cameras.forEach(cam => {
  const opt = document.createElement("option");
  opt.value = cam.deviceId;
  opt.text = cam.label || `Camera (${cam.deviceId.slice(0, 8)})`;
  camSelect.appendChild(opt);
});

// 2. Switch camera dynamically without dropping call
camSelect.onchange = async () => {
  const newDeviceId = camSelect.value;
  const newCamTrack = await iPipe.createCameraVideoTrack({
    cameraId: newDeviceId,
    encoderConfig: "720p_2"
  });
  await client.unpublish(currentCamTrack);
  currentCamTrack.close();
  currentCamTrack = newCamTrack;
  currentCamTrack.play("local-video-container");
  await client.publish(currentCamTrack);
};

const { IPipeTokenBuilder, Role } = require('@ipipe/server-sdk');

const appId = "rtc_cloud_demo_app_prod_001";
const appCertificate = "8f93a1c5d0e24177b94101e4a6789f10";
const channelName = "room_alpha";
const uid = "user_101";
const role = Role.PUBLISHER; // PUBLISHER | SUBSCRIBER | ADMIN
const privilegeExpiredTs = Math.floor(Date.now() / 1000) + 3600; // 1 hour

const token = IPipeTokenBuilder.buildTokenWithUid(
  appId, 
  appCertificate, 
  channelName, 
  uid, 
  role, 
  privilegeExpiredTs
);
console.log("Signed Token:", token); // Starts with IPIPE007...

curl http://localhost:8088/api/v1/health

const crypto = require('crypto');

function verifyWebhook(req, webhookSecret) {
  const sigHeader = req.headers['x-ipipe-signature'] || req.headers['x-rtc-signature'];
  const timestamp = req.headers['x-ipipe-timestamp'] || req.headers['x-rtc-timestamp'];
  const expectedSig = crypto.createHmac('sha256', webhookSecret)
    .update(`${timestamp}.${JSON.stringify(req.body)}`)
    .digest('hex');
  return sigHeader && sigHeader.includes(expectedSig);
}