txscribe API

curl https://txscribe.ai/api/v1/transcriptions \
  -H "Authorization: Bearer $TXSCRIBE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"url": "https://www.youtube.com/watch?v=VIDEO_ID", "language": "auto"}'

# 1. Create the transcription. The answer carries a one-time upload URL.
curl https://txscribe.ai/api/v1/transcriptions \
  -H "Authorization: Bearer $TXSCRIBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"fileName": "interview.m4a", "contentType": "audio/mp4", "size": 18234567}'

# 2. PUT the whole file to upload.url (no Authorization header).
curl -X PUT --upload-file interview.m4a -H "Content-Type: audio/mp4" "$UPLOAD_URL"

# 3. Start transcribing.
curl -X POST https://txscribe.ai/api/v1/transcriptions/$ID/start \
  -H "Authorization: Bearer $TXSCRIBE_API_KEY"

# 4. When status is "done" (or your webhook says so), fetch the transcript.
curl "https://txscribe.ai/api/v1/transcriptions/$ID/transcript?format=srt" \
  -H "Authorization: Bearer $TXSCRIBE_API_KEY" -o interview.srt

const API = "https://txscribe.ai/api/v1";
const headers = { Authorization: `Bearer ${process.env.TXSCRIBE_API_KEY}`, "Content-Type": "application/json" };

async function call(path, init = {}) {
  const response = await fetch(API + path, { ...init, headers: { ...headers, ...init.headers } });
  if (!response.ok) {
    const { error } = await response.json();
    throw new Error(`${error.code}: ${error.message} (request ${error.requestId})`);
  }
  return response;
}

const { transcription } = await (
  await call("/transcriptions", {
    method: "POST",
    headers: { "Idempotency-Key": crypto.randomUUID() },
    body: JSON.stringify({ url: "https://www.youtube.com/watch?v=VIDEO_ID" }),
  })
).json();

// Prefer a webhook; polling works too.
let current = transcription;
while (!["done", "error"].includes(current.status)) {
  await new Promise((resolve) => setTimeout(resolve, 15000));
  current = await (await call(`/transcriptions/${transcription.id}`)).json();
}
if (current.status === "done") {
  console.log(await (await call(`/transcriptions/${current.id}/transcript?format=txt`)).text());
}

import os, time, uuid, requests

API = "https://txscribe.ai/api/v1"
session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['TXSCRIBE_API_KEY']}"

created = session.post(
    f"{API}/transcriptions",
    json={"url": "https://www.youtube.com/watch?v=VIDEO_ID"},
    headers={"Idempotency-Key": str(uuid.uuid4())},
)
created.raise_for_status()
transcription = created.json()["transcription"]

while transcription["status"] not in ("done", "error"):
    time.sleep(15)
    transcription = session.get(f"{API}/transcriptions/{transcription['id']}").json()

if transcription["status"] == "done":
    print(session.get(f"{API}/transcriptions/{transcription['id']}/transcript", params={"format": "txt"}).text)

import { createHmac, timingSafeEqual } from "node:crypto";

// header: the Txscribe-Signature header. rawBody: the request body exactly as received, as a string.
export function verifyTxscribeSignature(secret, header, rawBody, toleranceSeconds = 300) {
  let timestamp = NaN;
  const signatures = [];
  for (const part of header.split(",")) {
    const [name, value] = part.trim().split("=", 2);
    if (name === "t") timestamp = Number(value);
    if (name === "v1" && value) signatures.push(value);
  }
  if (!Number.isInteger(timestamp) || Math.abs(Date.now() / 1000 - timestamp) > toleranceSeconds) return false;
  const expected = createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest();
  return signatures.some((signature) => {
    const given = Buffer.from(signature, "hex");
    return given.length === expected.length && timingSafeEqual(given, expected);
  });
}

import hashlib, hmac, time

# header: the Txscribe-Signature header. raw_body: the request body exactly as received, as bytes.
def verify_txscribe_signature(secret: str, header: str, raw_body: bytes, tolerance: int = 300) -> bool:
    timestamp, signatures = None, []
    for part in header.split(","):
        name, _, value = part.strip().partition("=")
        if name == "t":
            timestamp = value
        elif name == "v1":
            signatures.append(value)
    if timestamp is None or not timestamp.isdigit() or abs(time.time() - int(timestamp)) > tolerance:
        return False
    expected = hmac.new(secret.encode(), timestamp.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
    return any(hmac.compare_digest(expected, signature) for signature in signatures)