import requests
import time

API_KEY = "alef_sk_live_your_key_here"
BASE_URL = "https://alef-bot.top/api/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
FILE_PATH = "audio.mp3"

upload_res = requests.post(
    f"{BASE_URL}/uploads",
    headers=HEADERS,
    json={"filename": "audio.mp3", "content_type": "audio/mpeg", "size_bytes": 1024}
).json()

with open(FILE_PATH, "rb") as f:
    requests.put(upload_res["upload_url"], data=f)

job_res = requests.post(
    f"{BASE_URL}/transcriptions",
    headers=HEADERS,
    json={
        "upload_id": upload_res["upload_id"],
        "output_format": "srt" 
    }
).json()
job_id = job_res["job_id"]

while True:
    status_res = requests.get(f"{BASE_URL}/transcriptions/{job_id}", headers=HEADERS).json()
    if status_res["status"] == "completed":
        break
    elif status_res["status"] == "failed":
        print("Transcription failed")
        exit(1)
    time.sleep(5)

srt_content = requests.get(
    f"{BASE_URL}/transcriptions/{job_id}/artifact?format=srt",
    headers=HEADERS
).text

print(srt_content)

const fs = require('fs');

const API_KEY = "alef_sk_live_your_key_here";
const BASE_URL = "https://alef-bot.top/api/v1";
const HEADERS = { "Authorization": `Bearer ${API_KEY}` };

async function transcribe() {
  const uploadRes = await fetch(`${BASE_URL}/uploads`, {
    method: 'POST',
    headers: { ...HEADERS, 'Content-Type': 'application/json' },
    body: JSON.stringify({ filename: "audio.mp3", content_type: "audio/mpeg", size_bytes: 1024 })
  }).then(r => r.json());

  const fileData = fs.readFileSync("audio.mp3");
  await fetch(uploadRes.upload_url, { method: 'PUT', body: fileData });

  const jobRes = await fetch(`${BASE_URL}/transcriptions`, {
    method: 'POST',
    headers: { ...HEADERS, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      upload_id: uploadRes.upload_id,
      output_format: "srt" 
    })
  }).then(r => r.json());

  const jobId = jobRes.job_id;

  while (true) {
    const statusRes = await fetch(`${BASE_URL}/transcriptions/${jobId}`, { headers: HEADERS }).then(r => r.json());
    if (statusRes.status === "completed") break;
    if (statusRes.status === "failed") throw new Error("Job failed");
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  const srtContent = await fetch(`${BASE_URL}/transcriptions/${jobId}/artifact?format=srt`, { headers: HEADERS }).then(r => r.text());
  console.log(srtContent);
}

transcribe();

const API_KEY = "alef_sk_live_your_key_here";
const BASE_URL = "https://alef-bot.top/api/v1";
const FILE_INPUT_SELECTOR = "#audio-file";

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

async function transcribeFromBrowserFile() {
  const fileInput = document.querySelector(FILE_INPUT_SELECTOR);
  const file = fileInput?.files?.[0];
  if (!file) {
    throw new Error("Select a file in an <input type=\"file\" id=\"audio-file\"> first.");
  }

  const authHeaders = { Authorization: "Bearer " + API_KEY };

  const uploadRes = await fetch(BASE_URL + "/uploads", {
    method: "POST",
    headers: { ...authHeaders, "Content-Type": "application/json" },
    body: JSON.stringify({
      filename: file.name,
      content_type: file.type || "audio/mpeg",
      size_bytes: file.size,
    }),
  });
  if (!uploadRes.ok) throw new Error("Failed creating upload slot: " + uploadRes.status);
  const upload = await uploadRes.json();

  const uploadBinaryRes = await fetch(upload.upload_url, {
    method: "PUT",
    headers: authHeaders,
    body: file,
  });
  if (!uploadBinaryRes.ok) throw new Error("Failed uploading bytes: " + uploadBinaryRes.status);

  const jobRes = await fetch(BASE_URL + "/transcriptions", {
    method: "POST",
    headers: { ...authHeaders, "Content-Type": "application/json" },
    body: JSON.stringify({
      upload_id: upload.upload_id,
      output_format: "srt",
    }),
  });
  if (!jobRes.ok) throw new Error("Failed creating job: " + jobRes.status);
  const job = await jobRes.json();

  while (true) {
    const statusRes = await fetch(BASE_URL + "/transcriptions/" + job.job_id, { headers: authHeaders });
    const status = await statusRes.json();
    if (status.status === "completed") break;
    if (status.status === "failed") throw new Error("Transcription failed");
    await wait(5000);
  }

  const artifactRes = await fetch(BASE_URL + "/transcriptions/" + job.job_id + "/artifact?format=srt", {
    headers: authHeaders,
  });
  if (!artifactRes.ok) throw new Error("Failed downloading artifact: " + artifactRes.status);
  const srt = await artifactRes.text();
  console.log(srt);
}

transcribeFromBrowserFile().catch(console.error);

const crypto = require("crypto");

function sortKeysDeep(value) {
  if (Array.isArray(value)) return value.map(sortKeysDeep);
  if (!value || typeof value !== "object") return value;
  return Object.keys(value)
    .sort()
    .reduce((acc, key) => {
      acc[key] = sortKeysDeep(value[key]);
      return acc;
    }, {});
}

function verifyAlefbotSignature(body, timestamp, signature, secret) {
  const payload = JSON.stringify(sortKeysDeep(body));
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${timestamp}.${payload}`)
    .digest("hex");
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

async function verifyAlefbotSignature(body, timestamp, signatureHex, secret) {
  const canonical = JSON.stringify(sortKeysDeep(body));
  const data = new TextEncoder().encode(timestamp + "." + canonical);
  const keyData = new TextEncoder().encode(secret);

  const cryptoKey = await crypto.subtle.importKey(
    "raw",
    keyData,
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["sign"]
  );

  const signed = await crypto.subtle.sign("HMAC", cryptoKey, data);
  const expectedHex = [...new Uint8Array(signed)]
    .map((byte) => byte.toString(16).padStart(2, "0"))
    .join("");

  return timingSafeEqualHex(expectedHex, signatureHex);
}

function sortKeysDeep(value) {
  if (Array.isArray(value)) return value.map(sortKeysDeep);
  if (!value || typeof value !== "object") return value;
  return Object.keys(value)
    .sort()
    .reduce((acc, key) => {
      acc[key] = sortKeysDeep(value[key]);
      return acc;
    }, {});
}

function timingSafeEqualHex(a, b) {
  if (a.length !== b.length) return false;
  let diff = 0;
  for (let i = 0; i < a.length; i += 1) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
  return diff === 0;
}

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.post(
    f"{BASE_URL}/keys",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "name": "CI Read Only",
        "scope": "read_only",
        "mode": "test",
    },
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createKey() {
  const response = await fetch(BASE_URL + "/keys", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: "CI Read Only",
      scope: "read_only",
      mode: "test",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

createKey().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createKey() {
  const response = await fetch(BASE_URL + "/keys", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: "CI Read Only",
      scope: "read_only",
      mode: "test",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

createKey().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.get(
    f"{BASE_URL}/keys",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function listKeys() {
  const response = await fetch(BASE_URL + "/keys", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

listKeys().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function listKeys() {
  const response = await fetch(BASE_URL + "/keys", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

listKeys().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.get(
    f"{BASE_URL}/account",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function getAccountContext() {
  const response = await fetch(BASE_URL + "/account", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

getAccountContext().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function getAccountContext() {
  const response = await fetch(BASE_URL + "/account", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

getAccountContext().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.post(
    f"{BASE_URL}/uploads",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "filename": "lecture.mp3",
        "content_type": "audio/mpeg",
        "size_bytes": 2048,
    },
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createUploadSlot() {
  const response = await fetch(BASE_URL + "/uploads", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      filename: "lecture.mp3",
      content_type: "audio/mpeg",
      size_bytes: 2048,
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

createUploadSlot().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createUploadSlot() {
  const response = await fetch(BASE_URL + "/uploads", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      filename: "lecture.mp3",
      content_type: "audio/mpeg",
      size_bytes: 2048,
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

createUploadSlot().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"
UPLOAD_ID = "upl_02f4c48f7fc74ec58cc6"
FILE_PATH = "lecture.mp3"

with open(FILE_PATH, "rb") as file_obj:
    response = requests.put(
        f"{BASE_URL}/uploads/{UPLOAD_ID}/binary",
        headers={"Authorization": f"Bearer {API_KEY}"},
        data=file_obj,
        timeout=120,
    )
response.raise_for_status()
print(response.json())

const fs = require("node:fs");

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const UPLOAD_ID = "upl_02f4c48f7fc74ec58cc6";

async function uploadBinary() {
  const fileBytes = fs.readFileSync("lecture.mp3");
  const response = await fetch(BASE_URL + "/uploads/" + UPLOAD_ID + "/binary", {
    method: "PUT",
    headers: { Authorization: "Bearer " + API_KEY },
    body: fileBytes,
  });

  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

uploadBinary().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const UPLOAD_ID = "upl_02f4c48f7fc74ec58cc6";

async function uploadBinaryFromBrowser() {
  const fileInput = document.querySelector("#audio-file");
  const file = fileInput?.files?.[0];
  if (!file) throw new Error("Select a file in <input type=\"file\" id=\"audio-file\">.");

  const response = await fetch(BASE_URL + "/uploads/" + UPLOAD_ID + "/binary", {
    method: "PUT",
    headers: { Authorization: "Bearer " + API_KEY },
    body: file,
  });

  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

uploadBinaryFromBrowser().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.post(
    f"{BASE_URL}/transcriptions",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "upload_id": "upl_02f4c48f7fc74ec58cc6",
        "translate_to_hebrew": False,
        "output_format": "srt",
    },
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createTranscription() {
  const response = await fetch(BASE_URL + "/transcriptions", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      upload_id: "upl_02f4c48f7fc74ec58cc6",
      translate_to_hebrew: false,
      output_format: "srt",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

createTranscription().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function createTranscription() {
  const response = await fetch(BASE_URL + "/transcriptions", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      upload_id: "upl_02f4c48f7fc74ec58cc6",
      translate_to_hebrew: false,
      output_format: "srt",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

createTranscription().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.get(
    f"{BASE_URL}/transcriptions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"limit": 20, "cursor": 0},
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function listTranscriptions() {
  const params = new URLSearchParams({ limit: "20", cursor: "0" });
  const response = await fetch(BASE_URL + "/transcriptions?" + params.toString(), {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

listTranscriptions().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function listTranscriptions() {
  const params = new URLSearchParams({ limit: "20", cursor: "0" });
  const response = await fetch(BASE_URL + "/transcriptions?" + params.toString(), {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

listTranscriptions().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"
JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3"

response = requests.get(
    f"{BASE_URL}/transcriptions/{JOB_ID}",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3";

async function getTranscriptionStatus() {
  const response = await fetch(BASE_URL + "/transcriptions/" + JOB_ID, {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

getTranscriptionStatus().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3";

async function getTranscriptionStatus() {
  const response = await fetch(BASE_URL + "/transcriptions/" + JOB_ID, {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

getTranscriptionStatus().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"
JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3"

response = requests.get(
    f"{BASE_URL}/transcriptions/{JOB_ID}/artifact",
    params={"format": "srt"},
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=30,
)
response.raise_for_status()
with open("result.srt", "wb") as file_obj:
    file_obj.write(response.content)
print("Saved result.srt")

const fs = require("node:fs/promises");

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3";

async function downloadArtifact() {
  const response = await fetch(BASE_URL + "/transcriptions/" + JOB_ID + "/artifact?format=srt", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));

  const content = await response.text();
  await fs.writeFile("result.srt", content, "utf8");
  console.log("Saved result.srt");
}

downloadArtifact().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";
const JOB_ID = "ac69835f-0575-4429-a95f-1fbc977bb4d3";

async function downloadArtifact() {
  const response = await fetch(BASE_URL + "/transcriptions/" + JOB_ID + "/artifact?format=srt", {
    headers: { Authorization: "Bearer " + API_KEY },
  });
  if (!response.ok) throw new Error("Request failed: " + response.status);

  const blob = await response.blob();
  const downloadUrl = URL.createObjectURL(blob);
  const anchor = document.createElement("a");
  anchor.href = downloadUrl;
  anchor.download = "result.srt";
  anchor.click();
  URL.revokeObjectURL(downloadUrl);
}

downloadArtifact().catch(console.error);

import requests

API_KEY = "alef_sk_live_primary"
BASE_URL = "https://alef-bot.top/api/v1"

response = requests.post(
    f"{BASE_URL}/webhooks/test",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "webhook_url": "https://client.example.com/webhooks/alefbot",
        "event_type": "transcription.completed",
    },
    timeout=30,
)
response.raise_for_status()
print(response.json())

const API_KEY = process.env.ALEFBOT_API_KEY ?? "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function sendWebhookTest() {
  const response = await fetch(BASE_URL + "/webhooks/test", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      webhook_url: "https://client.example.com/webhooks/alefbot",
      event_type: "transcription.completed",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status + " " + (await response.text()));
  console.log(await response.json());
}

sendWebhookTest().catch(console.error);

const API_KEY = "alef_sk_live_primary";
const BASE_URL = "https://alef-bot.top/api/v1";

async function sendWebhookTest() {
  const response = await fetch(BASE_URL + "/webhooks/test", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      webhook_url: "https://client.example.com/webhooks/alefbot",
      event_type: "transcription.completed",
    }),
  });

  if (!response.ok) throw new Error("Request failed: " + response.status);
  const data = await response.json();
  console.log(data);
}

sendWebhookTest().catch(console.error);