API transkrip bahasa Indonesia (speech to text)

export TRANSKRIP_API_KEY="trk_live_..."

curl https://api.transkrip.online/v1/transcriptions \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -F [email protected] \
  -F language=id \
  -F num_speakers=3 \
  -F title="Rapat mingguan"

{
  "id": "trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1",
  "object": "transcription",
  "status": "queued",
  "created_at": 1792677149,
  "completed_at": null,
  "title": "Rapat mingguan",
  "filename": "rapat.m4a",
  "language": "id",
  "duration": 1834.2,
  "billed_minutes": 31,
  "price_idr": 1550,
  "num_speakers": 3,
  "source": "api"
}

curl https://api.transkrip.online/v1/transcriptions/trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1 \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY"

curl -o rapat.docx \
  "https://api.transkrip.online/v1/transcriptions/trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1/export?format=docx" \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY"

import os
import time

import requests

BASE = "https://api.transkrip.online/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['TRANSKRIP_API_KEY']}"}

# 1. Kirim rekaman (202: pekerjaan masuk antrean)
with open("rapat.m4a", "rb") as f:
    r = requests.post(
        f"{BASE}/transcriptions",
        headers=HEADERS,
        files={"file": ("rapat.m4a", f)},
        data={"language": "id", "num_speakers": "3", "title": "Rapat mingguan"},
        timeout=600,
    )
if not r.ok:
    raise SystemExit(r.json()["error"]["message"])
job = r.json()

# 2. Tanya status sampai selesai
while job["status"] in ("queued", "processing"):
    time.sleep(15)
    job = requests.get(f"{BASE}/transcriptions/{job['id']}", headers=HEADERS, timeout=30).json()

if job["status"] == "failed":
    raise SystemExit(job["error"]["message"])  # saldo sudah kembali otomatis

# 3. Pakai hasilnya: label pembicara + segmen berstempel waktu
names = {s["id"]: s["label"] for s in job["speakers"]}
for seg in job["segments"]:
    print(f"[{seg['start']:7.1f}] {names.get(seg['speaker'], seg['speaker'])}: {seg['text']}")

import os

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TRANSKRIP_API_KEY"],
    base_url="https://api.transkrip.online/v1",
    timeout=3 * 60 * 60,  # detik; bawaan SDK 10 menit, terlalu pendek untuk rekaman panjang
)

with open("rapat.m4a", "rb") as f:
    result = client.audio.transcriptions.create(
        model="transkrip-1",
        file=f,
        language="id",
        response_format="verbose_json",
        extra_body={"num_speakers": 2},  # opsional; kosong = otomatis
    )

print(result.text)
for seg in result.segments:
    print(seg.start, seg.end, seg.text)

// transkrip.mjs — Node 20+, tanpa dependensi
import { openAsBlob } from "node:fs";

const BASE = "https://api.transkrip.online/v1";
const headers = { Authorization: `Bearer ${process.env.TRANSKRIP_API_KEY}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// 1. Kirim rekaman (202: pekerjaan masuk antrean)
const form = new FormData();
form.append("file", await openAsBlob("rapat.m4a"), "rapat.m4a");
form.append("language", "id");
form.append("num_speakers", "3");

const res = await fetch(`${BASE}/transcriptions`, { method: "POST", headers, body: form });
let job = await res.json();
if (!res.ok) throw new Error(job.error.message);

// 2. Tanya status sampai selesai
while (job.status === "queued" || job.status === "processing") {
  await sleep(15_000);
  job = await (await fetch(`${BASE}/transcriptions/${job.id}`, { headers })).json();
}
if (job.status === "failed") throw new Error(job.error.message); // saldo sudah kembali

// 3. Pakai hasilnya: label pembicara + segmen berstempel waktu
const names = Object.fromEntries(job.speakers.map((s) => [s.id, s.label]));
for (const seg of job.segments) {
  console.log(`[${seg.start.toFixed(1)}] ${names[seg.speaker] ?? seg.speaker}: ${seg.text}`);
}

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TRANSKRIP_API_KEY,
  baseURL: "https://api.transkrip.online/v1",
  timeout: 3 * 60 * 60 * 1000, // milidetik; bawaan SDK 10 menit
});

const result = await client.audio.transcriptions.create({
  model: "transkrip-1",
  file: fs.createReadStream("rapat.m4a"),
  language: "id",
  response_format: "verbose_json",
});

console.log(result.text);

curl "https://api.transkrip.online/v1/transcriptions?language=id&num_speakers=3&title=Rapat%20tahunan" \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -H "Content-Type: video/mp4" \
  -T rapat-tahunan.mp4 -X POST

import os

import requests

BASE = "https://api.transkrip.online/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['TRANSKRIP_API_KEY']}"}

with open("rapat-tahunan.mp4", "rb") as f:
    r = requests.post(
        f"{BASE}/transcriptions",
        params={"language": "id", "num_speakers": 3, "title": "Rapat tahunan"},
        headers={**HEADERS, "Content-Type": "video/mp4"},
        data=f,  # objek berkas = dialirkan dari disk, tidak dimuat ke memori
        timeout=(10, 3600),
    )
print(r.status_code, r.json())

import { openAsBlob } from "node:fs";

const BASE = "https://api.transkrip.online/v1";
const params = new URLSearchParams({ language: "id", num_speakers: "3", title: "Rapat tahunan" });

const res = await fetch(`${BASE}/transcriptions?${params}`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.TRANSKRIP_API_KEY}`,
    "Content-Type": "video/mp4",
  },
  body: await openAsBlob("rapat-tahunan.mp4"), // dibaca dari disk sambil dikirim
});
console.log(res.status, await res.json());

curl https://api.transkrip.online/v1/transcriptions \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: upload-upl_8a1f..." \
  -d '{"upload_id": "upl_8a1f...", "language": "id", "num_speakers": 2}'

"""Unggah bertahap yang bisa dilanjutkan.

Pakai:  TRANSKRIP_API_KEY=trk_live_... python unggah.py rekaman.mp4
Bila koneksi putus, jalankan perintah yang sama lagi: unggahan diteruskan dari posisi terakhir.
"""
import os
import sys
import time
from pathlib import Path

import requests

BASE = "https://api.transkrip.online/v1"
AUTH = {"Authorization": f"Bearer {os.environ['TRANSKRIP_API_KEY']}"}


def call(method, path, headers=None, **kwargs):
    """Panggil API. Galat jaringan, 429, dan 5xx dicoba ulang dengan jeda bertambah."""
    for attempt in range(6):
        wait = 2**attempt
        try:
            r = requests.request(
                method, BASE + path, headers={**AUTH, **(headers or {})}, timeout=120, **kwargs
            )
            if r.status_code != 429 and r.status_code < 500:
                return r
            wait = int(r.headers.get("Retry-After") or wait)
        except requests.RequestException:
            pass
        time.sleep(wait)
    raise SystemExit(f"Gagal setelah 6 percobaan: {method} {path}")


def check(r):
    if not r.ok:
        err = r.json().get("error", {})
        raise SystemExit(f"{r.status_code} {err.get('code')}: {err.get('message')}")
    return r.json()


def main(file_path):
    path = Path(file_path)
    size = path.stat().st_size
    state = path.with_name(path.name + ".upload-id")

    # Lanjutkan unggahan lama bila masih terbuka; kalau tidak, mulai baru.
    upload = None
    if state.exists():
        r = call("GET", f"/uploads/{state.read_text().strip()}")
        if r.ok and r.json().get("status") == "uploading":
            upload = r.json()
    if upload is None:
        upload = check(call("POST", "/uploads", json={"filename": path.name, "bytes": size}))
        state.write_text(upload["id"])

    offset = upload["received_bytes"]
    with path.open("rb") as f:
        while offset < size:
            f.seek(offset)
            chunk = f.read(upload["part_bytes"])
            r = call(
                "PUT",
                f"/uploads/{upload['id']}/parts",
                params={"offset": offset},
                headers={"Content-Type": "application/octet-stream"},
                data=chunk,
            )
            if r.status_code == 409 and r.json()["error"]["code"] == "offset_mismatch":
                offset = check(call("GET", f"/uploads/{upload['id']}"))["received_bytes"]
                continue
            if not r.ok:
                check(r)
            offset += len(chunk)
            print(f"{offset * 100 // size}% terkirim")

    done = check(call("POST", f"/uploads/{upload['id']}/complete"))
    print(f"Durasi {done['duration']:.0f} detik, {done['billed_minutes']} menit, Rp{done['price_idr']}")
    if not done["enough_balance"]:
        raise SystemExit(
            f"Saldo Rp{done['balance_idr']} belum cukup. Isi saldo, lalu buat transkrip dengan "
            f"upload_id {upload['id']} (berlaku 24 jam)."
        )

    # Idempotency-Key dari id unggahan: aman diulang, tidak pernah tertagih dua kali.
    job = check(
        call(
            "POST",
            "/transcriptions",
            headers={"Idempotency-Key": f"upload-{upload['id']}"},
            json={"upload_id": upload["id"], "language": "id"},
        )
    )
    state.unlink(missing_ok=True)
    print("Transkrip dibuat:", job["id"], job["status"])


if __name__ == "__main__":
    main(sys.argv[1])

// unggah.mjs — unggah bertahap yang bisa dilanjutkan (Node 20+, tanpa dependensi).
// Pakai:  TRANSKRIP_API_KEY=trk_live_... node unggah.mjs rekaman.mp4
// Bila koneksi putus, jalankan perintah yang sama lagi: unggahan diteruskan dari posisi terakhir.
import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
import { open } from "node:fs/promises";
import { basename } from "node:path";

const BASE = "https://api.transkrip.online/v1";
const AUTH = { Authorization: `Bearer ${process.env.TRANSKRIP_API_KEY}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

/** Panggil API. Galat jaringan, 429, dan 5xx dicoba ulang dengan jeda bertambah. */
async function call(method, path, { headers = {}, body } = {}) {
  for (let attempt = 0; attempt < 6; attempt++) {
    let wait = 2 ** attempt * 1000;
    try {
      const res = await fetch(BASE + path, {
        method,
        headers: { ...AUTH, ...headers },
        body,
        signal: AbortSignal.timeout(120_000),
      });
      if (res.status !== 429 && res.status < 500) return res;
      wait = Number(res.headers.get("retry-after")) * 1000 || wait;
    } catch {
      // galat jaringan / batas waktu: coba lagi
    }
    await sleep(wait);
  }
  throw new Error(`Gagal setelah 6 percobaan: ${method} ${path}`);
}

async function check(res) {
  const data = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${data.error?.code}: ${data.error?.message}`);
  return data;
}

const asJson = (obj) => ({
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(obj),
});

const file = process.argv[2];
const size = statSync(file).size;
const stateFile = `${file}.upload-id`;

// Lanjutkan unggahan lama bila masih terbuka; kalau tidak, mulai baru.
let upload = null;
if (existsSync(stateFile)) {
  const res = await call("GET", `/uploads/${readFileSync(stateFile, "utf8").trim()}`);
  const data = res.ok ? await res.json() : null;
  if (data?.status === "uploading") upload = data;
}
if (!upload) {
  upload = await check(await call("POST", "/uploads", asJson({ filename: basename(file), bytes: size })));
  writeFileSync(stateFile, upload.id);
}

const fh = await open(file, "r");
let offset = upload.received_bytes;
while (offset < size) {
  const length = Math.min(upload.part_bytes, size - offset);
  const chunk = Buffer.alloc(length);
  await fh.read(chunk, 0, length, offset);
  const res = await call("PUT", `/uploads/${upload.id}/parts?offset=${offset}`, {
    headers: { "Content-Type": "application/octet-stream" },
    body: chunk,
  });
  if (res.status === 409) {
    const { error } = await res.json();
    if (error?.code !== "offset_mismatch") throw new Error(error?.message);
    offset = (await check(await call("GET", `/uploads/${upload.id}`))).received_bytes;
    continue;
  }
  if (!res.ok) await check(res);
  await res.arrayBuffer();
  offset += length;
  console.log(`${Math.floor((offset * 100) / size)}% terkirim`);
}
await fh.close();

const done = await check(await call("POST", `/uploads/${upload.id}/complete`));
console.log(`Durasi ${Math.round(done.duration)} detik, ${done.billed_minutes} menit, Rp${done.price_idr}`);
if (!done.enough_balance) {
  console.error(
    `Saldo Rp${done.balance_idr} belum cukup. Isi saldo, lalu buat transkrip dengan upload_id ${upload.id} (berlaku 24 jam).`,
  );
  process.exit(1);
}

// Idempotency-Key dari id unggahan: aman diulang, tidak pernah tertagih dua kali.
const job = await check(
  await call("POST", "/transcriptions", {
    headers: { "Content-Type": "application/json", "Idempotency-Key": `upload-${upload.id}` },
    body: JSON.stringify({ upload_id: upload.id, language: "id" }),
  }),
);
unlinkSync(stateFile);
console.log("Transkrip dibuat:", job.id, job.status);

POST /webhook/transkrip HTTP/1.1
Content-Type: application/json
User-Agent: Transkrip-Webhooks/1.0
Transkrip-Event: transcription.completed
Transkrip-Signature: t=1792677901,v1=5f0c2a…

{
  "id": "evt_3c9d1e7f2a6b4c8d9e0f1a2b3c4d5e6f",
  "object": "event",
  "type": "transcription.completed",
  "created_at": 1792677901,
  "data": {
    "id": "trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1",
    "status": "completed"
  }
}

import hashlib
import hmac
import json
import os
import time

from flask import Flask, abort, request

TOLERANCE = 300  # detik
SECRET = os.environ["TRANSKRIP_WEBHOOK_SECRET"]  # "whsec_..." utuh, termasuk awalannya


def verify_signature(raw_body: bytes, header: str, secret: str) -> bool:
    """raw_body = badan permintaan apa adanya (bytes), SEBELUM di-parse JSON."""
    t = None
    signatures = []
    for item in header.split(","):
        key, _, value = item.strip().partition("=")
        if key == "t":
            t = value
        elif key == "v1":
            signatures.append(value)  # bisa lebih dari satu (rahasia baru & lama)
    if t is None or not t.isdigit() or abs(time.time() - int(t)) > TOLERANCE:
        return False
    message = t.encode() + b"." + raw_body
    expected = hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()
    return any(hmac.compare_digest(expected.encode(), s.encode()) for s in signatures)


app = Flask(__name__)
seen = set()  # contoh; di produksi simpan id peristiwa di database/Redis


@app.post("/webhook/transkrip")
def transkrip_webhook():
    raw = request.get_data()
    if not verify_signature(raw, request.headers.get("Transkrip-Signature", ""), SECRET):
        abort(401)
    event = json.loads(raw)
    if event["id"] not in seen:  # peristiwa bisa tiba lebih dari sekali
        seen.add(event["id"])
        if event["type"] == "transcription.completed":
            print("Selesai:", event["data"]["id"])  # ambil hasil lewat GET di antrean Anda
    return "", 200

import crypto from "node:crypto";
import express from "express";

const TOLERANCE = 300; // detik
const SECRET = process.env.TRANSKRIP_WEBHOOK_SECRET; // "whsec_..." utuh, termasuk awalannya

/** rawBody = Buffer badan permintaan apa adanya, SEBELUM di-parse JSON. */
function verifySignature(rawBody, header, secret) {
  let t = null;
  const signatures = [];
  for (const item of (header ?? "").split(",")) {
    const i = item.indexOf("=");
    if (i < 0) continue;
    const key = item.slice(0, i).trim();
    const value = item.slice(i + 1).trim();
    if (key === "t") t = value;
    else if (key === "v1") signatures.push(value); // bisa lebih dari satu (rahasia baru & lama)
  }
  const ts = Number(t);
  if (!t || !Number.isSafeInteger(ts) || Math.abs(Date.now() / 1000 - ts) > TOLERANCE) {
    return false;
  }
  const expected = Buffer.from(
    crypto.createHmac("sha256", secret).update(`${t}.`).update(rawBody).digest("hex"),
  );
  return signatures.some((s) => {
    const got = Buffer.from(s);
    return got.length === expected.length && crypto.timingSafeEqual(got, expected);
  });
}

const app = express();
const seen = new Set(); // contoh; di produksi simpan id peristiwa di database/Redis

app.post("/webhook/transkrip", express.raw({ type: "application/json" }), (req, res) => {
  if (!verifySignature(req.body, req.get("Transkrip-Signature"), SECRET)) {
    return res.sendStatus(401);
  }
  const event = JSON.parse(req.body.toString("utf8"));
  if (!seen.has(event.id)) {
    // peristiwa bisa tiba lebih dari sekali
    seen.add(event.id);
    if (event.type === "transcription.completed") {
      console.log("Selesai:", event.data.id); // ambil hasil lewat GET di antrean Anda
    }
  }
  res.sendStatus(200);
});

app.listen(3000);

{
  "id": "trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1",
  "object": "transcription",
  "status": "completed",
  "created_at": 1792677149,
  "completed_at": 1792677901,
  "title": "Wawancara informan 3",
  "filename": "informan-3.m4a",
  "language": "id",
  "duration": 2832.4,
  "billed_minutes": 48,
  "price_idr": 2400,
  "charged_idr": 2400,
  "refunded": false,
  "num_speakers": 2,
  "progress": 1,
  "queue_position": null,
  "estimated_completion_at": null,
  "expires_at": 1795269149,
  "source": "api",
  "metadata": {
    "informan": "I-03"
  },
  "speakers": [
    {
      "id": "A",
      "label": "Pewawancara"
    },
    {
      "id": "B",
      "label": "Narasumber"
    }
  ],
  "text": "Sejak kapan usahanya berjalan? …",
  "segments": [
    {
      "id": 0,
      "start": 2.1,
      "end": 9.8,
      "speaker": "A",
      "text": "Sejak kapan usahanya berjalan?"
    },
    {
      "id": 1,
      "start": 10.4,
      "end": 18.2,
      "speaker": "B",
      "text": "Kurang lebih sejak 2019, Mas."
    }
  ],
  "error": null
}

{
  "status": "failed",
  "refunded": true,
  "error": {
    "code": "transcription_failed",
    "message": "…"
  }
}

curl "https://api.transkrip.online/v1/transcriptions?limit=20&status=completed" \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY"

{
  "object": "list",
  "data": [
    {
      "id": "trn_0f6c…",
      "object": "transcription",
      "status": "completed"
    }
  ],
  "first_id": "trn_0f6c…",
  "last_id": "trn_9b21…",
  "has_more": true
}

{
  "id": "trn_0f6c2b9e4d1a47c8b3e5a6f7d8c9b0a1",
  "object": "transcription",
  "deleted": true
}

curl https://api.transkrip.online/v1/transcriptions/estimate \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"upload_id": "upl_8a1f..."}'

{
  "upload_id": "upl_8a1f…",
  "duration": 2832.4,
  "billed_minutes": 48,
  "price_idr_per_minute": 50,
  "price_idr": 2400,
  "balance_idr": 5000,
  "enough_balance": true
}

{
  "object": "balance",
  "currency": "IDR",
  "balance_idr": 10000,
  "reserved_idr": 2400,
  "price_idr_per_minute": 50
}

# Word (.docx), sama dengan tombol Unduh di web
curl -o rapat.docx -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  "https://api.transkrip.online/v1/transcriptions/trn_0f6c.../export?format=docx"

# Subtitle
curl -o rapat.srt -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  "https://api.transkrip.online/v1/transcriptions/trn_0f6c.../export?format=srt"

# Teks polos tanpa stempel waktu
curl -o rapat.txt -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  "https://api.transkrip.online/v1/transcriptions/trn_0f6c.../export?format=txt&waktu=0"

curl https://api.transkrip.online/v1/audio/transcriptions \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -F model=transkrip-1 \
  -F [email protected] \
  -F language=id \
  -F response_format=srt

{
  "text": "Sejak kapan usahanya berjalan? …",
  "usage": {
    "type": "duration",
    "seconds": 2833
  }
}

{
  "task": "transcribe",
  "language": "indonesian",
  "duration": 2832.4,
  "text": "Sejak kapan usahanya berjalan? …",
  "segments": [
    {
      "id": 0,
      "seek": 0,
      "start": 2.1,
      "end": 9.8,
      "text": "Sejak kapan usahanya berjalan?",
      "tokens": [],
      "temperature": 0,
      "speaker": "A"
    }
  ],
  "usage": {
    "type": "duration",
    "seconds": 2833
  }
}

{
  "task": "transcribe",
  "duration": 2832.4,
  "text": "Sejak kapan usahanya berjalan? …",
  "segments": [
    {
      "type": "transcript.text.segment",
      "id": "seg_0",
      "start": 2.1,
      "end": 9.8,
      "text": "Sejak kapan usahanya berjalan?",
      "speaker": "A"
    }
  ],
  "speakers": [
    {
      "id": "A",
      "label": "Pewawancara"
    }
  ],
  "usage": {
    "type": "duration",
    "seconds": 2833
  }
}

{
  "error": {
    "message": "Transkrip belum selesai.",
    "type": "invalid_request_error",
    "code": "not_ready",
    "param": null
  }
}

curl https://api.transkrip.online/v1/transcriptions \
  -H "Authorization: Bearer $TRANSKRIP_API_KEY" \
  -H "Idempotency-Key: rapat-2026-10-21-ruang-3" \
  -F [email protected]