Can AI check whether contracts are billed correctly?

Yes, AI can check whether contracts are billed correctly, and it is one of the applications where it makes a real difference. A language model reads the contracts, extracts the terms that matter for invoicing (prices, volume tiers, indexation, term, discounts, arrangements for extra work) and puts them into a fixed structure. That structure is then compared with the invoices using ordinary rules. The AI does the reading, the comparison and calculation are deterministic, and a person assesses the discrepancies.

Why is this almost never done by hand?

In most B2B companies, the truth about what a customer should pay sits in a PDF. The signed contract, the framework agreement, the accepted quote, an addendum from two years later. Billing works from whatever someone copied out of those documents into the ERP or billing system at the start.

Checking whether the two still match means opening every contract, finding the relevant clauses, working out what should be invoiced today and comparing that with the latest invoices. For ten contracts you do it. For four hundred you do not. The result is that the check only happens when there is a dispute, and by then it is too late. The manual approach is described in how to check that contracts are billed correctly. This article is about what AI changes.

What does AI read in a contract?

A language model is good at finding and summarising specific provisions in long, unstructured text. For invoice checking, these are the fields you are looking for:

The model turns each contract into a record like this, with a reference for every field to the passage it came from. That reference is essential. Without a source, you cannot check a result.

How does the comparison work?

After the reading comes the comparison. That should not be done by a language model, but by ordinary code or a spreadsheet. A language model is good at reading, not at calculating reliably.

1. Link each contract to a customer in billing. On customer number, company registration number or name. Where that fails, that is a finding in itself: a contract without billing, or billing without a contract.
2. Calculate what should be invoiced per period under the contract. Including volume tiers, indexation since the start date and discounts that still apply.
3. Retrieve the actual invoice lines for the same period.
4. Compare line by line. Price, quantity, discount, period.
5. Flag every difference above a threshold. With the amount, the contract passage and the invoice line attached.

The result is a list of discrepancies, each with a source in the contract and in billing. A person can assess each line in a minute.

Where can it go wrong?

AI makes this check feasible, but not flawless. The known pitfalls:

• Misread provisions. A model can read an indexation of "no more than 3 percent" as "3 percent", or a temporary discount as permanent. It can also invent a value when a provision is absent. Hence the reference to the passage, and hence a sample check by a person.
• Addenda and amendments. A contract from 2021 with an addendum from 2023 that changes the price. If the model does not receive the addendum or does not link it, it compares against the wrong price.
• Arrangements outside the contract. A discount promised by email is not in the PDF. The AI then flags a discrepancy that is in fact an agreement. That is not an AI error but a gap in your contract management. Record such arrangements after the fact.
• Poor scans. Old contracts stored as images, with handwritten amendments, are harder to read. Reliability drops.
• Ambiguous contract wording. If two lawyers read a clause differently, a model will too. Flag such clauses for human review.

Every finding should carry a confidence level, and that confidence has to be based on something. How to judge whether such a recommendation can be trusted is covered in how to tell whether an AI recommendation is reliable.

Worked example

Worked example: suppose you have 320 running contracts. By hand, reading and working through one contract takes half an hour to an hour. That is 160 to 320 hours, or one to two months of work for one person. With AI:

• Reading 320 contracts and filling in the fields takes minutes to hours, depending on their length.
• A person checks a sample of 30 contracts for reading errors: about a day.
• The comparison with invoices produces, say, 45 discrepancies. These are assessed in two days.

Suppose that after review, 18 discrepancies are real leaks, together worth EUR 70,000 a year. Three days of work have then produced that amount. How many leaks sit in your contracts depends on how well contract management and billing currently line up. This is an example, not an average.

What should you check first?

Do not start with every contract and every field. Start where the money is:

1. Indexation. The most common and most measurable discrepancy. See also how to find missed price increases.
2. End dates and renewals. Contracts that have expired but are still being invoiced, or have been renewed but are no longer invoiced.
3. Minimum commitments. Customers who stay below their contractual minimum while the contract requires a top-up invoice.
4. Temporary discounts. Discounts with an end date that are still being applied.

These four cover a large share of the leaks between contract and invoice, which are explored further in revenue leakage between contract and invoice.

What do you need to get started?

• A complete folder of contracts. Including addenda, renewals and signed quotes that serve as contracts. A missing document is a blind spot the AI will not notice.
• A matching key. A customer number or company registration number in the contract or in the file name, so each contract can be linked to the right customer in billing.
• Invoice lines, not totals. Per customer, per period, with item, quantity, price and discount.
• Someone to assess the result. Preferably someone who knows both the contracts and the customers. Without that review, the list of discrepancies is a suspicion, not a finding.

One-off or continuous?

A one-off check finds what is wrong now. A continuous check finds what goes wrong as it happens: a new invoice that deviates from the contract, an indexation not applied on its effective date. The difference lies in the connection. For a one-off check, a folder of PDFs and an export from billing will do. For continuous checking, the system must be able to pull in new contracts and invoices by itself.

How a platform presents this, with evidence, confidence and a euro amount per signal, is shown on the system page. It is one of the ways AI detects revenue leakage, and it fits within the wider approach to finding revenue leakage.

Frequently asked questions

Do I have to upload my contracts to an AI service?

For this check, a model has to see the contract text. Pay attention to where that processing takes place, whether the provider uses the data for training, and whether personal data can be removed before the model sees the text. Names of contact persons are rarely needed for invoice checking.

How accurately does AI read contracts?

That depends on the quality of the documents and the clarity of the wording. With clear, digital contracts and standard clauses it does well. With scans, handwritten amendments and ambiguous wording, less so. Measure it yourself with a sample before relying on the result.

Can the AI correct the invoice straight away?

Technically, a system can prepare a correction. Whether you want that is another question. An invoice change affects the customer. Let a person approve whatever goes out of the door.

Does this also work for quotes and order confirmations?

Yes. Any document containing a price agreement can be read in the same way. The more sources, the more complete the picture, but also the greater the chance of contradictions that a person has to resolve.