Livestreams

RTMP URL: rtmp://stream.frontrow.com/live
Stream Key: [Your unique stream key from dashboard]

# Full connection string format
rtmp://stream.frontrow.com/live/{stream_key}

# With custom parameters
rtmp://stream.frontrow.com/live/{stream_key}?backup=1&lowLatency=1

4K Ultra HD: 3840×2160 @ 30/60 fps
1440p: 2560×1440 @ 30/60 fps
1080p Full HD: 1920×1080 @ 30/60 fps
720p HD: 1280×720 @ 30/60 fps
480p SD: 854×480 @ 30 fps
360p: 640×360 @ 30 fps

4K @ 60fps: 20,000-40,000 kbps
4K @ 30fps: 13,000-25,000 kbps
1080p @ 60fps: 4,500-9,000 kbps
1080p @ 30fps: 3,000-6,000 kbps
720p @ 60fps: 2,500-5,000 kbps
720p @ 30fps: 1,500-4,000 kbps

Settings > Stream
Service: Custom
Server: rtmp://stream.frontrow.com/live
Stream Key: [Your key from FrontRow dashboard]

Settings > Output
Output Mode: Advanced
Encoder: x264 or NVIDIA NVENC
Rate Control: CBR
Bitrate: 6000 kbps (for 1080p 30fps)
Keyframe Interval: 2

Settings > Video
Base Resolution: 1920x1080
Output Resolution: 1920x1080
FPS: 30 or 60

// Stream analytics API response
{
  "renditions": [
    { "name": "source", "resolution": "1920x1080", "bitrate": 6000 },
    { "name": "high", "resolution": "1280x720", "bitrate": 3000 },
    { "name": "medium", "resolution": "854x480", "bitrate": 1500 },
    { "name": "low", "resolution": "640x360", "bitrate": 800 }
  ]
}

// API configuration
const streamConfig = {
  lowLatency: true,
  targetLatency: 3, // seconds
  bufferSize: 1 // seconds
}

# Primary stream
rtmp://stream.frontrow.com/live/{stream_key}

# Backup stream
rtmp://backup.stream.frontrow.com/live/{stream_key}?backup=1

POST /api/v1/streams/sessions
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "title": "My Live Stream",
  "description": "Stream description",
  "privacy": "public",
  "recordStream": true,
  "lowLatency": true
}

GET /api/v1/streams/sessions/{sessionId}/status
Authorization: Bearer YOUR_API_KEY

Response:
{
  "status": "live",
  "health": {
    "bitrate": 6245,
    "fps": 29.97,
    "keyframeInterval": 2.0,
    "droppedFrames": 0
  },
  "viewers": 1523,
  "duration": 3600
}

PATCH /api/v1/streams/sessions/{sessionId}
Authorization: Bearer YOUR_API_KEY

{
  "title": "Updated Title",
  "enableChat": false,
  "enableDonations": true
}

// Future WebRTC implementation
const stream = await navigator.mediaDevices.getUserMedia({
  video: { width: 1920, height: 1080, frameRate: 30 },
  audio: { echoCancellation: true, noiseSuppression: true }
})

const peer = new FrontRowWebRTCPeer({
  stream: stream,
  streamKey: 'your-stream-key'
})

await peer.startBroadcast()

// Connect to metrics WebSocket
const ws = new WebSocket('wss://metrics.frontrow.com/streams/{sessionId}')

ws.onmessage = (event) => {
  const metrics = JSON.parse(event.data)
  console.log('Bitrate:', metrics.bitrate)
  console.log('FPS:', metrics.fps)
  console.log('Dropped Frames:', metrics.droppedFrames)
}

North America: NYC, LAX, CHI, DAL, SEA
Europe: LON, FRA, AMS, MAD
Asia-Pacific: TOK, SIN, SYD, BOM
South America: SAO, GRU

# Test RTMP connectivity
ffmpeg -re -i test.mp4 -c copy -f flv rtmp://stream.frontrow.com/live/{key}

# Check latency to servers
ping stream.frontrow.com

# Trace route for network path
traceroute stream.frontrow.com

import requests
import time

class FrontRowStreamMonitor:
    def __init__(self, api_key, session_id):
        self.api_key = api_key
        self.session_id = session_id
        self.base_url = "https://api.frontrow.com/v1"
    
    def get_stream_health(self):
        headers = {"Authorization": f"Bearer {self.api_key}"}
        response = requests.get(
            f"{self.base_url}/streams/sessions/{self.session_id}/health",
            headers=headers
        )
        return response.json()
    
    def monitor_stream(self, interval=5):
        while True:
            health = self.get_stream_health()
            print(f"Bitrate: {health['bitrate']} kbps")
            print(f"FPS: {health['fps']}")
            print(f"Viewers: {health['viewers']}")
            time.sleep(interval)

const FrontRowStream = require('frontrow-sdk')

class StreamManager {
  constructor(apiKey, streamKey) {
    this.client = new FrontRowStream(apiKey)
    this.streamKey = streamKey
    this.reconnectAttempts = 0
  }

  async monitorConnection() {
    setInterval(async () => {
      const health = await this.client.getStreamHealth()
      
      if (health.status === 'disconnected') {
        await this.attemptReconnect()
      }
    }, 5000)
  }

  async attemptReconnect() {
    if (this.reconnectAttempts < 3) {
      console.log(`Attempting reconnect ${this.reconnectAttempts + 1}/3`)
      // Trigger encoder restart
      this.reconnectAttempts++
    } else {
      console.error('Max reconnection attempts reached')
      // Send alert notification
    }
  }
}