curl -X POST \
  -H "X-API-Key: your-api-key" \
  -F file=@input.pdf \
  "https://prod.visionapi.unsiloed.ai/v3/parse"

curl -X POST \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/your-paper.pdf"}' \
  "https://prod.visionapi.unsiloed.ai/v3/parse"

KEY=your-api-key
API=https://prod.visionapi.unsiloed.ai/v3/parse

UP=$(curl -s -X POST -H "X-API-Key: $KEY" "$API/upload")
FILE_ID=$(jq -r .file_id <<< "$UP")
UPLOAD_URL=$(jq -r .upload_url <<< "$UP")

curl -X PUT \
  -H "Content-Type: application/pdf" \
  --upload-file big.pdf \
  "$UPLOAD_URL"

curl -X POST \
  -H "X-API-Key: $KEY" \
  -H "Content-Type: application/json" \
  -d "{\"file_id\":\"$FILE_ID\"}" \
  "$API"

curl -X POST \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/my-bench.tar.gz"}' \
  "https://prod.visionapi.unsiloed.ai/v3/parse/batch"

import os, time, requests

API = "https://prod.visionapi.unsiloed.ai/v3/parse"
KEY = os.environ["UNSILOED_API_KEY"]
HEADERS = {"X-API-Key": KEY}

# Small PDF (≤ 3 MB) — body shape 1
def submit_small(pdf_path: str) -> str:
    with open(pdf_path, "rb") as f:
        r = requests.post(
            API,
            headers=HEADERS,
            files={"file": (os.path.basename(pdf_path), f, "application/pdf")},
        )
    r.raise_for_status()
    return r.json()["job_id"]

# Caller-hosted URL — body shape 2
def submit_url(url: str) -> str:
    r = requests.post(
        API,
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"url": url},
    )
    r.raise_for_status()
    return r.json()["job_id"]

# Large PDF via presigned upload — body shape 3
def submit_large(pdf_path: str) -> str:
    up = requests.post(f"{API}/upload", headers=HEADERS).json()
    file_id, upload_url = up["file_id"], up["upload_url"]
    with open(pdf_path, "rb") as f:
        requests.put(
            upload_url,
            headers={"Content-Type": "application/pdf"},
            data=f,
        ).raise_for_status()
    r = requests.post(
        API,
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"file_id": file_id},
    )
    r.raise_for_status()
    return r.json()["job_id"]

# Poll until done or failed
def wait(job_id: str) -> dict:
    while True:
        body = requests.get(f"{API}/{job_id}", headers=HEADERS).json()
        if body["status"] in ("done", "failed"):
            return body
        time.sleep(5)

job = submit_small("input.pdf")
result = wait(job)
if result["status"] == "done":
    for p in result["pages"]:
        print(f"--- page {p['page']} ---")
        print(p["markdown"])
else:
    print("FAILED:", result.get("error"))

const API = "https://prod.visionapi.unsiloed.ai/v3/parse";
const KEY = process.env.UNSILOED_API_KEY;

// Body shape 1 — small PDF via multipart
async function submitSmall(file) {
  const form = new FormData();
  form.append("file", file);
  const r = await fetch(API, { method: "POST",
    headers: { "X-API-Key": KEY }, body: form });
  if (!r.ok) throw new Error(`submit failed: ${r.status}`);
  return (await r.json()).job_id;
}

// Body shape 2 — caller-hosted URL
async function submitUrl(url) {
  const r = await fetch(API, { method: "POST",
    headers: { "X-API-Key": KEY, "Content-Type": "application/json" },
    body: JSON.stringify({ url }) });
  if (!r.ok) throw new Error(`submit failed: ${r.status}`);
  return (await r.json()).job_id;
}

// Body shape 3 — presigned upload for large files
async function submitLarge(file) {
  const up = await (await fetch(`${API}/upload`, { method: "POST",
    headers: { "X-API-Key": KEY } })).json();
  await fetch(up.upload_url, { method: "PUT",
    headers: { "Content-Type": "application/pdf" }, body: file });
  const r = await fetch(API, { method: "POST",
    headers: { "X-API-Key": KEY, "Content-Type": "application/json" },
    body: JSON.stringify({ file_id: up.file_id }) });
  if (!r.ok) throw new Error(`submit failed: ${r.status}`);
  return (await r.json()).job_id;
}

async function wait(jobId) {
  while (true) {
    const r = await fetch(`${API}/${jobId}`, { headers: { "X-API-Key": KEY } });
    const body = await r.json();
    if (body.status === "done" || body.status === "failed") return body;
    await new Promise(res => setTimeout(res, 5000));
  }
}

{
  "job_id":     "5eb3493042f84af5860531df5b18c56b",
  "status":     "queued",
  "created_at": "2026-05-11T18:47:26Z"
}

{
  "file_id":             "527f4097f3d1...",
  "upload_url":          "https://...s3.amazonaws.com/...?X-Amz-Signature=...",
  "upload_method":       "PUT",
  "upload_content_type": "application/pdf",
  "max_bytes":           52428800,
  "expires_in":          3600
}

{
  "job_id":      "5eb3493042f84af5860531df5b18c56b",
  "status":      "done",
  "file_name":   "input.pdf",
  "started_at":  "2026-05-11T18:47:36Z",
  "finished_at": "2026-05-11T18:47:53Z",
  "page_count":  1,
  "pages": [
    { "page": 1, "markdown": "Example 4.28. Let us use Proposition 4.26 ..." }
  ]
}

{
  "job_id":     "...",
  "status":     "done",
  "source_url": "https://example.com/my-bench.tar.gz",
  "pdf_count":  3,
  "documents": [
    { "pdf": "doc1.pdf", "page_count": 1,
      "pages": [{ "page": 1, "markdown": "..." }] },
    { "pdf": "doc2.pdf", "page_count": 2,
      "pages": [{ "page": 1, "markdown": "..." }, { "page": 2, "markdown": "..." }] }
  ]
}

{
  "job_id":     "...",
  "status":     "failed",
  "created_at": "...",
  "error":      "PDF exceeds size limit (50 MB)"
}