Plan	Commitment	Price / page	Effective discount	Best for
Starter	5,000 pages / mo prepaid pack or monthly subscription	$0.085	15% off	Small teams, ~150–200 docs/day	Buy Prepaid Subscribe
Growth	25,000 pages / mo	$0.065	35% off	Mid-market, steady daily volume	Buy Prepaid Subscribe
Scale	100,000+ pages / mo	$0.045	55%+ off	Enterprise, high-volume processors	Buy Prepaid Subscribe

Documents Processed

uploaded today

Processing Volume — Last 14 Days Today:

Total Files

Processed

Queue

Avg Confidence

Avg Process Time

Recent Activity

Processing Queue

Quick Actions

Legacy Files Need Migration

Auto-detected dockets — click to preview

Filename	Detected Docket

Dockets Need Restructuring

Existing dockets will be grouped into supplier / sub docket folders

Supplier	Sub Dockets	Files

How DocuScrape works

Two separate setups meet in the middle: a Template Docket and a Document Docket with the same name — dockets can nest to any depth (supplier → sub docket → sub-sub docket…), and if no matching template docket has anything in it, every other template docket is searched automatically before falling back to OCR.

Set up once, per supplier

Every time invoices arrive

✏️ Template Maker

Open a sample PDF, draw a box around each field

Labels are fully freeform — call a field whatever you like, search-to-find it in the field list as your set grows.

🗂 Document Docket tab

Create (or reuse) a docket

Dockets nest to any depth — supplier → sub docket → sub-sub docket — and any docket can hold files and sub dockets at once.

💾 Save

Choose the target docket, save the template

Picked via the same docket tree browser — the template docket is created automatically if it doesn't exist yet.

📤 Upload

Drop invoice PDFs into that docket

Via the UI, or hands-off through iSettings (a scoped Web API key or SFTP login) for a client's own automation.

📋 Template Docket

e.g. siemens

Holds the annotated template + its source PDF.

🗂 Document Docket

e.g. siemens

Holds the raw invoices waiting to be processed.

matched by name, then searched

⚙️ Worker

Picks up the upload automatically

A background job (Celery) fetches the PDF from storage the moment it lands in the docket.

🔍 Match & extract

Finds the right template, reads every field

Checks the same-named template docket first (filename → PDF metadata → field position); if it's empty, every other template docket is searched too before reading each labeled region directly from the PDF, falling back to OCR for scanned pages.

✅ Validate & save

Auto-corrects and writes to the database

Dates, codes and amounts are checked and cleaned up, global correction rules applied, before the run is saved.

📊 Done

Results land in the Dashboard, Activity & Results tabs

Template setup

Invoice intake

Matched by docket name

Automatic processing

Outcome

Drop PDF to upload

Document Docket

Nest dockets inside dockets as deep as you need — every docket can hold both files and sub dockets

Existing Dockets Not Yet in the Nested Tree

Copies your existing suppliers into the new tree — nothing is deleted

Supplier	Sub Dockets	Files

Migrated into the nested docket tree

Docket Name

A friendly ID (like 901, 90101…) is assigned automatically

Rename Docket

New Name

Only the display name changes — its ID and stored files are untouched

Delete Docket

AI Extraction Results

Review, correct, and export structured data extracted from your documents

Document Preview

Compare with Reference JSON

Paste your reference (expected) JSON below — or upload a .json file

✓ JSON loaded

Accuracy

matched

mismatched

missing

total fields

Field Expected Extracted Status

Existing Templates Not Yet in the Nested Tree

Migrated into the nested docket tree

Template Docket

Nest template dockets as deep as you need — mirrors the Document Docket tree

Template Name	Source File	Regions	Keywords	Actions
			—

PDF not found in this docket

Docket Name

A friendly ID (like 901, 90101…) is assigned automatically

Rename Docket

New Name

Delete Docket

Compare Results

Diff two extraction runs of the same document, or check a run against a reference JSON — then resolve mismatches field by field.

File

Current Run (being checked)

Baseline Run (reference)

Or Paste Reference JSON

✏️

Field Marker

Upload a PDF invoice to start annotating fields

Draw boxes over fields → export a reusable extraction template

Template: → Docket:

🖨️

Scanned PDF (image-based) — No selectable text found. Annotation boxes will still work — the OCR Engine will extract text from them during processing.

📋

Pre-marked PDF detected —

Page /

Drag to draw · Right-click or Del to delete · Esc to deselect · +/− to zoom

Field to Draw

Annotations

Override Field Type

✎Manually overridden

Region Preview ✓ Good

✎Overridden

No text in region

Template Extraction Test

Review Detected Fields

Field names were read from your PDF annotations. Confirm or change each one before importing.

Page Label in PDF System Field

Load Existing Template

Select a saved template to restore its annotations onto the current PDF

Add Custom Field

Name the field and choose how it will be drawn on the template

Field Name Field Type

Correction Rules

Rules fire in sequence after every extraction — each one reads the previous rule's output.

Total Rules

Enabled

Disabled

Rules fire at extraction time in the worker and can be re-applied to existing results via POST /api/correction-rules/apply/{run_id}

Rule Name Field Path

Condition

Condition Value / Pattern

Action

Test this rule

iSettings

You get direct, scoped access to bulk-upload into one Document Docket → Sub Docket — via Web API or SFTP.

Total Ingestions

Active

Revoked

Your upload options

Web API (bulk upload, one or many files)

curl -X POST -H "X-API-Key: <api_key>" \
  -F "files=@invoice1.pdf" -F "files=@invoice2.pdf" \
  http://<host>:8081/api/integrations/upload

SFTP (drag-and-drop)

sftp -P 2222 <sftp_username>@<host>
put invoice.pdf

Webhooks (optional, set per ingestion)

POST <your webhook_url>
X-DocuScrape-Signature: sha256=<hmac(webhook_secret, body)>

{"event":"document.processed","filename":"invoice1.pdf",
 "status":"success","confidence":97.2,"needs_review":false}

Fired once, no retry queue on failure — if your endpoint is down when a document finishes, that one notification is lost; the extraction result itself is unaffected and stays available through the endpoints above.

Both channels ignore any docket you send — every upload is pinned to your credential's own docket (any depth in the tree, or a legacy supplier/sub docket), so if it ever leaks, it only ever exposes the one docket it was created for.

Connected accounts

Auto-import PDFs dropped into a Google Drive or Dropbox folder, and push processed results (JSON + CSV) back out.

+ Connect Google Drive + Connect Dropbox

Import polls every ~5 minutes (cloud APIs are rate-limited, unlike the ~5s watcher used for the docket upload flow above). Export happens right after a document in the target docket finishes processing.

Billing

1 credit is used per PDF page successfully processed — a 10-page invoice uses 10 credits. Prices are in USD.

Page Credits Remaining

Invoices Billed

Plans

Each plan supports a one-time prepaid purchase (no expiry, no auto-renew) or a monthly subscription (auto-recharges the same page quota every cycle).

Pay As You Go

No commitment — buy exactly the pages you need, whenever you need them, at $/page. Prepaid only, no subscription.

Pages to buy

Transaction History

Date	Type	Amount	Balance After	Reference

Top Up —

Credits

Type

Note (optional)

New Client

Name

Organization (optional)

Username

Password

Email (optional)

Initial Credits

New Ingestion

Label Docket

Nest to any depth — supplier, sub docket, sub-sub docket, etc. The credential is scoped to exactly this docket.

Channel Webhook URL (optional)

If set, we POST a signed JSON payload here every time a document uploaded through this credential finishes processing — no polling needed. Leave blank to skip.

Webhook

Webhook URL

Clear this field and save to disable delivery. Changing the URL keeps the existing signing secret — use "Regenerate secret" below only if the secret itself may have leaked.

Integration created

⚠ Copy these now — they won't be shown again.

📄

DocuScrape — Project Documentation

Version 3.0 · Last updated August 2026 · POC Build (GPU-accelerated)

This document explains what DocuScrape does, how it works step by step, what features are currently live, and what is planned for future releases — all in plain, easy-to-understand language.

1 What is DocuScrape?

DocuScrape is a system that automatically reads PDF invoices and pulls out the important information — like supplier name, invoice number, date, item descriptions, quantities, prices, and more — and saves it in a structured digital format (JSON) that other systems can use directly.

Think of it as a very smart data-entry assistant. Instead of a person manually typing invoice data into a spreadsheet or ERP system, DocuScrape does that job automatically, in seconds, with high accuracy — for known suppliers, without needing any AI model call at all.

Why does this matter? Processing invoices manually is slow, error-prone, and expensive. DocuScrape removes that bottleneck — a 20-page invoice that would take 15–20 minutes to manually enter can be processed in seconds once a template exists for that supplier.

Runs GPU-accelerated. This build runs on server hardware with an NVIDIA GPU — OCR uses CUDA. An earlier version of this system also called out to a local AI vision/text model (Ollama) for invoices it didn't recognise; that model has been switched off by default for this deployment (see Section 3, independent of the GPU/CPU choice) in favour of template-driven extraction, which needs no AI model at all for known suppliers.

2 How the System is Built

The system runs entirely on your local server — no internet connection, no cloud, no data leaving your premises. It is made up of several components that work together:

Component	What it does (plain English)
File Store (MinIO)	A secure locker where all uploaded PDF invoices are stored. Think of it like Google Drive, but running on your own server. Two storage layouts coexist side by side: the original flat supplier/sub docket layout, and a newer arbitrary-depth docket tree (dockets nested inside dockets, to any depth).
Queue (Redis)	A waiting list. When a PDF is uploaded, its name is added to this list so the Worker knows what to process next. Also used to avoid queuing the same file twice.
Database (PostgreSQL)	Stores all extracted invoice data permanently, the docket tree structure, and client integration credentials — so you can look up any past run, compare runs, or export the data.
Worker	The hands. Picks up each PDF from the queue, converts it to images, matches it against a saved template, reads text directly from the PDF or via OCR (EasyOCR), validates the result, and saves it to the database. Runs GPU-accelerated (CUDA) on this deployment.
Watcher	A background monitor that automatically detects when a new PDF is uploaded — in any of the three storage layouts — and queues it for processing within about 5 seconds, no manual trigger needed.
API + Web UI	The interface you see and use. Provides the web dashboard, all tabs, and also exposes a REST API so other software can connect directly.
SFTP Bridge	A small write-only drop box a client's own systems can push PDFs into over SFTP, without ever touching the web UI. Scoped to exactly one docket by a credential you issue them — see iSettings, below.

3 Step-by-Step Workflow

This is what happens from the moment you upload a PDF to the moment the extracted data is ready:

Upload PDF

You upload a PDF invoice through the web UI (Document Docket tab — either the flat supplier/sub docket layout or a nested docket tree, any depth), or hands-off through iSettings (a scoped Web API key or SFTP login handed to a client) without touching the UI at all.

Auto-Queue

The Watcher detects the new file within 5 seconds and adds it to the processing queue. It also prevents the same file from being processed twice, even if you re-process it manually right after uploading.

Template Check

The Worker checks whether a template exists for this docket. A template is a pre-configured map of where each field lives on that supplier's specific invoice layout. Three checks are done — by filename, by embedded PDF metadata (creator/producer), and by matching anchor text at known coordinates. If the same-named template docket has nothing in it, every other template docket is searched too before giving up, so a naming mismatch doesn't silently skip template matching.

Template Path (fast & precise — the primary path)

If a template is matched, the system uses direct text extraction from the PDF — pulling the exact text sitting at each annotated region. For scanned/image regions, it falls back to EasyOCR (Tesseract is only used as an emergency fallback if EasyOCR itself is unavailable). This path needs no AI model call at all, is very fast, and is the one almost every invoice takes once a supplier has a template.

No-Template Path (new / unrecognised invoices)

If no template matches, this deployment currently degrades to OCR-only extraction (EasyOCR) and flags the result "Needs Review" rather than reading it with an AI model — the vision/text LLM stage that would otherwise handle unknown layouts is switched off by default (an environment flag re-enables it if an LLM backend is set up; this is independent of this build already having GPU access). In practice this means: train a template for any supplier you process regularly — see Section 4.

Validation & Auto-Correction

The extracted data goes through automatic checks: country codes are standardised, dates are formatted correctly, numeric values are cleaned, and — for templates that opt individual fields into it — a rate×quantity≈amount cross-check catches common extraction errors. A global correction-rule pipeline then applies any configured find/replace-style rules before the result is saved. Any remaining issues are flagged for review.

Targeted Re-Extraction

On a deployment with the AI model enabled, fields that failed validation get asked again with a focused prompt about just those problem fields. On this build (model disabled by default, regardless of GPU availability) this step is a no-op — nothing to re-ask.

Confidence Scoring

Template-matched fields each get a 0–100% quality score based on content, length and character validity — averaged into the run's overall confidence. (A separate dual-pass comparison score exists specifically for the AI-vision path, when that path is enabled.) Low-confidence or no-template runs are flagged "Needs Review".

Save & Serve

The final structured JSON — along with the confidence score, processing time, and status — is saved to the database. It is immediately accessible via the Results tab in the UI or via the API, for both the flat docket layout and the newer docket tree.

4 How Template Training Works

A template teaches the system exactly where each field is located on a particular supplier's invoice. Once trained, the system doesn't need to guess — it reads the right spot directly. This is what lets every invoice avoid the no-template OCR-only fallback described in Section 3.

Open Template Maker tab

Go to Template Maker in the sidebar and upload a sample PDF invoice from the supplier you want to train.

Draw bounding boxes

Click and drag on the PDF to draw a box around each field. Labels are fully freeform — type any name you like, or pick one from the searchable field list as it grows. Item-table fields (quantity, rate, amount) can each optionally be tagged with a "role", which opts them into the automatic rate×qty≈amount cross-check.

Save the template

Give the template a name and choose a target docket — using the same tree browser used elsewhere in the app, so it can go as deep as you need (supplier → sub docket → sub-sub docket…). The template is stored as a JSON file with the position and label of every annotated region; the docket is created automatically if it doesn't exist yet.

Future invoices matched automatically

Next time an invoice lands in that docket (or any docket sharing its name), the system recognises it and uses the template — no AI model call needed, resulting in faster and more consistent extraction.

5 What's Currently Available

PDF Management

Upload PDF invoices through the web UI, the REST API, or a client-facing scoped credential (iSettings)
Two coexisting docket layouts: the original flat supplier/sub docket structure, and a newer docket tree that nests to any depth (supplier → sub docket → sub-sub docket…) — either can hold both files and further sub dockets at once
Create, rename, and delete dockets in either layout; deleting a tree docket can cascade to all its sub dockets and files at once, with a warning showing exactly what will be removed first
Auto-detect supplier name from the PDF filename
One-click, non-destructive migration from the flat layout into the tree (copies, never moves — nothing is deleted)
View, re-process, or delete individual PDFs per docket
Stream / preview any PDF directly in the browser

Extraction Engine

Template-driven extraction (PyMuPDF direct text + EasyOCR for scanned regions) — the primary path, needs no AI model call, and covers almost every invoice once a supplier has a template
Three-step template matching: filename keywords → PDF metadata → coordinate anchors, searching every other template docket too if the same-named one is empty
Optional vision/text AI model path for invoices with no matching template at all — disabled by default; those invoices instead get OCR-only extraction and are flagged "Needs Review"
Multi-page invoice support — all pages are processed
Wrapped, multi-line item descriptions are correctly read as a single line item rather than being split into phantom extra rows

Validation & Auto-Correction

Auto-correct country codes to ISO 2-letter standard (e.g. "INDIA" → "IN")
Auto-format invoice dates to DD/MM/YYYY
Clean and validate numeric fields (amounts, rates, quantities)
Rate × Quantity cross-check — opt any template's item fields in via a "role" tag; catches common extraction errors automatically
A global correction-rule pipeline applies configurable find/replace-style rules to every extraction before it's saved
Flag records that need human review (low confidence, or no template matched at all)

Template Maker (Training Tool)

Upload any PDF and render it page-by-page in the browser at 300 DPI
Draw bounding boxes on fields by clicking and dragging
Field labels are fully freeform — type any name, with a searchable picker as your label list grows
Auto-suggest labels from the text under each drawn box, and from a PDF's own embedded annotations if it has any
Save templates into any docket in the tree, at any depth, via the same docket picker used elsewhere in the app
Upload existing template JSON files directly
Edit a previously saved template — reopen it with all its boxes already drawn, adjust, and overwrite
Manage template dockets — create, rename, delete (with cascade-delete + warning, same as Document Docket)

Dashboard & Results

Dashboard showing total files, processed count, and "needs review" count
Recent activity feed — last 50 processed invoices, across both docket layouts
Live queue depth indicator (how many invoices are waiting to process)
Per-docket view: see all PDFs in a docket with run count and status
Results tab: select any file + run — from either docket layout — view full extracted JSON, and compare two runs side-by-side
Download extracted data as JSON, in either its raw shape or a normalised Header/InvoiceDetails/ItemsDetails shape
Re-trigger processing for any file from the UI

Client Integrations (iSettings)

Issue a scoped credential — Web API key, SFTP login, or both — that lets an external client push PDFs straight into one specific docket, at any depth, without ever touching the UI
Each credential is locked to exactly one docket: a leaked key or login only ever exposes that one docket, nothing else
Revoking a credential kills both channels immediately — no separate OS users or out-of-band state to clean up
Raw secrets are shown exactly once at creation time and never stored or retrievable again

API Access

Full REST API — upload, process, and retrieve results programmatically
Results returned as structured JSON ready for ERP/system integration
Docket management endpoints for both layouts (create, list, rename, delete)
Template management endpoints (save, list, delete)
Queue status endpoint for monitoring

6 Planned Features (Roadmap)

The following are genuinely outstanding — not yet done, or done partially. (A number of items that used to be on this roadmap — editable templates, freeform/custom field labels, arbitrary docket nesting, a JSON comparison module — have since shipped and moved to Section 5.)

Training Improvements

Clone a template as a starting point — When creating a template for a new supplier, load an existing similar template as a base and adjust only what's different — saves significant training time.
Additional extraction hints per template — Add a custom instruction to a specific supplier's template to guide extraction on unusual fields or layouts, without affecting any other template. Most useful once the AI model path is enabled on a given deployment.

Quality & Accuracy

Surface when the rate×qty≈amount cross-check is inactive — Templates that haven't tagged any fields with a role silently skip the cross-check; a "cross-check inactive" indicator on the Results tab would make that visible instead of reading as a possible regression.
Accuracy & processing time on the dashboard — Show average accuracy % and average processing time per docket, so it's easy to see which suppliers are performing well and which need a template.
Further multi-row / complex-table handling — Wrapped single-item descriptions are now handled correctly (see Section 5); genuinely complex layouts — merged cells, nested headers — still need broader testing against reference data.
Large invoice testing — Test and tune the pipeline for invoices with 50–100+ pages, to confirm accuracy and processing time hold up at scale.

Monitoring & Reporting

Supplier-wise performance dashboard — A dedicated view showing, per docket: how many templates exist, how many invoices have been processed, average accuracy, average processing time, and how many need review.

Cleanup, once the docket tree is confirmed stable everywhere

Retire the legacy flat-docket fallback code in the worker and watcher, once all real data is confirmed migrated off the pre-2026-07-17 one-level layout.
Extend docket-tree template matching's fallback search to more closely match the legacy path's "search every other docket" behaviour, if mismatches turn out to be common in practice for very large trees.

Infrastructure

Published domain access with TLS — Everything currently runs over plain HTTP on the server's IP; a proper domain + TLS would let this be exposed more broadly without the current caveats around credentials and API keys travelling in the clear.
Re-enabling the AI model path — the vision/text LLM stage exists in the codebase and can be turned back on (e.g. once GPU capacity is available again) to handle invoices with no matching template, instead of the current OCR-only + "Needs Review" degrade behaviour.

7 What the Extracted Data Looks Like

Two output shapes coexist, distinguished by a schema_version field on the saved run — older rows and new ones are both handled transparently everywhere they're displayed:

Shape	What's inside
Freeform (current, schema_version 2)	`header` and `items`, keyed literally by whatever labels the matching template defines — a template with a field called "TermsAndConditions" produces exactly that key. No fixed field list.
Legacy canonical (older rows, schema_version 1 or missing)	A fixed `supplier` / `importer` / `invoice` / `items` shape used before templates went fully freeform. Still readable and displayed exactly as before — nothing was reprocessed to migrate it.
Metadata (both shapes)	Extraction method used, confidence score, processing time in seconds, template name, and any validation issues found.

A separate "Download structured" option normalises either shape into a fixed Header / InvoiceDetails / ItemsDetails layout for downstream systems that expect a consistent structure. For freeform-shape rows, InvoiceDetails is always empty by design — there's no fixed schema to sort those fields into, so everything lives under Header and ItemsDetails instead.

Note: Because field vocabulary is fully freeform per template, two suppliers' outputs may use entirely different key names for conceptually similar data — that's expected, not a bug. Correction rules and per-template validation rules both resolve against whatever shape a given row actually has.

DocuScrape · POC Build, GPU-accelerated · Running on port 8081 · All processing is local — no data leaves this server

Turn any document into structured data.

Three lines to your first extraction.

Everything a document pipeline needs, none of what it doesn't.

Secure repository

Real-time processing

Reliable delivery

Programmable interface

Flexible output formats

Multiple integrations

A record that can't be quietly changed.

Fits into the systems you've already got.

Submit & retrieve

Push on completion

Native libraries

ERP, CRM & more

Pay for what you process.

Start with 50 page credits, free

Built to end manual document entry.

Teach DocuScrape your invoice format once. Let it handle the rest.

Invoice processing,on autopilot.

Welcome back

Create an account

Account created

Choose a Docket

How DocuScrape works

Open a sample PDF, draw a box around each field

Create (or reuse) a docket

Choose the target docket, save the template

Drop invoice PDFs into that docket

e.g. siemens

e.g. siemens

Picks up the upload automatically

Finds the right template, reads every field

Auto-corrects and writes to the database

Results land in the Dashboard, Activity & Results tabs

Document Docket

Rename Docket

Delete Docket

AI Extraction Results

Template Docket

Rename Docket

Delete Docket

Compare Results

Field Marker

Template Extraction Test

Review Detected Fields

Load Existing Template

Add Custom Field

Correction Rules

iSettings

Billing

Clients

New Ingestion

Webhook

Integration created

Invoice processing,
on autopilot.