Last reviewed September 1, 2026

How do I stop manually entering invoices?

Direct answer

Stop typing fields and start declaring them. Pick the ten or so values your accounting system actually needs from an invoice, write them down as a typed schema, and run every incoming bill through software that returns exactly those fields — then let arithmetic, not a person, decide which ones are wrong. Manual entry disappears when the output shape is fixed in advance and a human only sees the exceptions.

01

Why invoice entry survives every automation attempt

Accounts payable teams rarely fail at automation because the software cannot read a PDF. They fail because the work is four jobs stapled together: getting invoices into one place, reading them, matching them against a purchase order or contract, and deciding what to do when something does not match. Buying a reader solves exactly one of those.

The second reason is shape. Generic OCR hands back a page of text or a loose bag of key-value pairs, so somebody still writes the code that turns "TOTAL DUE ......... 4,125.60" into a number your ledger will accept. That code is where projects die: it works for the twelve vendors you tested and breaks on the thirteenth.

  • Intake: email attachments, a shared mailbox, supplier portals, paper that gets scanned.
  • Reading: turning the file into named fields with types you can post.
  • Matching: purchase order, receipt, contract rate, or none of the above.
  • Exceptions: who fixes a mismatch, and what happens to the invoice while they do.
02

The four decisions that actually remove the typing

Before evaluating any tool, write these four answers down. They determine whether automation sticks far more than the tool choice does.

  • Field list: the smallest set your ledger needs. Most teams need vendor, invoice number, invoice date, due date, PO number, currency, subtotal, tax, total, and line items. Anything else is a nice-to-have that adds review work.
  • Acceptance rule: what has to be true for an invoice to post without a human. Start with "line items sum to subtotal, subtotal plus tax equals total, invoice number is not already in the ledger".
  • Exception owner: one named person or queue. An exception with no owner becomes a spreadsheet.
  • Matching policy: which invoices need a PO match at all. Many teams discover that only a minority do.
03

What still needs a person, on purpose

Full automation of payment approval is not the goal — a wrong payment is expensive and slow to unwind. Keep a person in the loop wherever the failure is money leaving the company rather than a typo in a description field.

A practical split: auto-post invoices that pass every arithmetic check, come from a vendor you have paid before, and fall inside the range you normally pay that vendor. Route everything else — new vendors, changed bank details, unusual amounts, missing purchase orders — to review. Changed bank details deserve a manual callback to a known phone number regardless of how confident any software is.

04

Do the cost math before you buy anything

You do not need an industry statistic to justify this; you need your own numbers. Time one person entering ten real invoices end to end, including the interruptions. Multiply the median by your monthly volume. That is the hours side. Then estimate the review rate you are willing to accept — if 20% of invoices go to a human, you are still removing four in five keystroke sessions.

The number that surprises most teams is not the entry time; it is the correction time. A single mis-keyed total that reaches the ledger costs a reversal, a re-post, and an awkward vendor email. Counting those makes the arithmetic checks below the highest-return part of the whole project.

Copy-pasteable artifact

A copy-pasteable invoice schema, and the JSON it should produce

This is a complete JSON Schema (2020-12) for a business invoice, the output object it accepts for one sample bill, and the same field list expressed the way Dokyumi stores a schema. Validate the middle pane against the left pane with any JSON Schema validator — Ajv in Node, jsonschema in Python — and you have a machine-checkable definition of "done" that belongs to you, not to a vendor.

invoice.schema.json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://example.com/schemas/invoice.json",
  "title": "Vendor invoice",
  "type": "object",
  "required": ["vendor_name", "invoice_number", "invoice_date", "currency", "total"],
  "additionalProperties": false,
  "properties": {
    "vendor_name": { "type": "string", "minLength": 1 },
    "invoice_number": { "type": "string", "minLength": 1 },
    "invoice_date": { "type": "string", "format": "date" },
    "due_date": { "type": ["string", "null"], "format": "date" },
    "po_number": { "type": ["string", "null"] },
    "currency": { "type": "string", "pattern": "^[A-Z]{3}$" },
    "subtotal": { "type": ["number", "null"], "minimum": 0 },
    "tax_amount": { "type": ["number", "null"], "minimum": 0 },
    "total": { "type": "number", "minimum": 0 },
    "line_items": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["description", "line_total"],
        "additionalProperties": false,
        "properties": {
          "description": { "type": "string", "minLength": 1 },
          "quantity": { "type": ["number", "null"], "minimum": 0 },
          "unit_price": { "type": ["number", "null"], "minimum": 0 },
          "line_total": { "type": "number" }
        }
      }
    }
  }
}

Two details do real work here. Field descriptions are instructions, not documentation — "the vendor’s own identifier for this bill" is what stops a reader returning your own PO number as the invoice number. And nullable-but-required is deliberate: a required field is always present in the output so your code can branch on it, which is not the same as guaranteeing a value was found.

Checklist

The acceptance checks to run before anything posts

Run these in your own code, on every invoice, before it touches the ledger. They are cheap, deterministic, and catch the failures that matter most.

  1. 1

    Line items sum to subtotal

    Compare in integer cents with a tolerance of one cent per line to absorb rounding. A mismatch usually means a missed or duplicated row.

  2. 2

    Subtotal + tax = total

    The single highest-value check on an invoice. If it fails, nothing else on the document is trustworthy.

  3. 3

    Invoice number is new for this vendor

    A unique index on (vendor, invoice_number) is the cheapest duplicate-payment control you will ever build.

  4. 4

    Date is real and recent

    Reject dates in the future or more than a year old; both are common signs of a misread year digit.

  5. 5

    Currency is an ISO 4217 code you actually transact in

    A three-letter pattern check plus an allow-list stops "S" from becoming "SGD" in your books.

  6. 6

    Amount is inside this vendor’s normal range

    Compare against the vendor’s trailing median. An order-of-magnitude jump is a decimal-point error until proven otherwise.

  7. 7

    Bank details match the vendor record

    Never auto-update remittance details from a document. Confirm changes by phone on a number you already had.

Terminology bridge

This is called AP automation, and the reading half is intelligent document processing (IDP)

Vendors sell the reading step as IDP or "document AI", and the surrounding workflow as accounts payable automation or invoice capture. The metric everyone uses is the touchless (or straight-through) rate: the share of invoices that post without a human touching them. When a salesperson quotes an accuracy number, ask whether it is per field or per document, and on which document set — those two choices move the number more than the technology does.

  • IDP
  • invoice capture
  • AP automation
  • touchless processing
  • straight-through processing

Follow-up questions

Do I need one schema per vendor?+
No. One schema per document class is the right granularity — an invoice is an invoice whether it comes from a two-page PDF or a scanned fax. Per-vendor templates are what makes template systems expensive to own, because every new supplier is a project.
What about invoices that arrive as email bodies rather than attachments?+
Treat them as a separate intake path. Extraction tools take files, so either render the email to PDF or parse the body text with the same schema. The acceptance checks stay identical.
How many invoices should I test before trusting this?+
Enough to include your awkward vendors. Take 25 real invoices weighted toward the messy end — the multi-page ones, the scanned ones, the foreign-currency ones — and measure how many pass every acceptance check without edits. That number is your starting touchless rate, and it is worth more than any published benchmark.

Evidence notes

Sources and limitations

Sources used

Limitations

  • The sample output above is an illustrative document, not a measured benchmark. Dokyumi has not published a universal document-accuracy figure, and no page here claims one.
  • Arithmetic checks catch internally inconsistent documents. They cannot catch an invoice that is wrong but self-consistent — that is what purchase-order matching and approvals are for.
  • Extraction reads what is on the page. Fraud controls, duplicate-payment policy, and approval routing stay in your systems.

Published and last reviewed September 1, 2026. Product behavior can change; the linked API, pricing, and security pages are the controlling public references.

Test it on your own worst invoice

Define the schema above, send one PDF, and read the JSON. The free plan includes 25 credits a month and 2 schemas, with no card required, which is enough to test this on your own documents before deciding anything.