Can ChatGPT Review Contracts? (2026 Update)

ChatGPT can review contracts well enough to triage them, and not well enough to rely on. It summarizes an agreement, extracts the commercial terms, and flags the obvious gaps in a standard nondisclosure or master services agreement in seconds, which makes it a usable first pass. It misses the things that decide a deal: cross-referenced defined terms, asymmetric liability caps, strict notice mechanics, and anything that turns on the jurisdiction or on which party you represent. It also carries no duty of confidentiality and no professional accountability for what it tells you. A lawyer who reviews a contract with ChatGPT prepares and redacts it first, names the party represented and the governing law in the prompt, checks every finding against the contract text, and owns the error if one gets through. Where that is not enough, purpose-built contract review software grounded in your own playbook returns the review as tracked changes in Microsoft Word.

[cta-1]

Advantages of using ChatGPT for contract review

ChatGPT does five things reliably enough in a contract review to be worth the time: it summarizes, extracts, compares, translates, and flags missing boilerplate. Every one of them is orientation work, which is why each row above leaves the judgment with the lawyer. The pattern is consistent: ChatGPT is dependable at telling you what a contract says and unreliable at telling you what it means for your client.

When to use ChatGPT for contract review (and when to avoid it)

ChatGPT is worth using for contract review when the agreement is standard, the stakes are low, and the output is a starting point rather than a conclusion. It is worth avoiding when the agreement is bespoke, the exposure is material, or confidentiality cannot be protected by redaction.

Ideal use cases for ChatGPT

ChatGPT works best when the goal is speed, clarity, or early orientation rather than a final legal conclusion.

1. First-pass reviews of standard nondisclosure agreements (NDAs), master services agreements (MSAs), service level agreements (SLAs), or data processing agreements (DPAs) to surface obvious issues before deeper legal analysis
2. Summarizing lengthy contracts so lawyers can quickly understand key obligations and deal structure
3. Extracting specific information such as payment terms, notice periods, deadlines, and renewal dates
4. Flagging potentially missing boilerplate clauses based on common contract patterns
5. Comparing contract versions to identify changes between drafts during negotiation
6. Generating plain-language explanations of complex legal terms for internal stakeholders

When to avoid ChatGPT

In the situations below, the limits around context, accuracy, and data handling become material risks rather than inconveniences.

1. Bespoke commercial agreements that reflect extensive negotiation history or custom risk allocation
2. High-stakes strategic agreements, including mergers and acquisitions (M&A) transactions, major partnerships, or enterprise deals
3. Contracts with material litigation risk or regulatory exposure, where accuracy and context are critical
4. Agreements requiring jurisdiction-specific interpretation of laws, regulations, or enforceability
5. Any contract where confidentiality is critical and sensitive terms cannot be safely redacted

How to prepare a contract before uploading it to ChatGPT

Preparing a contract for ChatGPT review has four steps: convert it to clean machine-readable text, redact the details that cannot leave your firm, keep the clause numbering and headings intact, and write an internal summary of everything you redacted so you can check the output against the real terms.

1. Convert the contract to clean text

Convert scanned PDFs into machine-readable text using optical character recognition (OCR) before uploading. Strip headers, footers, page numbers, signature blocks, and formatting artifacts so the model processes the contract language and nothing else. A scanned page that OCR renders badly produces a review of garbled text, and the model will not tell you that is what happened. Confirm before uploading that:

1. Every clause number and heading survived the conversion in order
2. Tables, schedules, and exhibits came through as text rather than as images
3. No pages are missing, which is a common OCR failure and an easy one to miss

2. Redact what cannot leave the firm

Remove personal data, contact details, network identifiers, and proprietary business information that should not be shared with a third-party service.

1. Replace dates with [Effective Date], [Term Start], and [Expiration Date]
2. Replace financial amounts with [Fee], [Cap], and [Rate]
3. Replace identifiable party names with neutral placeholders such as [Company A] and [Company B]

Redaction protects confidentiality and removes legal context at the same time, and that trade-off is worth naming before you rely on the output. A $100,000 liability cap redacted to [Cap] strips away the detail needed to judge whether the cap is commercially reasonable for the deal size, so the model can describe the mechanism and cannot assess the number. Decide in advance which findings you will treat as provisional because the figure behind them was removed.

3. Keep the contract structure intact

Keep section headings, clause numbering, and the overall organization as they appear in the original. Preserved structure lets the model reference specific provisions accurately and reduces the risk of misattributing an obligation to the wrong party. It also gives you a clause reference to check each finding against, which is the step that catches many of the errors.

4. Write your own summary first

Before uploading anything, prepare an internal summary that holds the confidential terms in full. That document is the reference point: you read the model output against your own unredacted summary rather than against the redacted copy you uploaded. Without it, you are checking a review of a partial contract against the same partial contract.

How to use ChatGPT to review contracts

To use ChatGPT to review a contract, run it as a seven-step triage: start with the low-risk tasks, tell the model which party you represent and which law governs, ask for structured output, extract obligations and deadlines, compare the versions clause by clause, open a fresh chat for each agreement, then confirm every finding against the contract text yourself.

1. Start with the low-risk tasks

Begin with summarizing, extracting, and explaining rather than interpreting. These are the tasks where an error is visible on inspection: if the summary misstates the term length, you see it the moment you check clause 2. Interpretive questions produce confident answers whose errors are not visible without doing the analysis yourself, which defeats the purpose. Anyone starting out with ChatGPT in a legal workflow should stay in this band until the output has been checked a few dozen times.

2. Name the party you represent and the governing law

State in the prompt which side you are on and which law applies. A clause that is unremarkable for the supplier can be a material risk for the buyer, and a model given no side will default to describing the clause neutrally rather than assessing it against your interests. Governing law matters for the same reason: notice provisions, liability caps, and non-compete terms are read differently under different state law, and an unprompted model tends toward a generic US reading.

3. Ask for structured output

Prompt the model to organize its findings in a predictable format: a table, a clause list, or a numbered set of risks. Structured output is easier to scan, and it is far easier to audit, because each row carries a clause reference you can open. Asking for prose invites the model to blend findings together, which is where unsupported assertions hide. Specify the columns you want:

1. The clause reference, so every finding can be opened and checked
2. The exact words the model relied on, quoted rather than paraphrased
3. Why the point matters to the party you represent
4. What you should do about it, stated as a question to raise rather than a conclusion

4. Extract the obligations and the deadlines

Ask for each party’s responsibilities, the dates attached to them, and the financial terms, as a table with clause references. Deadlines are among the most useful things to extract because they are objective, checkable, and expensive to miss. Treat the output as a list of places to look rather than a calendar you can act on.

5. Compare versions clause by clause

When reviewing successive drafts, ask the model to compare the versions and list what changed, clause by clause rather than as a narrative. The model is good at spotting changed wording and poor at judging which changes shift legal effect, so the useful output is a complete change list that you then triage yourself.

6. Open a fresh chat for each contract

Start a new conversation for every agreement. ChatGPT’s memory feature can carry details between conversations, and OpenAI documents that saved memories and chat history can be referenced in later responses unless memory is turned off in the settings, as described in the memory documentation. For contract work that creates two problems: terms from one client’s agreement can surface while you review another, and the model may answer about a clause that is not in the document in front of it.

7. Confirm every finding against the contract

Verify each finding against the clause it cites before it reaches a client, a counterparty, or a memo. Check that the clause reference is real, that the quoted language matches the contract, and that the reading holds under the governing law. Work through each finding against four questions:

1. Does the cited clause number exist, and does it say what the model quoted?
2. Does the reading hold under the governing law you named?
3. Does the finding depend on a defined term used elsewhere in the agreement?
4. What did the model not mention in this clause that you would expect to see?

The output is a starting point rather than a conclusion, and the review is not complete until a lawyer has read the clauses the model flagged and the ones it did not.

Ready-to-use ChatGPT prompts for contract review

The three prompts below handle the first-pass work a commercial lawyer is most likely to want from ChatGPT: a risk assessment, a missing-clause check, and a key-terms extraction. Each prompt below is written to be pasted as is, and each one names the party you represent, the governing law, and the output format, because a prompt that leaves those out produces generic commentary.

Prompt 1: First-pass risk assessment

Use this when you want a ranked view of where the risk sits in a reasonably standard agreement before committing time to a full review. How a contract review prompt is phrased changes what comes back, so each of the three below names the party, the governing law, and the output format.

> You are assisting a commercial lawyer with a first-pass review of a [contract type]. I represent [Party A], the [buyer or supplier]. The governing law is [governing law]. Review the contract text below and return a table with four columns: clause reference, the risk, why it matters to [Party A], and the question I should raise before signing. Rank the rows by exposure, highest first. Cover payment and fee mechanics, term and termination, liability and indemnity, confidentiality, and assignment. Quote the exact words you relied on in every row. Do not propose redline language and do not state a legal conclusion. If a problem is a missing clause rather than an unfavorable one, list it separately below the table.

Good output is a ranked table where every row quotes contract language you can locate. Check it in this order:

1. The top three rows, read against the clause itself rather than against the quoted fragment
2. Any row whose quotation you cannot find in the document, which is the model filling a gap
3. The separate missing-clause list, which is where the model is least reliable and the stakes are often highest

Prompt 2: Missing clause check

This one earns its keep on template-based agreements, where an absent clause is harder to notice than an unfavorable one.

> You are assisting a commercial lawyer reviewing a [contract type] governed by [governing law]. I represent [Party A]. Compare the contract text below against the clauses an agreement of this type normally contains, and return a checklist with three columns: clause, present or absent, and the clause reference where it appears. List the absent clauses first. For each absent clause, state in one sentence what [Party A] loses without it. Treat a clause as present only where the text creates the obligation, not where it merely mentions the topic. Do not draft replacement language.

Good output distinguishes a clause that is genuinely absent from one that is present in weakened form, which is the distinction that matters. Verify in this order:

1. The “present” rows, as carefully as the absent ones: a clause scored present can be a cross-reference to a schedule that does not exist
2. Each absent clause against the template you actually use, rather than against the model’s idea of a standard agreement
3. The one-sentence consequence beside each gap, which is where unsupported reasoning tends to appear

Prompt 3: Key terms extraction

Use this when you need the commercial shape of the deal quickly, for an internal update or a term sheet check.

> Extract the key commercial terms from the [contract type] below. I represent [Party A] and the governing law is [governing law]. Return a two-column table of term and value, putting the clause reference in the value cell, covering: parties, effective date, term length, renewal mechanism, notice period and delivery method for termination, fees and payment timing, price escalation, liability cap, representations and warranties, indemnities, confidentiality period, and assignment restrictions. Where the contract does not state a term, write “not stated” rather than inferring it. Quote figures and dates exactly as written. Do not summarize or interpret.

Good output carries a clause reference beside every value and an explicit “not stated” wherever the contract is silent. Work through it as follows:

1. Read the “not stated” rows first: a missing notice-delivery method or an absent escalation cap tells you where to negotiate
2. Spot-check every figure and date character by character, because transcription errors in amounts are common and consequential
3. Open two or three clause references at random to confirm the model is citing real provisions

Tips for better prompt results

A few habits make the output more predictable:

1. Be explicit about what the model should focus on: risks, obligations, deadlines, or commercial terms
2. Request structured output such as tables, bullet points, or numbered sections so results are easier to audit
3. Ask for specific clause numbers or section headings alongside every finding to reduce ambiguity
4. Specify the review perspective, such as reviewing as the buyer rather than as the vendor
5. Tell the model to say when the contract is silent instead of supplying what a contract of that type usually says

[cta-2]

What ChatGPT misses in a contract review

What ChatGPT misses in a contract review is rarely a clause it failed to find. Seven mechanics inside clauses it located and summarized correctly account for most of it: hidden fee structures, auto-renewal and notice traps, asymmetric liability and indemnity carve-outs, arbitration specifics, jurisdiction-specific requirements, consequential damages distinctions, and chains of cross-referenced defined terms.

Hidden or unusual fee structures

Pricing mechanics buried in dense language or spread across several sections are easy for the model to describe and hard for it to evaluate. Tiered fees, automatic escalations, and loosely defined charges slip through. A clause permitting “reasonable administrative fees” without defining “reasonable” can create open-ended cost exposure, and the model is likely to report the clause without flagging the exposure.

Automatic renewal and termination traps

Evergreen and auto-renewal provisions are a common miss, particularly where notice requirements are specific. The model recognizes that termination is permitted and tends to lose the mechanics. A clause requiring “written notice via certified mail 120 days prior to the anniversary date” carries four separate conditions, and missing any one of them is the difference between exiting the contract and renewing it for another year.

Asymmetric liability caps and indemnity carve-outs

Layered liability structures are where the model’s output is least dependable. A cap that applies to one party and not the other, a carve-out that lifts the cap for a named category of claim, or an indemnity whose scope is set by a definition elsewhere all require reading several provisions against each other. Representations and warranties belong in the same check, because they are what the indemnity is usually triggered by: a model that reads the indemnity clause in isolation will not tell you that the warranty it depends on was narrowed to the supplier’s knowledge. Stanford RegLab and HAI researchers measured hallucination rates of 69% to 88% on specific legal queries about case law, holdings, and precedential relationships, which is a finding about legal authority rather than about clause mechanics, and it is a reasonable caution to carry into any question where the model has to reason across provisions.

Arbitration and dispute resolution specifics

The model reliably notes that arbitration applies and routinely drops the details that determine what arbitration means here: the forum, the governing rules, discovery limits, the number of arbitrators, and class action waivers. The choice of rules alone changes the process materially, and the American Arbitration Association publishes separate rule sets whose provisions on discovery, consolidation, and arbitrator appointment differ.

Jurisdiction-specific requirements

General-purpose models have patchy awareness of state-specific statutes, industry regulation, and recent developments. A California employment agreement may require wage statement or notice provisions that the model will not flag as absent, because it is pattern-matching against agreements generally rather than against the law of a named state.

Consequential damages distinctions

Distinctions between direct, indirect, consequential, and incidental damages are frequently conflated. The model may summarize a damages exclusion accurately and still fail to identify whether it is drafted narrowly or broadly, which is the question the clause exists to answer.

Chains of cross-referenced defined terms

This is the miss that is hardest to catch by reading the output. A definition in clause 1 can narrow an obligation in clause 12, and the model reads each clause substantially on its own. It will summarize clause 12 correctly as written and miss that the defined term carves out most of what the clause appears to require.

Limitations of using ChatGPT for contract review

The limitations of ChatGPT for contract review are structural rather than fixable by better prompting. It fabricates legal authority at measurable rates, it has no access to your playbook or your precedent, its consumer plans may use what you upload to train models, and its Microsoft Word extension cannot apply your playbook or return the review as native tracked changes, which is where the redlining actually happens.

No access to your positions

The model has no knowledge of your firm’s negotiated positions, your fallback language, or the deals you have already done. It assesses a clause against agreements generally rather than against what your client accepted last quarter, so it cannot tell you that a cap is unusual for you even where it is ordinary for the market. A review that does not know your standards cannot enforce them. A playbook holds four things the model has no way to reach:

1. The standard position your firm opens with on each clause
2. The fallback positions, in the order you are willing to concede them
3. The terms that are genuinely non-negotiable, and who may waive them
4. What comparable counterparties have already accepted

Fabricated authority

A second Stanford analysis found legal models hallucinating in one out of six or more benchmarking queries, and the failure mode is the problem rather than the rate: the fabricated citation, holding, or statutory reference arrives in the same confident register as the correct ones. Nothing in the output marks which parts were invented, so verification cannot be targeted and has to be total.

Data handling

What happens to an uploaded contract is set by the plan it was uploaded under and by an account setting, rather than by any fixed property of the tool. That makes confidentiality a configuration question, which is a limitation in itself: the answer can change when a plan is upgraded, when a firm adds seats, or when someone toggles a setting, and nothing in the interface tells the reviewing lawyer that it changed.

No place in the drafting workflow

ChatGPT runs in a browser tab, not in the document. Applying its suggestions means moving between windows and retyping or pasting language into the contract, which is slow and introduces transcription errors in exactly the places that matter. The redlining, the tracked changes, and the comment thread the counterparty will read all live in the document, and the model is not there.

Is it safe to put a contract into ChatGPT?

Whether it is safe to upload a contract to ChatGPT depends on which ChatGPT you are using. On the individual Free, Plus, and Pro plans, OpenAI states that it may use your content to train its models unless you turn off “Improve the model for everyone” in Data controls, so an unredacted client agreement does not belong there. On ChatGPT Business, Enterprise, Edu, and the API, OpenAI states that it does not use inputs or outputs to improve its models by default, which changes the confidentiality analysis without removing the duty to run it.

What the plan tier changes

The opt-out on individual plans has an exception worth knowing: OpenAI’s documentation on how uploaded content is used states that submitting thumbs-up or thumbs-down feedback on a response allows that conversation to be used for training even after the setting has been turned off. A lawyer who has opted out and then rates an answer has put the contract back in scope.

The tiers divide as follows:

1. Free, Plus, and Pro: content may be used for training unless “Improve the model for everyone” is turned off in Data controls
2. Business, Enterprise, and Edu: inputs and outputs are not used to improve models by default
3. The API: not used for training by default, though an organization owner can opt in

On the business tiers the default runs the other way, and the terms are set out in OpenAI’s enterprise privacy commitments. One detail matters for firms running their own integration: an API organization owner can opt in to data sharing, so the default is a setting rather than a fixed property of the account, and someone has to confirm which way it is set.

What redaction does and does not solve

None of that resolves the professional obligation. Confidentiality duties attach to the information rather than to the vendor’s policy, and the practical consequence is that the plan tier determines what redaction is required rather than whether redaction is required. The broader question of what ChatGPT does with the data you give it is worth settling at the firm level rather than per matter, because the answer drives which agreements can be uploaded at all. Redaction remains the control that does not depend on anyone else’s configuration, and it carries the trade-off named earlier in the preparation steps: the detail you remove to protect the client is often the detail the review needed.

Who is responsible when ChatGPT gets a contract wrong

The reviewing lawyer is responsible when ChatGPT gets a contract wrong. ChatGPT is not licensed to practice law, carries no malpractice coverage, and owes your client no duty, so every error it produces and you pass on remains your error. ABA Formal Opinion 512 sets out the duties that follow: competence in the tool, confidentiality of what you put into it, supervision of the output, and candor about the fees you bill for it.

Opinion 512 also treats client consent as a threshold question: where information relating to a representation is entered into a self-learning tool, the opinion calls for the client’s informed consent first. The supervision duty is the one that bites hardest in contract work. Opinion 512 frames competence as requiring a reasonable understanding of the capabilities and limitations of the specific tool in use, which is a factor-based standard rather than a bright-line rule, and it is not satisfied by a general awareness that models make mistakes. In practice it means the reviewing lawyer can say which parts of the output were verified against the contract and how.

The cautionary example is not hypothetical. In Mata v. Avianca, counsel filed a brief citing judicial decisions that did not exist and were produced by ChatGPT, and the court imposed sanctions after the citations could not be substantiated; the filings are on the public docket at CourtListener. The pattern transfers directly to contract work, where a fabricated cross-reference or a misstated cap is less visible than a fake case and reaches a counterparty rather than a judge.

A firm policy is the practical answer, and it is likely to be read as evidence of supervision if a review is ever questioned. The useful version names four things:

1. Which plan tier is approved, and who confirms the data controls on it
2. Which categories of document may be uploaded, and in what redacted form
3. Who verifies output before it leaves the firm, and against what
4. How the verification is recorded, so supervision can be evidenced later

Whether and how lawyers may use ChatGPT is answered by the policy; the harder half is the record that evidences it.

ChatGPT vs. a specialist contract review tool

ChatGPT is a general-purpose assistant that reads a contract you paste into it; a specialist contract review tool is grounded in your playbook and in market contract data and returns the review as tracked changes in Microsoft Word. They differ on grounding, data handling, where the review lands, and whether the tool can hold your firm’s negotiated positions.

A general-purpose assistant like ChatGPT

Pros

1. Available immediately, with no procurement, configuration, or onboarding
2. Strong at summarizing, extracting, and explaining contract language
3. Flexible across document types and tasks, legal and otherwise
4. Low cost relative to specialist legal software

Cons

1. No knowledge of the firm’s playbook, precedent, or prior positions
2. Fabricates legal authority without signaling which output is invented
3. Data handling varies by plan tier and by a setting someone has to verify
4. Produces chat text rather than tracked changes, so edits are applied by hand
5. No professional accountability for an error it introduces

Purpose-built contract review software

Pros

1. Grounded in the firm’s own standards, so a review can enforce them consistently
2. Returns redlines as native tracked changes in the document under negotiation
3. Contractual data handling terms rather than a user-configurable setting
4. Compares clause positions against market contract data instead of general text

Cons

1. Scoped to commercial contract work, so it is not a legal research or litigation platform and it is not a document store
2. Requires a playbook to be defined before the grounding benefits apply
3. Priced as specialist legal software rather than as a general consumer subscription
4. The lawyer still reviews and owns every proposed change

Spellbook sits in the second category as a commercial contract specialist rather than a general assistant or a contract lifecycle management system. The Review feature surfaces risks and proposes redlines as native Word tracked changes, the Playbooks feature applies a firm’s standard and fallback positions so a contract playbook is enforced rather than remembered, and the Compare to Market feature checks clause positions against 2,300+ benchmark standards drawn from 20M+ real contracts and 270+ clause types. Spellbook operates under zero data retention agreements with its model providers and does not use customer documents for training. Pricing is custom per seat by team size, with a free seven-day trial. In every case the output is a proposal: the lawyer reads the redline, accepts or rejects it, and signs off on what goes back to the counterparty.

What ChatGPT can and cannot do in a contract review

ChatGPT is dependable for triage on standard paper and unreliable for the judgment a review exists to produce. It will tell you what an agreement says faster than you can read it, and it will do that well enough to be worth the few minutes it takes, provided the contract is standard, the text is prepared, the prompt names your side and the governing law, and every finding is checked against the clause it cites. What it will not do is hold your positions, see across provisions, owe a duty of confidentiality, or carry any part of the risk when it is wrong.

A lawyer doing occasional first-pass work on low-stakes paper is well served by a general assistant used carefully. A team reviewing third-party contracts at volume, against its own standards, inside the document, needs software built for it. Try Spellbook free to see how the Review feature handles your contracts in Word.

[cta-3]

Frequently Asked Questions About ChatGPT Contract Review

Can ChatGPT redline a contract?

Not in the way a lawyer means by redlining. ChatGPT can propose replacement wording in a chat window, but it cannot produce tracked changes in the document, so the edits are applied by hand and the change history is whatever the lawyer reconstructs. The practical limits of using ChatGPT to redline contracts come down to that gap between suggested language and an editable redline the counterparty can accept or reject.

Can you use ChatGPT to write contracts?

ChatGPT can produce a first draft of a standard agreement, and the output tends to be a generic template with plausible clauses rather than one that reflects a negotiated position. The risks are the same as in review and somewhat larger, because a drafting error creates the obligation rather than merely failing to spot it. A draft produced this way needs the same clause-by-clause verification as a third-party document.

Can ChatGPT hallucinate court cases?

Yes, and it is one of the better-documented failure modes of large language models in legal work. Fabricated case names, holdings, and citations appear in the same confident style as accurate ones, which is why every authority has to be opened and read rather than spot-checked. The consequences of filing AI-generated citations have included sanctions and referrals.

Does a contract reviewed with ChatGPT hold up in court?

The tool used to review an agreement does not generally affect its enforceability, which turns on the contract and the governing law rather than on the review process. What the review method can affect is the lawyer’s position: a term that is unenforceable, missing, or misunderstood because the review relied on unverified output is a problem of professional responsibility rather than of contract validity.

Can ChatGPT find loopholes in a contract?

It can surface candidates and should not be trusted to find them. The gaps that function as loopholes usually depend on the interaction between provisions, such as a defined term that narrows an obligation or a carve-out that lifts a cap, and reasoning across provisions is where the model is least dependable. Treat the output as a list of places to look.

Can ChatGPT identify all key clauses in a contract?

It identifies most clauses in a conventionally structured agreement and should not be relied on for completeness. It recognizes patterns, so unconventional drafting, clauses split across sections, and obligations created by a schedule rather than by the body of the agreement are the ones most likely to be missed. Enumeration is also where silence is dangerous: the model rarely reports that it found nothing in a category.