Batch processing with webhooks

from concurrent.futures import ThreadPoolExecutor
from ocrqueen import OCRQueen

client = OCRQueen(api_key="pk_live_xxx")
WEBHOOK = "https://api.acme.com/hooks/ocrqueen"

def submit_one(path: str) -> str:
    job = client.submit(path, callback_url=WEBHOOK)
    return job.job_id

# 8 concurrent submits — bounded by the per-key rate limit. Bump the pool
# up to your plan's RPS limit.
with ThreadPoolExecutor(max_workers=8) as pool:
    job_ids = list(pool.map(submit_one, ["doc1.pdf", "doc2.pdf", ...]))

# Record job_ids → your DB so you can correlate webhook payloads later.

import { OCRQueen } from "ocrqueen";

const client = new OCRQueen({ apiKey: "pk_live_xxx" });
const WEBHOOK = "https://api.acme.com/hooks/ocrqueen";

const files = ["doc1.pdf", "doc2.pdf", /* ... */];

// Promise.all — simple but unbounded. For real batches, use a worker pool
// (p-limit, p-queue, etc.) so you don't exceed your plan's rate limit.
const jobIds = await Promise.all(
  files.map(async (path) => {
    const job = await client.submit(path, { callbackUrl: WEBHOOK });
    return job.job_id;
  })
);

import hmac, hashlib, os
from fastapi import FastAPI, Header, HTTPException, Request

WEBHOOK_SECRET = os.environ["OCRQUEEN_WEBHOOK_SECRET"]
app = FastAPI()

@app.post("/hooks/ocrqueen")
async def receive(
    request: Request,
    ocrqueen_signature: str = Header(alias="OCRQueen-Signature"),
):
    body = await request.body()
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        body,
        hashlib.sha256,
    ).hexdigest()
    if not hmac.compare_digest(expected, ocrqueen_signature):
        raise HTTPException(401, "invalid signature")

    payload = await request.json()
    # payload is the same JobResponse shape returned by /v1/jobs/{id}
    print(payload["job_id"], payload["status"])
    # → enqueue downstream processing, write to DB, etc.
    return {"ok": True}