Video transcoding API for uploads

import { Dreep } from "dreep";

const dreep = new Dreep({ apiKey: process.env.DREEP_API_KEY });

// Server-side: get a single-use upload URL
const upload = await dreep.presignUpload({
  filename: "launch.mov",
  contentType: "video/quicktime",
  sizeBytes: 184_000_000,
  folder: "videos/2026",
});

// Browser or worker: PUT the raw bytes, then confirm server-side
await fetch(upload.uploadUrl, { method: "PUT", body: file });
const asset = await dreep.confirmUpload({ id: upload.id });

const hls = dreep.url(asset, { format: "m3u8" });
const webm = dreep.url(asset, { format: "webm", videoCodec: "vp9", width: 1280 });
const poster = dreep.url(asset, { format: "webp", width: 1280 });

f, _ := os.Open("launch.mov")
defer f.Close()
info, _ := f.Stat()

// Presign, PUT and confirm in one call
asset, err := client.UploadPresigned(ctx, dreep.DirectUploadOptions{
    PresignOptions: dreep.PresignOptions{
        Filename:    "launch.mov",
        ContentType: "video/quicktime",
        SizeBytes:   info.Size(),
        Destination: dreep.Destination{Folder: "videos/2026"},
    },
    File: f,
})
if err != nil {
    log.Fatal(err)
}

hls := client.URL(asset.ID, &dreep.Transform{Format: dreep.FormatM3U8})
mp4 := client.URL(asset.ID, &dreep.Transform{
    Format: dreep.FormatMP4, VideoCodec: dreep.CodecH264, Width: 1280,
})

curl -X POST https://api.dreep.cloud/api/v1/upload/presign \
  -H "Authorization: Bearer $DREEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename":"launch.mov","contentType":"video/quicktime","sizeBytes":184000000,"folder":"videos/2026"}'

curl -X PUT "$UPLOAD_URL" -H "Content-Type: video/quicktime" --data-binary @launch.mov

curl -X POST "https://api.dreep.cloud/api/v1/upload/$UPLOAD_ID/confirm" \
  -H "Authorization: Bearer $DREEP_API_KEY"

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Resolves when the rendition is ready; does not download the body
const waitForRendition = async (url, { maxAttempts = 15 } = {}) => {
  let delay = 2000;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const res = await fetch(url, { headers: { Accept: "application/json" } });
    await res.body?.cancel();

    if (res.status === 200) return url;
    if (res.status !== 202) throw new Error(`Transform failed: ${res.status}`);

    await sleep(delay + Math.random() * 500); // jitter
    delay = Math.min(delay * 2, 30_000);
  }

  throw new Error("Still processing; try again later");
};

const ready = await waitForRendition(dreep.url(asset, { format: "m3u8" }));

func waitForRendition(ctx context.Context, url string) error {
    delay := 2 * time.Second

    for attempt := 0; attempt < 15; attempt++ {
        req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
        req.Header.Set("Accept", "application/json")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return err
        }
        resp.Body.Close()

        switch resp.StatusCode {
        case http.StatusOK:
            return nil
        case http.StatusAccepted:
            // still processing
        default:
            return fmt.Errorf("transform failed: %s", resp.Status)
        }

        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-time.After(delay):
        }
        delay = min(delay*2, 30*time.Second)
    }
    return errors.New("still processing")
}

# 202 while processing, 200 once the rendition is cached
curl -s -o /dev/null -w "%{http_code}\n" \
  -H "Accept: application/json" \
  "https://cdn.dreep.cloud/api/v1/fetch/2f928a3f.mp4?format=webm&videoCodec=vp9&width=1280"

import Hls from "hls.js";

const video = document.querySelector("video");
const src = "https://cdn.dreep.cloud/api/v1/fetch/2f928a3f.m3u8";

if (Hls.isSupported()) {
  const hls = new Hls();
  hls.loadSource(src);
  hls.attachMedia(video);
} else if (video.canPlayType("application/vnd.apple.mpegurl")) {
  // Safari plays HLS natively
  video.src = src;
}