Doc-AI for developers

Submit and handle the callback

Two functions. That is the integration for most workloads.

# submit
resp = requests.post(
    f"{DOC_AI}/v1/transactions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    files={"file": open(path, "rb")},
    data={"project": "accounts-payable",
          "callback_url": "https://app.example.com/hooks/doc-ai"},
)
txn_id = resp.json()["transaction_id"]

# handle the webhook
@app.post("/hooks/doc-ai")
def doc_ai_hook(event):
    verify_signature(event)                     # HMAC over the raw body
    if event["event"] != "transaction.completed":
        return 200
    r = get_json(event["result_url"])
    if r["review_required"]:
        queue_for_review(r)                     # or surface it in your own UI
    else:
        post_to_erp(r["fields"])                # validated, typed, confident
    return 200

A document type is data, not code

Fields and rules are declarative. Adding a document type is a config change, which means it can live in your repo and go through review like anything else.

document_type: purchase_order
description: >
  A customer purchase order. May arrive as an email attachment or a scan.
  Line items may continue across pages.
fields:
  - { name: po_number,     type: string }
  - { name: order_date,    type: date }
  - { name: buyer_name,    type: string }
  - { name: ship_to,       type: string }
  - { name: currency,      type: enum, values: [USD, EUR, GBP, CAD] }
  - { name: total,         type: decimal }
  - name: lines
    type: array
    items:
      - { name: sku,       type: string }
      - { name: qty,       type: decimal }
      - { name: unit_price, type: decimal }
rules:
  - { name: lines_sum,  expr: "abs(sum(lines.qty * lines.unit_price) - total) < 0.01" }
  - { name: sku_exists, lookup: item_catalog, on: lines.sku }
thresholds:
  classification: 0.90
  extraction: 0.85

Put document processing in your test suite

Deterministic execution means extraction is testable like any other component, instead of being the one part nobody can assert on.

def test_wrapped_line_items_are_reconstructed():
    r = doc_ai.process("fixtures/po-continuation-pages.pdf",
                      project="orders", wait=True)

    assert r["document_type"] == "purchase_order"
    assert r["validation"]["passed"] is True
    assert len(r["fields"]["lines"]) == 27          # spans 3 pages
    assert r["fields"]["total"]["value"] == 48210.00
    assert r["fields"]["total"]["confidence"] > 0.95

def test_model_change_does_not_regress():
    # scored against a labeled corpus, run in CI
    score = doc_ai.evaluate(corpus="orders-golden-50", model="candidate")
    assert score["field_accuracy"] >= BASELINE - 0.005

If you need to pull three fields off one predictable PDF layout, write the regex. If you are extracting from documents you generated yourself, parse your own format. If volume is a handful a day and a person reads every result, a direct model call is fine and cheaper.

The case for a platform starts where variety, volume, and consequences meet: many layouts you do not control, enough throughput that nobody reads every result, and output that posts somewhere it matters. That is when the pieces you would otherwise build — OCR structure, splitting, validation, evaluation, review — stop being a sprint and start being a team.