Publish to BentBox from your platform

curl -X POST https://api.bentbox.co/v1/content/video \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "access_token": "'"$ACCESS_TOKEN"'",
    "connection_id": "conn_abc123",
    "title": "Golden hour session",
    "filename": "session.mp4",
    "filesize": 524288000,
    "duration": 300,
    "description": "Shot on the rooftop at sunset.",
    "tags": ["outdoor", "summer"],
    "price": 9.99,
    "sole_performer": true,
    "publish_on_ready": true
  }'

{
  "access_token": "bx_live_abc123",
  "connection_id": "conn_abc123",
  "title": "Golden hour session",
  "filename": "session.mp4",
  "filesize": 524288000,
  "duration": 300,
  "description": "Shot on the rooftop at sunset.",
  "tags": ["outdoor", "summer"],
  "price": 9.99,
  "sole_performer": true,
  "publish_on_ready": true
}

curl -X PUT --upload-file ./session.mp4 \
  -H "Content-Type: video/mp4" \
  "$UPLOAD_URL"

import { createReadStream, statSync } from "node:fs";

const res = await fetch(uploadUrl, {
  method: "PUT",
  headers: { "Content-Type": "video/mp4", "Content-Length": String(statSync(path).size) },
  body: createReadStream(path),
  duplex: "half",
});
if (!res.ok) throw new Error(`Upload failed: ${res.status}`);

import requests

with open("session.mp4", "rb") as f:
    r = requests.put(upload_url, data=f, headers={"Content-Type": "video/mp4"})
r.raise_for_status()

<?php
$fh = fopen($path, 'rb');
$ch = curl_init($uploadUrl);
curl_setopt_array($ch, [
    CURLOPT_PUT            => true,
    CURLOPT_INFILE         => $fh,
    CURLOPT_INFILESIZE     => filesize($path),
    CURLOPT_HTTPHEADER     => ['Content-Type: video/mp4'],
    CURLOPT_RETURNTRANSFER => true,
]);
curl_exec($ch);
$ok = curl_getinfo($ch, CURLINFO_HTTP_CODE) === 200;
curl_close($ch);
fclose($fh);

curl "https://api.bentbox.co/v1/content/video/1770903940-db122f8acccf9dfe?connection_id=conn_abc123" \
  -H "Authorization: Bearer $ACCESS_TOKEN"

const res = await fetch(
  `https://api.bentbox.co/v1/content/video/${videoId}?connection_id=${connectionId}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }
);
const video = await res.json();
if (!video.success) throw new Error(video.error_description);
console.log(video.status, video.is_live);

import requests

r = requests.get(
    f"https://api.bentbox.co/v1/content/video/{video_id}",
    params={"connection_id": connection_id},
    headers={"Authorization": f"Bearer {access_token}"},
    timeout=10,
)
video = r.json()
print(video["status"], video["is_live"])

<?php
$url = 'https://api.bentbox.co/v1/content/video/' . rawurlencode($videoId)
     . '?connection_id=' . rawurlencode($connectionId);

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 10,
    CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $accessToken],
]);
$video = json_decode(curl_exec($ch), true);
curl_close($ch);

// npm install express
import express from "express";
import crypto from "node:crypto";
import { createReadStream, statSync } from "node:fs";

const API = "https://api.bentbox.co";
const CLIENT_ID = process.env.BENTBOX_CLIENT_ID;
const CLIENT_SECRET = process.env.BENTBOX_CLIENT_SECRET;
const REDIRECT_URI = "https://yourplatform.com/oauth/callback";

const app = express();
app.use(express.json());

// 1. Send the creator to BentBox
app.get("/connect-bentbox", (req, res) => {
  const state = crypto.randomBytes(16).toString("hex");
  req.session.oauthState = state;
  const q = new URLSearchParams({
    client_id: CLIENT_ID, redirect_uri: REDIRECT_URI,
    scope: "upload_video", state, response_type: "code",
  });
  res.redirect(`${API}/oauth/authorize?${q}`);
});

// 2. Exchange the code and store the connection
app.get("/oauth/callback", async (req, res) => {
  if (req.query.state !== req.session.oauthState) return res.status(400).send("Invalid state");
  const r = await fetch(`${API}/oauth/token`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      grant_type: "authorization_code", code: req.query.code,
      client_id: CLIENT_ID, client_secret: CLIENT_SECRET, redirect_uri: REDIRECT_URI,
    }),
  });
  const t = await r.json();
  await db.saveConnection(req.user.id, {
    connectionId: t.connection_id, bentboxUserId: t.user_id,
    accessToken: encrypt(t.access_token), refreshToken: encrypt(t.refresh_token),
  });
  res.redirect("/dashboard?connected=1");
});

// 3. Create, get upload URL, upload
app.post("/upload-video", async (req, res) => {
  const conn = await db.getConnection(req.user.id);
  const token = decrypt(conn.accessToken);
  const auth = { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
  const { path, title, price = 0, duration } = req.body;

  const created = await (await fetch(`${API}/v1/content/video`, {
    method: "POST", headers: auth,
    body: JSON.stringify({
      access_token: token, connection_id: conn.connectionId,
      title, filename: "video.mp4", filesize: statSync(path).size, duration,
      price, sole_performer: true,
    }),
  })).json();
  if (!created.success) return res.status(400).json(created);

  const signed = await (await fetch(`${API}/v1/content/upload-url`, {
    method: "POST", headers: auth,
    body: JSON.stringify({
      access_token: token, connection_id: conn.connectionId,
      video_id: created.video_id, title, price, duration,
    }),
  })).json();
  if (!signed.success) return res.status(400).json(signed);

  const put = await fetch(signed.upload_url, {
    method: "PUT", headers: { "Content-Type": "video/mp4" },
    body: createReadStream(path), duplex: "half",
  });
  if (!put.ok) return res.status(502).json({ error: "upload_failed" });

  res.json({ video_id: created.video_id, settings: created.video_settings_url });
});

// 4. Status for your UI
app.get("/videos/:id/status", async (req, res) => {
  const conn = await db.getConnection(req.user.id);
  const r = await fetch(
    `${API}/v1/content/video/${encodeURIComponent(req.params.id)}?connection_id=${conn.connectionId}`,
    { headers: { Authorization: `Bearer ${decrypt(conn.accessToken)}` } }
  );
  res.status(r.status).json(await r.json());
});

app.listen(3000);

# pip install flask requests
import os, secrets, requests
from flask import Flask, redirect, request, session, jsonify

API = "https://api.bentbox.co"
CLIENT_ID = os.environ["BENTBOX_CLIENT_ID"]
CLIENT_SECRET = os.environ["BENTBOX_CLIENT_SECRET"]
REDIRECT_URI = "https://yourplatform.com/oauth/callback"

app = Flask(__name__)
app.secret_key = os.environ["FLASK_SECRET"]

# 1. Send the creator to BentBox
@app.get("/connect-bentbox")
def connect():
    session["oauth_state"] = state = secrets.token_urlsafe(16)
    q = requests.compat.urlencode({
        "client_id": CLIENT_ID, "redirect_uri": REDIRECT_URI,
        "scope": "upload_video", "state": state, "response_type": "code",
    })
    return redirect(f"{API}/oauth/authorize?{q}")

# 2. Exchange the code and store the connection
@app.get("/oauth/callback")
def callback():
    if request.args.get("state") != session.pop("oauth_state", None):
        return "Invalid state", 400
    t = requests.post(f"{API}/oauth/token", json={
        "grant_type": "authorization_code", "code": request.args["code"],
        "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, "redirect_uri": REDIRECT_URI,
    }, timeout=15).json()
    db.save_connection(session["user_id"], connection_id=t["connection_id"],
                       access_token=encrypt(t["access_token"]),
                       refresh_token=encrypt(t["refresh_token"]))
    return redirect("/dashboard?connected=1")

# 3. Create, get upload URL, upload
@app.post("/upload-video")
def upload_video():
    conn = db.get_connection(session["user_id"])
    token = decrypt(conn.access_token)
    auth = {"Authorization": f"Bearer {token}"}
    body = request.json
    path, title = body["path"], body["title"]
    price, duration = body.get("price", 0), body["duration"]

    created = requests.post(f"{API}/v1/content/video", headers=auth, json={
        "access_token": token, "connection_id": conn.connection_id,
        "title": title, "filename": "video.mp4", "filesize": os.path.getsize(path),
        "duration": duration, "price": price, "sole_performer": True,
    }, timeout=15).json()
    if not created.get("success"):
        return jsonify(created), 400

    signed = requests.post(f"{API}/v1/content/upload-url", headers=auth, json={
        "access_token": token, "connection_id": conn.connection_id,
        "video_id": created["video_id"], "title": title, "price": price, "duration": duration,
    }, timeout=15).json()
    if not signed.get("success"):
        return jsonify(signed), 400

    with open(path, "rb") as f:
        requests.put(signed["upload_url"], data=f,
                     headers={"Content-Type": "video/mp4"}).raise_for_status()

    return {"video_id": created["video_id"], "settings": created["video_settings_url"]}

# 4. Status for your UI
@app.get("/videos/<video_id>/status")
def video_status(video_id):
    conn = db.get_connection(session["user_id"])
    r = requests.get(f"{API}/v1/content/video/{video_id}",
                     params={"connection_id": conn.connection_id},
                     headers={"Authorization": f"Bearer {decrypt(conn.access_token)}"},
                     timeout=10)
    return r.json(), r.status_code

<?php
const API           = 'https://api.bentbox.co';
const REDIRECT_URI  = 'https://yourplatform.com/callback.php';
define('CLIENT_ID',     getenv('BENTBOX_CLIENT_ID'));
define('CLIENT_SECRET', getenv('BENTBOX_CLIENT_SECRET'));

function bentbox(string $method, string $path, ?array $body = null, ?string $token = null): array {
    $ch = curl_init(API . $path);
    $headers = ['Accept: application/json'];
    if ($token) $headers[] = 'Authorization: Bearer ' . $token;
    if ($body !== null) {
        $headers[] = 'Content-Type: application/json';
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_HTTPHEADER     => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 15,
    ]);
    $res = json_decode(curl_exec($ch), true) ?? [];
    curl_close($ch);
    return $res;
}

// 1. Send the creator to BentBox
function connectBentBox(): void {
    $_SESSION['oauth_state'] = bin2hex(random_bytes(16));
    header('Location: ' . API . '/oauth/authorize?' . http_build_query([
        'client_id' => CLIENT_ID, 'redirect_uri' => REDIRECT_URI,
        'scope' => 'upload_video', 'state' => $_SESSION['oauth_state'], 'response_type' => 'code',
    ]));
    exit;
}

// 2. Exchange the code and store the connection
function handleCallback(): void {
    if (!hash_equals($_SESSION['oauth_state'] ?? '', $_GET['state'] ?? '')) exit('Invalid state');
    $t = bentbox('POST', '/oauth/token', [
        'grant_type' => 'authorization_code', 'code' => $_GET['code'],
        'client_id' => CLIENT_ID, 'client_secret' => CLIENT_SECRET, 'redirect_uri' => REDIRECT_URI,
    ]);
    saveConnection($_SESSION['user_id'], $t['connection_id'],
                   encrypt($t['access_token']), encrypt($t['refresh_token']));
    header('Location: /dashboard?connected=1');
}

// 3. Create, get upload URL, upload
function uploadVideo(string $path, string $title, float $price, float $duration): array {
    $c = getConnection($_SESSION['user_id']);
    $token = decrypt($c['access_token']);
    $auth = ['access_token' => $token, 'connection_id' => $c['connection_id']];

    $created = bentbox('POST', '/v1/content/video', $auth + [
        'title' => $title, 'filename' => 'video.mp4', 'filesize' => filesize($path),
        'duration' => $duration, 'price' => $price, 'sole_performer' => true,
    ], $token);
    if (empty($created['success'])) return $created;

    $signed = bentbox('POST', '/v1/content/upload-url', $auth + [
        'video_id' => $created['video_id'], 'title' => $title,
        'price' => $price, 'duration' => $duration,
    ], $token);
    if (empty($signed['success'])) return $signed;

    $fh = fopen($path, 'rb');
    $ch = curl_init($signed['upload_url']);
    curl_setopt_array($ch, [
        CURLOPT_PUT => true, CURLOPT_INFILE => $fh, CURLOPT_INFILESIZE => filesize($path),
        CURLOPT_HTTPHEADER => ['Content-Type: video/mp4'], CURLOPT_RETURNTRANSFER => true,
    ]);
    curl_exec($ch);
    $ok = curl_getinfo($ch, CURLINFO_HTTP_CODE) === 200;
    curl_close($ch);
    fclose($fh);

    return ['success' => $ok, 'video_id' => $created['video_id'],
            'settings' => $created['video_settings_url']];
}

// 4. Status for your UI
function videoStatus(string $videoId): array {
    $c = getConnection($_SESSION['user_id']);
    return bentbox('GET', '/v1/content/video/' . rawurlencode($videoId)
        . '?connection_id=' . rawurlencode($c['connection_id']), null, decrypt($c['access_token']));
}