Orob API Documentation

import requests

resp = requests.post(
    "https://orob.ai/v1/chat/completions",
    headers={"Authorization": "Bearer bkb_YOUR_API_KEY"},
    json={
        "model": "auto",
        "messages": [{"role": "user", "content": "Explain quantum computing in one paragraph."}]
    }
)
print(resp.json()["choices"][0]["message"]["content"])

const resp = await fetch("https://orob.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "auto",
    messages: [{ role: "user", content: "Explain quantum computing in one paragraph." }]
  })
});
const data = await resp.json();
console.log(data.choices[0].message.content);

import requests

headers = {"Authorization": "Bearer bkb_YOUR_API_KEY"}

# Or alternatively:
# headers = {"X-Api-Key": "bkb_YOUR_API_KEY"}

resp = requests.post(
    "https://orob.ai/v1/chat/completions",
    headers=headers,
    json={"model": "auto", "messages": [{"role": "user", "content": "Hello"}]}
)
print(resp.json())

const headers = {
  "Authorization": "Bearer bkb_YOUR_API_KEY",
  "Content-Type": "application/json"
};

// Or alternatively:
// headers["X-Api-Key"] = "bkb_YOUR_API_KEY";

const resp = await fetch("https://orob.ai/v1/chat/completions", {
  method: "POST",
  headers,
  body: JSON.stringify({
    model: "auto",
    messages: [{ role: "user", content: "Hello" }]
  })
});
console.log(await resp.json());

import requests
import base64

with open("report.pdf", "rb") as f:
    b64 = base64.b64encode(f.read()).decode()

resp = requests.post(
    "https://orob.ai/api/chat",
    headers={"Authorization": "Bearer bkb_YOUR_API_KEY"},
    json={
        "messages": [{
            "role": "user",
            "content": "Summarize this document",
            "files": [{"name": "report.pdf", "type": "application/pdf", "data_b64": b64}]
        }]
    },
    stream=True
)

for line in resp.iter_lines():
    if line:
        print(line.decode())

const fileBuffer = await fs.promises.readFile("report.pdf");
const b64 = fileBuffer.toString("base64");

const resp = await fetch("https://orob.ai/api/chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [{
      role: "user",
      content: "Summarize this document",
      files: [{ name: "report.pdf", type: "application/pdf", data_b64: b64 }]
    }]
  })
});

const reader = resp.body.getReader();
const decoder = new TextDecoder();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

curl https://orob.ai/v1/chat/completions \
  -H "Authorization: Bearer bkb_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [{"role": "user", "content": "Write a haiku about APIs"}],
    "stream": true
  }'

const resp = await fetch("https://orob.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "auto",
    messages: [{ role: "user", content: "Write a haiku about APIs" }],
    stream: true
  })
});

const reader = resp.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  const text = decoder.decode(value);
  for (const line of text.split("\n")) {
    if (line.startsWith("data: ") && line !== "data: [DONE]") {
      const chunk = JSON.parse(line.slice(6));
      const content = chunk.choices?.[0]?.delta?.content;
      if (content) process.stdout.write(content);
    }
  }
}

curl https://orob.ai/v1/messages \
  -H "Authorization: Bearer bkb_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "auto",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Explain recursion simply."}]
  }'

const resp = await fetch("https://orob.ai/v1/messages", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json",
    "anthropic-version": "2023-06-01"
  },
  body: JSON.stringify({
    model: "auto",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Explain recursion simply." }]
  })
});
const data = await resp.json();
console.log(data.content[0].text);

import requests

resp = requests.post(
    "https://orob.ai/api/route",
    headers={"Authorization": "Bearer bkb_YOUR_API_KEY"},
    json={"prompt": "Write a Python script that scrapes news headlines"}
)
data = resp.json()
print(f"Category: {data['category']}")
print(f"Subcategory: {data['subcategory']}")
print(f"Recommended model: {data['model']}")

const resp = await fetch("https://orob.ai/api/route", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    prompt: "Write a Python script that scrapes news headlines"
  })
});
const data = await resp.json();
console.log(`Category: ${data.category}`);
console.log(`Recommended model: ${data.model}`);

import requests

resp = requests.get(
    "https://orob.ai/api/pricing",
    headers={"Authorization": "Bearer bkb_YOUR_API_KEY"}
)
for model in resp.json()["models"]:
    print(f"{model['name']}: ${model['inputPer1M']}/1M input, ${model['outputPer1M']}/1M output")

const resp = await fetch("https://orob.ai/api/pricing", {
  headers: { "Authorization": "Bearer bkb_YOUR_API_KEY" }
});
const { models } = await resp.json();
models.forEach(m =>
  console.log(`${m.name}: $${m.inputPer1M}/1M input, $${m.outputPer1M}/1M output`)
);

# Base64 encode your file first
B64=$(base64 -i data.xlsx)

curl https://orob.ai/api/chat \
  -H "Authorization: Bearer bkb_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"Analyze this spreadsheet\",
      \"files\": [{\"name\": \"data.xlsx\", \"type\": \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\", \"data_b64\": \"$B64\"}]
    }]
  }"

const fs = require("fs");
const b64 = fs.readFileSync("data.xlsx").toString("base64");

const resp = await fetch("https://orob.ai/api/chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [{
      role: "user",
      content: "Analyze this spreadsheet",
      files: [{ name: "data.xlsx", type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", data_b64: b64 }]
    }]
  })
});

import requests

headers = {"Authorization": "Bearer bkb_YOUR_API_KEY"}

# Check credit balance
summary = requests.get("https://orob.ai/api/usage/summary", headers=headers).json()
print(f"Credits remaining: {summary['credits']}")

# Per-model breakdown
by_model = requests.get("https://orob.ai/api/usage/by-model", headers=headers).json()
for entry in by_model["models"]:
    print(f"  {entry['model']}: ${entry['cost']:.4f}")

# Redeem promo code
result = requests.post(
    "https://orob.ai/api/redeem",
    headers=headers,
    json={"code": "WELCOME50"}
)
print(result.json())

const headers = { "Authorization": "Bearer bkb_YOUR_API_KEY" };

// Check credit balance
const summary = await fetch("https://orob.ai/api/usage/summary", { headers });
const { credits } = await summary.json();
console.log(`Credits remaining: ${credits}`);

// Per-model breakdown
const byModel = await fetch("https://orob.ai/api/usage/by-model", { headers });
const { models } = await byModel.json();
models.forEach(m => console.log(`  ${m.model}: $${m.cost.toFixed(4)}`));

// Redeem promo code
const result = await fetch("https://orob.ai/api/redeem", {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ code: "WELCOME50" })
});
console.log(await result.json());

const resp = await fetch("https://orob.ai/api/chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer bkb_YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [{ role: "user", content: "Create a PDF report about AI trends" }]
  })
});

const reader = resp.body.getReader();
const decoder = new TextDecoder();
let buffer = "";

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });

  const lines = buffer.split("\n");
  buffer = lines.pop();

  for (const line of lines) {
    if (!line.startsWith("data: ")) continue;
    const event = JSON.parse(line.slice(6));

    switch (event.type) {
      case "meta":    console.log(`Routed to: ${event.model}`); break;
      case "token":   process.stdout.write(event.text); break;
      case "file":    console.log(`\nFile: ${event.fileName} -> ${event.fileUrl}`); break;
      case "done":    console.log(`\nCost: $${event.costUsd} | ${event.latencyMs}ms`); break;
      case "error":   console.error(`Error: ${event.error}`); break;
    }
  }
}

data: {"type": "error", "error": "Model unavailable, retrying with fallback..."}

data: {"type": "error", "error": "Insufficient credits to complete this request"}

async function callWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const resp = await fetch(url, options);
    if (resp.status === 429) {
      const wait = Math.pow(2, attempt) + Math.random();
      await new Promise(r => setTimeout(r, wait * 1000));
      continue;
    }
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    return resp.json();
  }
  throw new Error("Max retries exceeded");
}

import requests

headers = {"Authorization": "Bearer bkb_YOUR_API_KEY"}

# Create a new key
new_key = requests.post(
    "https://orob.ai/api/keys",
    headers=headers,
    json={"name": "Production"}
).json()
print(f"New key: {new_key['key']}")  # Full key shown only at creation

# List all keys
keys = requests.get("https://orob.ai/api/keys", headers=headers).json()
for k in keys["keys"]:
    print(f"  {k['name']}: {k['prefix']}... (created {k['created_at']})")

# Revoke a key
requests.delete(f"https://orob.ai/api/keys/{key_id}", headers=headers)

const headers = {
  "Authorization": "Bearer bkb_YOUR_API_KEY",
  "Content-Type": "application/json"
};

// Create a new key
const newKey = await fetch("https://orob.ai/api/keys", {
  method: "POST", headers,
  body: JSON.stringify({ name: "Production" })
}).then(r => r.json());
console.log(`New key: ${newKey.key}`);

// List all keys
const { keys } = await fetch("https://orob.ai/api/keys", { headers }).then(r => r.json());
keys.forEach(k => console.log(`  ${k.name}: ${k.prefix}...`));

// Revoke a key
await fetch(`https://orob.ai/api/keys/${keyId}`, {
  method: "DELETE", headers
});