Videos

curl --fail-with-body "$BASE/video/videos?limit=50&offset=0" \
  -H "Authorization: Bearer $SIMPLIFYD_API_TOKEN"

const response = await fetch(`${BASE}/video/videos?limit=50&offset=0`, {
  headers: {
    Authorization: `Bearer ${process.env.SIMPLIFYD_API_TOKEN}`,
  },
});
const result = await response.json();
if (!response.ok) throw new Error(result.message ?? response.statusText);

const form = new FormData();
form.append('title', 'Opening the account');
form.append('file', videoFile);

const response = await fetch(`${BASE}/video/videos`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.SIMPLIFYD_API_TOKEN}` },
  body: form,
});

if (!response.ok) {
  const { message } = await response.json();
  throw new Error(message);
}

const video = await response.json();
// video.slug   — the id everything else is addressed by
// video.status — "queued": the file is stored, encoding has not started yet

import { openAsBlob } from 'node:fs';

form.append('file', await openAsBlob('./talk.mp4'), 'talk.mp4');

<?php

$form = [
    // Ordered deliberately: cURL sends the fields in the order of this array,
    // and a title after the file is never read. See the note below.
    'title' => 'Opening the account',
    'file'  => new CURLFile('/path/to/talk.mp4', 'video/mp4', 'talk.mp4'),
];

$ch = curl_init("{$base}/video/videos");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $form,
    CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . getenv('SIMPLIFYD_API_TOKEN')],
    CURLOPT_RETURNTRANSFER => true,
]);

$body   = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
curl_close($ch);

$video = json_decode($body, true);

if ($status !== 201) {
    throw new RuntimeException($video['message'] ?? 'upload failed');
}

// $video['slug']   — the id everything else is addressed by
// $video['status'] — "queued": the file is stored, encoding has not started yet

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
)

// UploadVideo posts a file to a video library and returns the video it created.
//
// The form is written into a pipe rather than a buffer, so the file streams from
// disk to the network instead of being held in memory a second time.
func UploadVideo(base, token, path, title string) (map[string]any, error) {
	pr, pw := io.Pipe()
	form := multipart.NewWriter(pw)

	go func() {
		// Closed exactly once, with whatever went wrong, and nil on success —
		// which ends the body cleanly. Do not also `defer pw.Close()`: it would
		// overwrite that error with EOF, and a file that failed halfway would
		// be uploaded as though it were the whole thing.
		pw.CloseWithError(func() error {
			// Written before the file, deliberately — see the note below.
			if err := form.WriteField("title", title); err != nil {
				return err
			}
			part, err := form.CreateFormFile("file", filepath.Base(path))
			if err != nil {
				return err
			}
			f, err := os.Open(path)
			if err != nil {
				return err
			}
			defer f.Close()
			if _, err := io.Copy(part, f); err != nil {
				return err
			}
			// The trailing boundary, written only once the file is all there.
			// Writing it after a failed copy would frame a truncated body as a
			// complete one.
			return form.Close()
		}())
	}()

	req, err := http.NewRequest(http.MethodPost, base+"/video/videos", pr)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", form.FormDataContentType())
	req.Header.Set("Authorization", "Bearer "+token)

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

	var video map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&video); err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusCreated {
		return nil, fmt.Errorf("upload failed: %v", video["message"])
	}
	return video, nil
}

client := cloud.NewClient(cloud.WithToken(os.Getenv("SIMPLIFYD_API_TOKEN")))
videos := client.Workspace(ws).Project(proj).Env(env).Services().Video(library)

video, err := videos.Upload(ctx, "talk.mp4", "Opening the account", nil)

curl -X POST "$BASE/video/videos" \
  -H "Authorization: Bearer $SIMPLIFYD_API_TOKEN" \
  -F "title=Opening the account" \
  -F "file=@talk.mp4"

const response = await fetch(`${BASE}/video/videos/${videoId}`, {
  headers: { Authorization: `Bearer ${process.env.SIMPLIFYD_API_TOKEN}` },
});

const video = await response.json();
return Response.json({
  videoId: video.slug,
  playbackUrl: video.playback_url,
  thumbnailUrl: video.poster_url,
  embedCode: video.iframe_snippet,
});

<?php

$ch = curl_init("{$base}/video/videos/{$videoId}");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . getenv('SIMPLIFYD_API_TOKEN')],
    CURLOPT_RETURNTRANSFER => true,
]);
$video = json_decode(curl_exec($ch), true);
curl_close($ch);

echo json_encode([
    'videoId'      => $video['slug'],
    'playbackUrl'  => $video['playback_url'] ?? null,
    'thumbnailUrl' => $video['poster_url'] ?? null,
    'embedCode'    => $video['iframe_snippet'] ?? null,
]);

// Video is the subset worth naming. Add fields as you need them; the response
// carries more.
type Video struct {
	Slug          string `json:"slug"`
	Title         string `json:"title"`
	Status        string `json:"status"`
	StatusMessage string `json:"status_message"`
	DurationMS    int64  `json:"duration_ms"`
	ProgressPct   int    `json:"progress_pct"`

	// Empty until Status is "ready".
	PlaybackURL   string `json:"playback_url"`
	EmbedURL      string `json:"embed_url"`
	PosterURL     string `json:"poster_url"`
	IframeSnippet string `json:"iframe_snippet"`
}

func GetVideo(base, token, videoID string) (*Video, error) {
	req, err := http.NewRequest(http.MethodGet, base+"/video/videos/"+videoID, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+token)

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

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("reading video %s: %s", videoID, resp.Status)
	}

	var video Video
	if err := json.NewDecoder(resp.Body).Decode(&video); err != nil {
		return nil, err
	}
	return &video, nil
}

const response = await fetch(`${BASE}/video/videos/${videoId}/original`, {
  headers: { Authorization: `Bearer ${process.env.SIMPLIFYD_API_TOKEN}` },
});
if (!response.ok) throw new Error(`could not get the original: ${response.status}`);

const { url } = await response.json();
const original = await fetch(url); // no token: the link carries its own permission

url=$(curl -s "$BASE/video/videos/$VIDEO_ID/original" \
  -H "Authorization: Bearer $SIMPLIFYD_API_TOKEN" | jq -r .url)
curl -L -o original.mp4 "$url"

const headers = {
  Authorization: `Bearer ${process.env.SIMPLIFYD_API_TOKEN}`,
  'Content-Type': 'application/json',
};

// Read the current settings first, so the others are sent back unchanged.
const library = await (await fetch(`${BASE}/video`, { headers })).json();

const response = await fetch(`${BASE}/video`, {
  method: 'PUT',
  headers,
  body: JSON.stringify({
    max_height: library.max_height,
    keep_original: library.keep_original,
    allowed_embed_domains: ['example.com', 'learn.example.org'],
  }),
});
if (!response.ok) {
  const { message } = await response.json();
  throw new Error(message); // e.g. "\"example\" is not a domain"
}

curl -X PUT "$BASE/video" \
  -H "Authorization: Bearer $SIMPLIFYD_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"max_height": 720, "keep_original": true, "allowed_embed_domains": ["example.com"]}'