Contract review assistance
Contract review assistance uses two tiers of models: a mainstream model extracts key clauses and writes a summary for the business owner, and a stronger model checks the contract against your company playbook, flags risky clauses and explains what changed between versions. The output helps your legal team and lawyers; it is not legal advice, and the lawyer makes the call. For 300 contracts a month, 100 of them with a revised version to compare, at live prices in each model’s cheapest group, model costs are about ¥40.72 a month.
Prices updated Nov 13, 2026, 6:13 PM
Monthly cost estimate
Assumptions: 300 contracts a month at about 15,000 tokens each; extraction and summary take about 16,000 input and 1,500 output tokens per contract; the risk review takes about 20,000 input tokens (15,000 contract, 4,000 playbook, 1,000 instructions) and 2,000 output tokens; 100 contracts have a revision to compare, at about 6,000 input and 1,000 output tokens each.
¥40.72per month
- Clause extraction and summary¥8.4
- Risk review against the playbook¥28.8
- Version comparison¥3.52
The business problem
Sales, purchasing and partnership contracts keep coming, and legal reads every one from the start: payment terms, breach, liability caps, termination, dispute resolution. When the other side sends back a revision, someone has to find what changed, paragraph by paragraph. With the business waiting to sign, legal easily becomes the bottleneck.
Asking an LLM whether a contract is risky usually gets generic warnings that do not match your own red lines. The model may also quote sentences that are not in the contract, or miss a clause that matters.
The reliable approach is to write your review standards down as a playbook, have the model check the contract rule by rule with quotes and reasons, verify in code that each quote really comes from the contract, and have a lawyer confirm. The model finds what needs attention first; judgment and decisions stay with the lawyer.
Recommended models
Recommended models are picked from the live catalog; prices are each model's cheapest group, updated Nov 13, 2026, 6:13 PM. Click a model to see every group's price.
Clause extraction and business summary (mainstream model)
qwen3.5-plusQwen
input ¥1.12 / output ¥6.72 per 1M tokensChina Models group
Every contract goes through this step: parties, amount, term, payment, breach, termination and dispute resolution come back as JSON, followed by a plain-language summary for the business owner. Long input, short output, so input tokens dominate.
Risk review and version comparison (stronger model)
Claude Sonnet 5.5Anthropic
input ¥3.2 / output ¥16 per 1M tokensClaude Lite group
Checking each playbook rule means finding the right clause in a long contract and explaining why, the step that needs the most judgment, so it gets a stronger model. Contract, playbook and instructions go into one request, often around 20,000 input tokens; how much fits in one request is set by the context length the model’s maker publishes.
Reference architecture
- 1
Write the playbook
Legal writes the company’s review standards as a playbook: each rule has an id, a topic, the standard position and the red line, such as “our liability is capped at the contract value”. The playbook is what the model judges against; the more specific it is, the steadier the results.
- 2
Parse and split
Extract the text of Word files and PDFs with a text layer in code, keeping clause numbers; convert scans to text first. Very long contracts are reviewed chapter by chapter and the results merged.
- 3
Extract and summarize
The mainstream model pulls key clauses into fixed JSON fields, then writes a summary for the business owner: what we pay, what we get and where the main risks are.
- 4
Review against the playbook
The stronger model compares the full contract with the playbook and returns each finding with the rule id, clause number, quoted text, risk level and a suggested change, plus playbook topics the contract does not cover. Code then checks that every quote appears in the contract and flags the ones that do not for the lawyer.
- 5
Compare versions
When a revision comes back, diff the two versions in code first and send only the changed paragraphs, before and after, so the model explains which party each change favours and which rule it touches.
- 6
Lawyer sign-off
Findings, suggested changes and summaries are marked as model-assisted and confirmed by a lawyer before they go to the business or the other side; the lawyer’s corrections feed back into the playbook.
Cost estimate
Assumptions: 300 contracts a month at about 15,000 tokens each; extraction and summary take about 16,000 input and 1,500 output tokens per contract; the risk review takes about 20,000 input tokens (15,000 contract, 4,000 playbook, 1,000 instructions) and 2,000 output tokens; 100 contracts have a revision to compare, at about 6,000 input and 1,000 output tokens each.
| Item | Model | Usage assumed | Cost |
|---|---|---|---|
| Clause extraction and summary | qwen3.5-plus | 300 × (16,000 input + 1,500 output tokens) | ¥8.4 |
| Risk review against the playbook | Claude Sonnet 5.5 | 300 × (20,000 input + 2,000 output tokens) | ¥28.8 |
| Version comparison | Claude Sonnet 5.5 | 100 × (6,000 input + 1,000 output tokens) | ¥3.52 |
| Total (per month) | ¥40.72 | ||
Calculated from live prices in each model's cheapest group, updated Nov 13, 2026, 6:13 PM.
Model usage only: lawyer review and text parsing are not included. The playbook sits unchanged at the start of every prompt, so on models with context caching the cached part is billed at the lower cache-read price and the real bill is lower. Prices are from the cheapest groups; if you give contract review its own key in an official-source group, re-estimate with that group’s prices. Longer contracts and more of them raise the cost roughly in proportion.
Sample code
The playbook is structured data; the model returns findings with quotes, and code checks that each quote comes from the contract. For versions, difflib finds the changed paragraphs and only those go to the model.
import difflib
import json
import os
from openai import OpenAI
client = OpenAI(base_url="https://www.tutujin.com/v1", api_key=os.environ["TUTUJIN_API_KEY"])
# The company playbook, written by your legal team: one entry per rule.
PLAYBOOK = [
{"id": "LIAB-1", "topic": "limitation of liability", "standard": "Our total liability is capped at the contract value.", "red_line": "Unlimited liability for us."},
{"id": "PAY-1", "topic": "payment terms", "standard": "We pay within 30 days of a valid invoice.", "red_line": "Payment due in under 15 days or prepayment over 30%."},
{"id": "TERM-1", "topic": "termination", "standard": "Either party may terminate with 30 days of written notice.", "red_line": "Only the other party may terminate for convenience."},
]
RULES = "Playbook:\n" + json.dumps(PLAYBOOK, ensure_ascii=False)
def ask(system, user):
resp = client.chat.completions.create(
model="claude-sonnet-5-5",
messages=[{"role": "system", "content": system + "\n\n" + RULES}, {"role": "user", "content": user}],
temperature=0,
)
return resp.choices[0].message.content
def review(contract):
raw = ask(
"You help a company lawyer review contracts against the playbook. For every clause that departs from a rule "
"or crosses a red line, and for every playbook topic the contract does not cover, return one finding. "
'Reply with JSON only: {"findings": [{"rule_id": "", "clause": "clause number", "quote": "exact words copied '
'from the contract, empty if missing", "risk": "high|medium|low", "reason": "", "suggestion": ""}]}. '
"Do not give legal advice; the lawyer decides.",
contract,
)
findings = json.loads(raw[raw.find("{"): raw.rfind("}") + 1])["findings"]
for f in findings:
# a quote that cannot be found in the contract must be checked by the lawyer, never trusted
f["quote_found"] = f["quote"] == "" or f["quote"] in contract
return findings
def explain_changes(old, new):
"""Diff in code first, so the model only reads the paragraphs that changed."""
a, b = old.splitlines(), new.splitlines()
changes = [
"BEFORE:\n" + "\n".join(a[i1:i2]) + "\nAFTER:\n" + "\n".join(b[j1:j2])
for op, i1, i2, j1, j2 in difflib.SequenceMatcher(None, a, b).get_opcodes()
if op != "equal"
]
return ask(
"For each change, say in one or two sentences what changed, which party it favours "
"and which playbook rule it touches, if any.",
"\n\n".join(changes),
)
with open("contract_v1.txt", encoding="utf-8") as f1, open("contract_v2.txt", encoding="utf-8") as f2:
v1, v2 = f1.read(), f2.read()
for item in review(v2):
print(item["risk"], item["rule_id"], item["clause"], "" if item["quote_found"] else "QUOTE NOT FOUND - check by hand")
print(explain_changes(v1, v2))Try this with one key
Sign up, create an API key in the console, and put your base_url and key into the code above. For company purchasing or invoices, add our WeChat support JsnonoChat.

Scan the code or search the WeChat ID to add us
FAQ
What does reviewing 300 contracts a month cost in model usage?
At about 15,000 tokens per contract, with extraction and risk review for every contract and 100 revisions compared, the cheapest groups come to about ¥40.72 a month. Contract length and volume matter most.
Can the model’s review be treated as legal advice?
No. The output helps your legal team and lawyers find the clauses that need attention first, with reasons and quotes. It can miss risks, misread a clause and knows nothing about the deal behind it; final judgment and any advice to others must come from a lawyer.
Why write a playbook first?
Without one, the model can only give generic warnings that do not match your real red lines. A playbook states what you accept and what you do not, so the model checks rule by rule and the results can be compared and reviewed. It also grows with your lawyers’ feedback.
What if a contract is too long for one request?
How much fits in one request is set by the context length the model’s maker publishes. Review very long contracts chapter by chapter with the playbook in every request and merge the findings, or send only the chapters that match playbook topics.
How should trade secrets and personal data in contracts be handled?
Requests are forwarded through this service to the model provider for processing. Redact counterparty names, ID numbers, bank accounts and anything else the review does not need before sending. If the source of the line matters to you, give contract review its own key in an official-source group; each model’s page lists the groups it is available in. Assess the setup against your own confidentiality and data-compliance rules.
Can scanned contracts be reviewed?
Yes, convert the scans to text first. The document parsing and data extraction solution shows how a vision model reads scans; check the converted text, since numbers and dates are the most likely to be wrong.