API Reference

"""
VIDing.AI — Complete upload → compress → download flow (Python)
pip install requests
"""
import requests, time, os

API_KEY = os.environ["VIDING_API_KEY"]
BASE    = "https://api.viding.ai"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# --- Option A: Single-file upload (under 100 MB) ---

def compress_simple(filepath, target_ratio=0.3):
    with open(filepath, "rb") as f:
        resp = requests.post(
            f"{BASE}/api/compress",
            headers=HEADERS,
            files={"video": f},
            data={"target_ratio": target_ratio},
        )
    resp.raise_for_status()
    return resp.json()

# --- Option B: Chunked upload for large files ---

def compress_large(filepath, preset="balanced"):
    file_size = os.path.getsize(filepath)
    filename  = os.path.basename(filepath)

    # Step 1: Initialize upload
    init = requests.post(f"{BASE}/api/v1/uploads/init", headers=HEADERS, json={
        "filename": filename,
        "mime_type": "video/mp4",
        "file_size": file_size,
    }).json()

    upload_id  = init["upload_id"]
    chunk_size = init["chunk_size"]
    chunk_urls = init["chunk_urls"]

    # Step 2: Upload chunks
    with open(filepath, "rb") as f:
        for i, url in enumerate(chunk_urls):
            chunk = f.read(chunk_size)
            requests.put(url, data=chunk,
                headers={"Content-Type": "application/octet-stream"})
            print(f"  Uploaded chunk {i+1}/{len(chunk_urls)}")

    # Step 3: Complete upload
    complete = requests.post(
        f"{BASE}/api/v1/uploads/{upload_id}/complete",
        headers=HEADERS,
    ).json()

    # Step 4: Create compression job
    job = requests.post(f"{BASE}/api/v1/jobs", headers=HEADERS, json={
        "file_id": complete["file_id"],
        "preset": preset,
    }).json()

    job_id = job["id"]
    print(f"Job created: {job_id}")

    # Step 5: Poll until complete
    while True:
        status = requests.get(
            f"{BASE}/api/v1/jobs/{job_id}", headers=HEADERS
        ).json()
        print(f"  Status: {status['status']} ({status.get('progress', 0)}%)")
        if status["status"] == "complete":
            break
        if status["status"] == "failed":
            raise Exception(f"Job failed: {status}")
        time.sleep(5)

    # Step 6: Download result
    dl = requests.get(
        f"{BASE}/api/v1/jobs/{job_id}/download", headers=HEADERS
    ).json()

    output_path = f"compressed_{filename}"
    with requests.get(dl["download_url"], stream=True) as r:
        with open(output_path, "wb") as f:
            for chunk in r.iter_content(chunk_size=8192):
                f.write(chunk)

    print(f"Downloaded: {output_path} ({dl['file_size']} bytes)")
    return dl

# Usage
compress_large("interview.mp4", preset="balanced")

/**
 * VIDing.AI — Complete upload → compress → download flow (Node.js)
 * npm install node-fetch
 */
import fs from "fs";
import fetch from "node-fetch";
import path from "path";

const API_KEY = process.env.VIDING_API_KEY;
const BASE    = "https://api.viding.ai";
const HEADERS = { "Authorization": `Bearer ${API_KEY}` };

async function compressVideo(filepath, preset = "balanced") {
  const fileSize = fs.statSync(filepath).size;
  const filename = path.basename(filepath);

  // Step 1: Initialize upload
  const init = await fetch(`${BASE}/api/v1/uploads/init`, {
    method: "POST",
    headers: { ...HEADERS, "Content-Type": "application/json" },
    body: JSON.stringify({
      filename, mime_type: "video/mp4", file_size: fileSize,
    }),
  }).then(r => r.json());

  const { upload_id, chunk_size, chunk_urls } = init;

  // Step 2: Upload chunks
  const fd = fs.openSync(filepath, "r");
  for (let i = 0; i < chunk_urls.length; i++) {
    const buf = Buffer.alloc(Math.min(chunk_size, fileSize - i * chunk_size));
    fs.readSync(fd, buf, 0, buf.length, i * chunk_size);
    await fetch(chunk_urls[i], {
      method: "PUT", body: buf,
      headers: { "Content-Type": "application/octet-stream" },
    });
    console.log(`  Uploaded chunk ${i + 1}/${chunk_urls.length}`);
  }
  fs.closeSync(fd);

  // Step 3: Complete upload
  const complete = await fetch(
    `${BASE}/api/v1/uploads/${upload_id}/complete`,
    { method: "POST", headers: HEADERS }
  ).then(r => r.json());

  // Step 4: Create compression job
  const job = await fetch(`${BASE}/api/v1/jobs`, {
    method: "POST",
    headers: { ...HEADERS, "Content-Type": "application/json" },
    body: JSON.stringify({ file_id: complete.file_id, preset }),
  }).then(r => r.json());

  console.log(`Job created: ${job.id}`);

  // Step 5: Poll until complete
  while (true) {
    const status = await fetch(
      `${BASE}/api/v1/jobs/${job.id}`, { headers: HEADERS }
    ).then(r => r.json());

    console.log(`  Status: ${status.status} (${status.progress || 0}%)`);
    if (status.status === "complete") break;
    if (status.status === "failed") throw new Error(`Job failed: ${JSON.stringify(status)}`);
    await new Promise(r => setTimeout(r, 5000));
  }

  // Step 6: Download result
  const dl = await fetch(
    `${BASE}/api/v1/jobs/${job.id}/download`, { headers: HEADERS }
  ).then(r => r.json());

  const res = await fetch(dl.download_url);
  const dest = fs.createWriteStream(`compressed_${filename}`);
  await new Promise((resolve, reject) => {
    res.body.pipe(dest);
    dest.on("finish", resolve);
    dest.on("error", reject);
  });

  console.log(`Downloaded: compressed_${filename} (${dl.file_size} bytes)`);
}

compressVideo("interview.mp4");