PIPELINE

Ensure zero downtime with automatic failover to backup ingest servers. Critical for 24/7 broadcasts.

const stream = await wave.streams.create({
  title: 'Mission-Critical Broadcast',
  protocol: 'srt',
  failover: {
    enabled: true,
    backupUrl: 'srt://backup.wave.online:9000',
    switchoverTime: 3000, // ms
    autoReconnect: true,
    maxRetries: 5
  },
  monitoring: {
    healthCheckInterval: 5000,
    alertEmail: '[email protected]',
    alertOnFailover: true
  }
});

// Backup automatically takes over if primary fails
console.log('Primary:', stream.primaryUrl);
console.log('Backup:', stream.backupUrl);

Stream to YouTube, Facebook, Twitch, and your own platform simultaneously from a single source.

const stream = await wave.streams.create({
  title: 'Product Launch Event',
  protocol: 'rtmp',
  simulcast: {
    enabled: true,
    destinations: [
      {
        platform: 'youtube',
        streamKey: process.env.YOUTUBE_KEY,
        resolution: '1080p',
        bitrate: 6000
      },
      {
        platform: 'facebook',
        streamKey: process.env.FACEBOOK_KEY,
        resolution: '720p',
        bitrate: 4000
      },
      {
        platform: 'twitch',
        streamKey: process.env.TWITCH_KEY,
        lowLatency: true
      }
    ],
    perDestinationMetrics: true
  }
});

// Get status of each destination
const status = await stream.getSimulcastStatus();
console.log('YouTube:', status.youtube.viewers);

Define custom quality ladders optimized for your content type and audience devices.

const stream = await wave.streams.create({
  title: 'Sports Broadcast',
  transcoding: {
    codec: 'h265',
    profiles: [
      {
        name: 'ultra_hd',
        resolution: '3840x2160',
        fps: 60,
        bitrate: 15000,
        hardwareAcceleration: true
      },
      {
        name: 'full_hd_60',
        resolution: '1920x1080',
        fps: 60,
        bitrate: 8000
      },
      {
        name: 'hd',
        resolution: '1280x720',
        fps: 30,
        bitrate: 3000
      }
    ],
    adaptiveBitrate: true
  }
});

Select specific edge locations for optimal delivery to your target audience regions.

const stream = await wave.streams.create({
  title: 'Regional Event',
  cdn: {
    preferredRegions: ['us-east', 'us-west', 'eu-west'],
    fallbackRegions: ['ap-southeast', 'eu-central'],
    geolocation: {
      restrictTo: ['US', 'CA', 'GB', 'DE', 'FR'],
      blockFrom: []
    },
    caching: {
      ttl: 3600,
      preload: true,
      purgeonUpdate: true
    }
  },
  routing: {
    strategy: 'lowest-latency',
    healthCheckInterval: 10000
  }
});

console.log('Active regions:', stream.cdn.activeRegions);

Protect premium content with Widevine, FairPlay, and PlayReady DRM.

const stream = await wave.streams.create({
  title: 'Premium Content',
  drm: {
    enabled: true,
    providers: ['widevine', 'fairplay', 'playready'],
    encryption: 'aes-256-ctr',
    keyRotation: {
      enabled: true,
      intervalMinutes: 60
    },
    tokenAuth: {
      required: true,
      expirationMinutes: 120,
      singleUse: false
    }
  },
  watermarking: {
    enabled: true,
    visibleText: 'CONFIDENTIAL',
    forensic: true // Invisible tracking
  }
});

// Generate viewer token
const token = await stream.generateViewerToken({
  userId: 'user-123',
  maxDevices: 2
});

Switch between multiple NDI camera sources in real-time during live broadcasts.

const production = await wave.productions.create({
  title: 'Live Concert',
  sources: [
    { name: 'Camera 1', protocol: 'ndi', url: 'ndi://cam1' },
    { name: 'Camera 2', protocol: 'ndi', url: 'ndi://cam2' },
    { name: 'Camera 3', protocol: 'ndi', url: 'ndi://cam3' },
    { name: 'Graphics', protocol: 'ndi', url: 'ndi://gfx' }
  ],
  output: {
    protocol: 'srt',
    quality: '1080p60'
  }
});

// Switch cameras
await production.switchSource('Camera 2');

// Picture-in-picture
await production.enablePiP({
  main: 'Camera 1',
  pip: 'Camera 3',
  position: 'bottom-right'
});

Receive real-time notifications for viewer milestones and stream events.

const stream = await wave.streams.create({
  title: 'Event Stream',
  webhooks: {
    url: 'https://api.company.com/webhooks/stream',
    secret: process.env.WEBHOOK_SECRET,
    events: [
      'stream.started',
      'stream.ended',
      'viewers.milestone', // 1K, 10K, 100K, 1M
      'quality.degraded',
      'connection.lost'
    ],
    retryPolicy: {
      maxAttempts: 3,
      backoffMs: 1000
    }
  }
});

// Webhook payload example:
// {
//   event: 'viewers.milestone',
//   streamId: 'str_123',
//   milestone: 10000,
//   timestamp: '2024-11-17T...'
// }

Automatically adjust bitrate and quality based on network conditions.

const stream = await wave.streams.create({
  title: 'Adaptive Stream',
  quality: {
    autoTune: true,
    target: {
      latency: 100, // ms
      bufferHealth: 0.95,
      packetLoss: 0.001
    },
    adjustmentStrategy: 'aggressive',
    metrics: {
      measureInterval: 5000,
      adaptInterval: 2000
    }
  },
  viewer: {
    autoQualitySwitch: true,
    switchThreshold: {
      up: 2000, // Upgrade if >2s buffer
      down: 500  // Downgrade if <500ms buffer
    }
  }
});

// Monitor adjustments
stream.on('quality:adjusted', (data) => {
  console.log('New bitrate:', data.bitrate);
});

Record to multiple regions simultaneously for disaster recovery.

const stream = await wave.streams.create({
  title: 'Critical Event',
  recording: {
    enabled: true,
    redundancy: {
      enabled: true,
      regions: ['us-east-1', 'eu-west-1', 'ap-southeast-1'],
      verifyIntegrity: true
    },
    format: 'mp4',
    quality: 'source', // Record at source quality
    retention: {
      days: 90,
      autoArchive: true,
      archiveClass: 'glacier'
    }
  },
  liveRewind: {
    enabled: true,
    windowMinutes: 120
  }
});

// Access recordings
const recordings = await stream.getRecordings();
console.log('Available in:', recordings.regions);

Production-grade error handling with automatic recovery and alerting.

try {
  const stream = await wave.streams.create({
    title: 'Production Stream',
    errorHandling: {
      autoRecover: true,
      maxRetries: 5,
      retryStrategy: 'exponential',
      fallbackProtocol: 'rtmp',
      alerting: {
        email: ['[email protected]'],
        sms: ['+1234567890'],
        slack: 'https://hooks.slack.com/...'
      }
    }
  });

  // Event monitoring
  stream.on('error', async (error) => {
    logger.error('Stream error:', error);

    if (error.recoverable) {
      await stream.recover();
    } else {
      await stream.switchToBackup();
      await notifyOpsTeam(error);
    }
  });

  stream.on('warning', (warning) => {
    // Handle degraded performance
    if (warning.type === 'high_latency') {
      stream.adjustQuality('lower');
    }
  });

} catch (error) {
  // Handle fatal errors
  console.error('Stream creation failed:', error);
  await fallbackToPreviousStream();
}

PIPELINE supports all major streaming protocols: RTMP, SRT, WebRTC, NDI, OMT, HLS, and DASH. RTMP is perfect for industry-standard ingest from tools like OBS Studio. SRT provides secure, low-latency transport with error correction (20-300ms). WebRTC enables browser-based streaming with 100-500ms latency. NDI offers broadcast-quality video over IP for production workflows. OMT (our proprietary protocol) delivers ultra-low latency under 16ms for real-time applications like gaming and interactive experiences.

Yes, PIPELINE's multi-destination streaming lets you broadcast to YouTube, Facebook Live, Twitch, and other platforms simultaneously from a single source. You can configure multiple RTMP outputs, each with custom encoding settings. This eliminates the need to run multiple encoders and significantly reduces bandwidth requirements. Professional and Enterprise plans support unlimited simultaneous destinations. Starter plans support up to 3 destinations.

PIPELINE supports up to 4K resolution (3840×2160) at 60fps with bitrates up to 50 Mbps. We support H.264, H.265 (HEVC), and AV1 codecs for optimal quality and bandwidth efficiency. Adaptive bitrate streaming automatically generates multiple quality levels (1080p, 720p, 480p, 360p) from your source, ensuring smooth playback for viewers on any device or connection speed. GPU-accelerated encoding handles high-quality streams efficiently.

Connecting OBS Studio is simple and takes less than 2 minutes:

1. Log into your WAVE dashboard and create a new stream
2. Copy your unique RTMP URL and Stream Key
3. In OBS, go to Settings → Stream
4. Select "Custom" as the service
5. Paste your RTMP URL in the Server field
6. Paste your Stream Key in the Stream Key field
7. Click OK and hit "Start Streaming" in OBS

Your stream will appear live in the WAVE dashboard within seconds. We recommend starting with 6000 Kbps bitrate for 1080p streams.

PIPELINE includes enterprise-grade reliability features to prevent stream interruptions. Automatic reconnection attempts to restore your stream within 3 seconds if the connection drops. Backup streaming lets you configure a secondary ingest server that takes over automatically if the primary fails. Our 99.99% uptime SLA is backed by redundant infrastructure across 200+ edge locations. Real-time health monitoring alerts you to potential issues before they impact viewers. Professional and Enterprise plans include multi-path streaming with automatic failover for mission-critical broadcasts.

Yes, PIPELINE automatically records all streams to VAULT for on-demand playback. Recordings are available within minutes of stream end and stored securely in the cloud. Live DVR lets viewers pause, rewind, and replay live streams in real-time. You can configure retention periods from 7 days to unlimited storage. Recordings support the same adaptive bitrate playback as live streams. Create highlight clips, generate thumbnails, and share recordings via embed codes or direct links. All recordings are delivered via our global CDN for fast, reliable playback worldwide.

PIPELINE provides comprehensive real-time monitoring through the PULSE dashboard. Track viewer count, bitrate, buffer health, dropped frames, and network conditions in real-time. Set up custom alerts via email, SMS, or webhooks for critical events like quality degradation or connection loss. Access detailed analytics including geographic distribution, device types, and viewer engagement patterns. Professional and Enterprise plans include advanced diagnostics, historical trending, and exportable reports. Our API provides programmatic access to all metrics for integration with your existing monitoring tools like Datadog, Grafana, or New Relic.

Each protocol is optimized for different use cases:

• RTMP: Industry standard for ingest (3-5s latency), works with all encoders like OBS Studio
• SRT: Low-latency (20-300ms) with error correction, ideal for unreliable networks
• WebRTC: Browser-native (100-500ms), best for interactive applications
• NDI: Broadcast-quality (<100ms) for production workflows with multiple cameras
• OMT: Ultra-low latency (<16ms), perfect for real-time gaming and esports
• HLS/DASH: Scalable delivery with adaptive bitrate, 3-30s latency for mass distribution

Choose based on your latency requirements, viewer devices, and network conditions. PIPELINE supports protocol switching without reconfiguration.

Yes, Enterprise plans support bring-your-own CDN (BYOC) integration. Connect your existing Cloudflare, Fastly, Akamai, or custom CDN infrastructure. PIPELINE can push streams to multiple CDN origins simultaneously for redundancy. You can also deploy WAVE edge nodes in your own data centers or colocation facilities for maximum control and compliance. Hybrid configurations let you use WAVE's global CDN for most viewers while routing specific regions through your infrastructure. Our engineering team assists with custom CDN integrations and performance optimization.

Absolutely. Define custom transcoding profiles with specific resolutions, bitrates, codecs, and frame rates. Add overlays, watermarks, and graphics during encoding. Inject pre-roll and mid-roll ads with frame-accurate timing. Apply real-time filters like color correction, brightness adjustment, and noise reduction. Professional plans support custom FFmpeg filters for advanced processing. Enterprise customers can deploy custom encoding pipelines using our SDK for specialized workflows like multi-language audio tracks, closed captions, or AI-powered content moderation. GPU-accelerated processing ensures real-time performance even with complex transformations.

PIPELINE's intelligent routing automatically detects CDN node failures and reroutes traffic to healthy edge locations within milliseconds. Our anycast network ensures viewers connect to the nearest working server with zero manual intervention. Multi-CDN failover is included in Professional and Enterprise plans, distributing load across multiple CDN providers for ultimate reliability. Real-time health checks run every 5 seconds to identify issues before they impact viewers. Historical uptime tracking and incident reports provide full transparency. Our 99.99% SLA includes financial credits if we fail to meet availability commitments.

Yes, PIPELINE includes advanced scheduling capabilities. Create streams days or weeks in advance with specific start and end times. Automatic stream activation ensures your broadcast begins exactly when planned, even if you're not online. Configure pre-stream countdown pages and holding screens with custom branding. Set up recurring streams for regular events like weekly shows or daily broadcasts. Scheduled streams automatically generate preview pages and embed codes for promotion. Post-stream actions like automatic recording, email notifications, and social media publishing can be configured per schedule. Calendar integration syncs with Google Calendar, Outlook, and other scheduling tools.