Documents in, JSON out

# 1. Create your key in the app (every plan, free included): https://app.whappscan.com -> API
export WHAPPSCAN_KEY=wsk_xxxxxxxxxxxxxxxx
BASE=https://api.whappscan.com

# 2. Upload a PDF or a photo -> HTTP 202 and a result_id
curl -s -X POST "$BASE/api/v1/process" \
  -H "X-API-Key: $WHAPPSCAN_KEY" \
  -F "file=@invoice.pdf;type=application/pdf"

# 3. Poll until "status" is "done" (every 2-3 seconds)
curl -s "$BASE/api/v1/results/RESULT_ID" -H "X-API-Key: $WHAPPSCAN_KEY"

{
  "success": true,
  "result_id": "bd929a0f-de95-4321-97a4-abdc5d078da2",
  "status": "done",
  "scanner_name": "Business card",
  "tokens_used": 1,
  "confidence": 0.95,
  "extracted_data": {
    "fields": [
      {
        "name": "contacts",
        "value_type": "table",
        "confidence": 0.95,
        "value": [
          { "full_name": "Sofia Wong", "company_name": "Sunway Packaging",
            "job_title": "Procurement Lead", "phone": "+60 17-716 7035",
            "email": "sofia.wong@sunwaypackaging.example", "website": null }
        ]
      }
    ]
  }
}

curl -s -X POST "$BASE/api/v1/scanners" \
  -H "X-API-Key: $WHAPPSCAN_KEY" -H "Content-Type: application/json" \
  -d '{
    "name": "Supplier invoice",
    "fields": [
      {"name": "invoice_number", "type": "string", "description": "Invoice number as printed"},
      {"name": "total_amount", "type": "currency"},
      {"name": "lines", "type": "table", "item_fields": [
        {"name": "description", "type": "string"},
        {"name": "quantity", "type": "number"},
        {"name": "amount", "type": "currency"}]}
    ]}'

Use the WhappScan API to extract data from documents.
Spec: https://whappscan.com/openapi.json  (docs: https://whappscan.com/en/api)
Auth: header X-API-Key from the env var WHAPPSCAN_KEY.
Flow: POST /api/v1/process (multipart, field "file") -> result_id -> poll GET /api/v1/results/{id} every 2-3 s until status is "done".
Read extracted_data.fields[].value. On 402 tell me the next_action; on 429 wait Retry-After; files must be under ~4.4 MB.

import mimetypes, os, time, requests

BASE = "https://api.whappscan.com"
HEADERS = {"X-API-Key": os.environ["WHAPPSCAN_KEY"]}

def extract(path, scanner_id=None, timeout=180):
    """Upload a document and return the extracted fields as a dict {name: value}."""
    url = f"{BASE}/api/v1/scanners/{scanner_id}/upload" if scanner_id else f"{BASE}/api/v1/process"
    mime = mimetypes.guess_type(path)[0] or "application/pdf"  # the API needs the part's content type
    with open(path, "rb") as f:
        r = requests.post(url, headers=HEADERS, files={"file": (os.path.basename(path), f, mime)})
    if r.status_code == 402:   # no pages left: r.json()["next_action"] says what to do
        raise RuntimeError(r.json()["next_action"])
    if r.status_code == 413:   # over ~4.4 MB: lower the resolution or compress the PDF
        raise RuntimeError("file too large")
    r.raise_for_status()
    result_id = r.json()["result_id"]

    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(2.5)
        res = requests.get(f"{BASE}/api/v1/results/{result_id}", headers=HEADERS)
        if res.status_code == 429:  # rate limited: wait what the server says
            time.sleep(int(res.headers.get("Retry-After", 5)))
            continue
        res.raise_for_status()
        data = res.json()
        if data["status"] == "done":
            return {f["name"]: f["value"] for f in data["extracted_data"]["fields"]}
        if data["status"] in ("error", "rejected"):
            raise RuntimeError(f'{data.get("error_code")}: {data.get("error_message")}')
    raise TimeoutError("still processing")

print(extract("invoice.pdf"))

// Node 18+ (fetch, FormData and Blob are built in)
import { readFile } from "node:fs/promises";
import { basename } from "node:path";

const BASE = "https://api.whappscan.com";
const headers = { "X-API-Key": process.env.WHAPPSCAN_KEY };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function extract(path, mime = "application/pdf", scannerId) {
  const form = new FormData();
  form.append("file", new Blob([await readFile(path)], { type: mime }), basename(path));
  const url = scannerId ? `${BASE}/api/v1/scanners/${scannerId}/upload` : `${BASE}/api/v1/process`;
  const up = await fetch(url, { method: "POST", headers, body: form });
  if (up.status === 402) throw new Error(JSON.stringify((await up.json()).next_action));
  if (!up.ok) throw new Error(`upload failed: ${up.status} ${await up.text()}`);
  const { result_id } = await up.json();

  for (let i = 0; i < 80; i++) {
    await sleep(2500);
    const res = await fetch(`${BASE}/api/v1/results/${result_id}`, { headers });
    if (res.status === 429) { await sleep(Number(res.headers.get("retry-after") || 5) * 1000); continue; }
    const data = await res.json();
    if (data.status === "done") return Object.fromEntries(data.extracted_data.fields.map((f) => [f.name, f.value]));
    if (["error", "rejected"].includes(data.status)) throw new Error(`${data.error_code}: ${data.error_message}`);
  }
  throw new Error("still processing");
}

console.log(await extract("invoice.pdf"));