DocParser API

X-API-Key: dp_YOUR_API_KEY

curl -X POST https://docparser.deconbear.cn/parse \
  -F "file=@paper.pdf" \
  -F "engine=struct" \
  -H "X-API-Key: dp_YOUR_KEY"

import requests

r = requests.post(
    "https://docparser.deconbear.cn/parse",
    files={"file": open("paper.pdf", "rb")},
    data={"engine": "struct"},
    headers={"X-API-Key": "dp_YOUR_KEY"},
)
print(r.json())  # {"task_id":"...", "status":"queued"}

const form = new FormData();
form.append("file", pdfFile);
form.append("engine", "struct");

const res = await fetch("https://docparser.deconbear.cn/parse", {
  method: "POST",
  headers: { "X-API-Key": "dp_YOUR_KEY" },
  body: form,
});
const { task_id } = await res.json();
// {"task_id":"...", "status":"queued"}

curl -H "X-API-Key: dp_YOUR_KEY" \
  https://docparser.deconbear.cn/status/TASK_ID

import time

while True:
    r = requests.get(
        f"https://docparser.deconbear.cn/status/{task_id}",
        headers={"X-API-Key": "dp_YOUR_KEY"},
    )
    status = r.json()["status"]
    if status in ("success", "failure"):
        break
    time.sleep(5)

let status: string;
do {
  await new Promise(r => setTimeout(r, 5000));
  const res = await fetch(
    `https://docparser.deconbear.cn/status/${task_id}`,
    { headers: { "X-API-Key": "dp_YOUR_KEY" } },
  );
  ({ status } = await res.json());
} while (status !== "success" && status !== "failure");

curl -H "X-API-Key: dp_YOUR_KEY" \
  https://docparser.deconbear.cn/result/TASK_ID

r = requests.get(
    f"https://docparser.deconbear.cn/result/{task_id}",
    headers={"X-API-Key": "dp_YOUR_KEY"},
)
data = r.json()
print(f"Engine: {data['engine']}, Time: {data['parse_time_s']:.1f}s")
print(data["markdown"])

const res = await fetch(
  `https://docparser.deconbear.cn/result/${task_id}`,
  { headers: { "X-API-Key": "dp_YOUR_KEY" } },
);
const { markdown, engine, parse_time_s } = await res.json();
console.log(`Engine: ${engine}, Time: ${parse_time_s}s`);
console.log(markdown);

{"task_id": "f3a1b9c0d2e4", "status": "queued", "message": "Task submitted"}

{
  "task_id": "f3a1b9c0d2e4",
  "status": "started",
  "engine": "struct",
  "created_at": "2025-06-15T14:32:00Z",
  "started_at": "2025-06-15T14:32:05Z",
  "completed_at": null,
  "error": null
}

{
  "task_id": "f3a1b9c0d2e4",
  "status": "success",
  "markdown": "# Paper Title\n\n## Abstract\n\n...",
  "engine": "struct",
  "parse_time_s": 42.3,
  "error": null
}

{"task_id": "f3a1b9c0d2e4", "status": "revoked"}

{
  "status": "healthy",
  "gpus": [{"index":0, "name":"NVIDIA GeForce RTX 4090",
            "utilization_pct":15.0, "memory_pct":33.3}],
  "redis_connected": true,
  "workers": 2
}

import requests
import time

HOST = "https://docparser.deconbear.cn"
HEADERS = {"X-API-Key": "dp_YOUR_KEY"}


def parse_pdf(filepath: str, engine: str = "struct") -> str | None:
    # 1. Submit
    with open(filepath, "rb") as f:
        r = requests.post(
            f"{HOST}/parse",
            files={"file": f},
            data={"engine": engine},
            headers=HEADERS,
        )
    r.raise_for_status()
    task_id = r.json()["task_id"]
    print(f"Task submitted: {task_id}")

    # 2. Poll until done
    while True:
        r = requests.get(
            f"{HOST}/status/{task_id}",
            headers=HEADERS,
        )
        r.raise_for_status()
        status = r.json()["status"]
        print(f"  {status}")
        if status in ("success", "failure"):
            break
        time.sleep(5)

    if status == "failure":
        raise RuntimeError(f"Parse failed: {r.json().get('error')}")

    # 3. Get result
    r = requests.get(
        f"{HOST}/result/{task_id}",
        headers=HEADERS,
    )
    r.raise_for_status()
    data = r.json()
    print(f"Done. engine={data['engine']}, time={data['parse_time_s']:.1f}s")
    return data["markdown"]


if __name__ == "__main__":
    md = parse_pdf("paper.pdf", "struct")
    print(md[:500])

/**
 * DocParser API — complete TypeScript example
 * Requires: Node.js 18+ (built-in fetch)
 */
const HOST = "https://docparser.deconbear.cn";
const KEY = "dp_YOUR_KEY";

interface ParseResponse {
  task_id: string;
  status: string;
  message: string;
}

interface TaskStatus {
  task_id: string;
  status: "queued" | "started" | "retrying" | "success" | "failure";
  engine: string;
  error: string | null;
}

interface TaskResult {
  task_id: string;
  status: string;
  markdown: string | null;
  engine: string | null;
  parse_time_s: number | null;
  error: string | null;
}

async function parsePDF(
  file: File | Blob,
  engine: "struct" | "polyglot" = "struct",
): Promise {
  // 1. Submit
  const form = new FormData();
  form.append("file", file);
  form.append("engine", engine);

  const submitRes = await fetch(`${HOST}/parse`, {
    method: "POST",
    headers: { "X-API-Key": KEY },
    body: form,
  });
  if (!submitRes.ok) {
    throw new Error(`Submit failed: ${submitRes.status}`);
  }
  const { task_id } = (await submitRes.json()) as ParseResponse;

  // 2. Poll until done
  let status: string;
  do {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    const statusRes = await fetch(`${HOST}/status/${task_id}`, {
      headers: { "X-API-Key": KEY },
    });
    if (!statusRes.ok) {
      throw new Error(`Status check failed: ${statusRes.status}`);
    }
    ({ status } = (await statusRes.json()) as TaskStatus);
  } while (status !== "success" && status !== "failure");

  if (status === "failure") {
    throw new Error("PDF parsing failed");
  }

  // 3. Get result
  const resultRes = await fetch(`${HOST}/result/${task_id}`, {
    headers: { "X-API-Key": KEY },
  });
  if (!resultRes.ok) {
    throw new Error(`Result fetch failed: ${resultRes.status}`);
  }

  const { markdown } = (await resultRes.json()) as TaskResult;
  if (markdown === null) {
    throw new Error("Empty result");
  }
  return markdown;
}

// Usage (Node.js)
import { readFileSync } from "node:fs";
const pdfBlob = new Blob([readFileSync("paper.pdf")]);
const markdown = await parsePDF(pdfBlob, "struct");
console.log(markdown.slice(0, 500));