StreamVault API

curl BASE_URL/api/videos \
  -H "Authorization: Bearer sv_live_TU_KEY" \
  -H "X-Workspace-Id: TU_WORKSPACE_ID"

// HTTP 404
{
  "error": "Video no encontrado",
  "status": 404
}

curl -X POST BASE_URL/api/upload \
  -H "Authorization: Bearer sv_live_KEY" \
  -H "X-Workspace-Id: WS_ID" \
  -F "file=@video.mp4" \
  -F "title=Demo" \
  -F "visibility=public"

const form = new FormData();
form.append('file', fileInput.files[0]);
form.append('title', 'Demo');

const res = await fetch('BASE_URL/api/upload', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sv_live_KEY',
    'X-Workspace-Id': 'WS_ID'
  },
  body: form
});
const video = await res.json();

{
  "id": "abc123",
  "title": "Demo",
  "status": "processing",
  "m3u8Url": "https://..."
}

curl -X POST BASE_URL/api/import \
  -H "Authorization: Bearer sv_live_KEY" \
  -H "X-Workspace-Id: WS_ID" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://ejemplo.com/v.mp4"}'

curl "BASE_URL/api/videos?limit=10&sort=newest" \
  -H "Authorization: Bearer sv_live_KEY" \
  -H "X-Workspace-Id: WS_ID"

curl -X POST BASE_URL/api/apikeys \
  -H "Authorization: Bearer TU_JWT" \
  -H "X-Workspace-Id: WS_ID" \
  -H "Content-Type: application/json" \
  -d '{"name":"CI/CD","scopes":["uploads:write","videos:read"]}'

{
  "status": "ok",
  "uptime": 86400,
  "database": "connected",
  "storage": "connected",
  "queue": "connected"
}

// Obtener todos los videos con paginación automática
async function getAllVideos() {
  let cursor = null;
  const allVideos = [];

  do {
    const url = `BASE_URL/api/videos?limit=50`
      + (cursor ? `&cursor=${cursor}` : '');

    const res = await fetch(url, {
      headers: { 'Authorization': 'Bearer sv_live_KEY',
                 'X-Workspace-Id': 'WS_ID' }
    });
    const data = await res.json();

    allVideos.push(...data.videos);
    cursor = data.nextCursor;
  } while (cursor);

  return allVideos;
}

{
  "videos": [ ... ],
  "nextCursor": "eyJpZCI6MTIzfQ==",
  "hasMore": true,
  "total": 847
}

HTTP/1.1 200 OK
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 87
X-RateLimit-Reset: 1716000060

# Cuando se excede:
HTTP/1.1 429 Too Many Requests
Retry-After: 43
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0

async function fetchWithRetry(url, opts, retries = 3) {
  const res = await fetch(url, opts);

  if (res.status === 429 && retries > 0) {
    const wait = (res.headers.get('Retry-After') || 5) * 1000;
    await new Promise(r => setTimeout(r, wait));
    return fetchWithRetry(url, opts, retries - 1);
  }

  return res;
}

{
  "event": "video.ready",
  "timestamp": 1716000000,
  "workspaceId": "ws_abc123",
  "data": {
    "id": "vid_xyz",
    "title": "Mi Video",
    "duration": 125.4,
    "qualities": ["360p", "720p", "1080p"],
    "m3u8Url": "https://cdn.../master.m3u8",
    "thumbnailUrl": "https://cdn.../thumb.jpg"
  }
}

{
  "event": "transcription.complete",
  "timestamp": 1716000060,
  "workspaceId": "ws_abc123",
  "data": {
    "videoId": "vid_xyz",
    "language": "es",
    "duration": 125.4,
    "segments": 42,
    "vttUrl": "https://.../subtitles.vtt"
  }
}

{
  "event": "video.failed",
  "timestamp": 1716000030,
  "workspaceId": "ws_abc123",
  "data": {
    "id": "vid_xyz",
    "title": "Mi Video",
    "error": "Codec no soportado"
  }
}

const crypto = require('crypto');

function verifyWebhook(rawBody, signature, secret) {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature), Buffer.from(expected)
  );
}

// lib/streamvault.js
class StreamVault {
  constructor(apiKey, workspaceId, base = 'BASE_URL') {
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'X-Workspace-Id': workspaceId,
      'Content-Type': 'application/json'
    };
    this.base = base;
  }

  async req(method, path, body) {
    const res = await fetch(this.base + path, {
      method, headers: this.headers,
      body: body ? JSON.stringify(body) : undefined
    });
    if (!res.ok) throw await res.json();
    return res.status === 204 ? null : res.json();
  }

  listVideos(params = {}) {
    const q = new URLSearchParams(params).toString();
    return this.req('GET', `/api/videos?${q}`);
  }
  getVideo(id) { return this.req('GET', `/api/videos/${id}`); }
  updateVideo(id, data) { return this.req('PATCH', `/api/videos/${id}`, data); }
  deleteVideo(id) { return this.req('DELETE', `/api/videos/${id}`); }
  importVideo(url, title) { return this.req('POST', '/api/import', {url, title}); }
  listFolders() { return this.req('GET', '/api/folders'); }
  createWebhook(url, events) { return this.req('POST', '/api/webhooks', {url, events}); }
}

module.exports = StreamVault;

// Uso:
// const sv = new StreamVault('sv_live_KEY', 'ws_ID');
// const { videos } = await sv.listVideos({ limit: 10 });

# lib/streamvault.py
import requests

class StreamVault:
    def __init__(self, api_key, workspace_id,
                 base="BASE_URL"):
        self.base = base
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "X-Workspace-Id": workspace_id,
            "Content-Type": "application/json"
        }

    def req(self, method, path, body=None):
        r = requests.request(
            method, self.base + path,
            headers=self.headers, json=body
        )
        r.raise_for_status()
        return r.json() if r.text else None

    def list_videos(self, **kw):
        return self.req("GET", "/api/videos")
    def get_video(self, id):
        return self.req("GET", f"/api/videos/{id}")
    def delete_video(self, id):
        return self.req("DELETE", f"/api/videos/{id}")
    def import_video(self, url, title=None):
        return self.req("POST", "/api/import",
                        {"url": url, "title": title})

# sv = StreamVault("sv_live_KEY", "ws_ID")
# data = sv.list_videos()