Representations and Warranties Extraction Prompt

This prompt is designed for M&A and due diligence teams who need to extract representations and warranties from transaction documents at scale. It produces structured outputs that capture the rep statement text, survival periods, knowledge qualifiers, materiality scrapes, and disclosure schedule references. Use this prompt when you need to build a rep and warranty index, compare seller and buyer reps across deal documents, or feed structured rep data into downstream risk assessment and negotiation playbooks.

The prompt assumes you have already extracted or chunked the relevant contract sections and are providing clean text input. It does not handle scanned PDFs, handwriting, or multi-document cross-referencing on its own. For those cases, pair this prompt with OCR-aware preprocessing and document structure parsing prompts from the Document Intelligence pillar. The output schema is designed to be ingested by a database or risk analysis tool, not to produce a final legal memo. Always route outputs through a validation layer that checks for missing qualifiers, incorrect survival period formats, and hallucinated disclosure schedule references before the data enters a system of record.

Do not use this prompt for real-time negotiation support, for generating legal advice, or as a substitute for attorney review. It is a structured extraction tool that reduces manual data entry and speeds up diligence, but it does not interpret the legal effect of a representation. For workflows that require comparing extracted reps against a negotiation playbook or scoring risk, chain this prompt's output into the Clause Risk Scoring and Playbook Alignment Prompt. For production deployments, implement a human review step for any rep flagged with a low confidence score or an unrecognized qualifier hierarchy.

This template is designed to be pasted directly into your system instructions or as a user message for a capable language model. It instructs the model to act as a precise extraction engine, isolating representations and warranties from a provided contract. The prompt is structured to capture not just the statement itself, but the critical legal nuances that surround it: knowledge qualifiers, materiality scrapes, survival periods, and references to disclosure schedules. The output is a strict JSON schema, making it suitable for direct ingestion into a downstream due diligence checklist or contract review platform.

textCopy
You are a precise legal document extraction engine. Your task is to identify and extract all representations and warranties from the provided [CONTRACT_TEXT].

For each representation or warranty found, extract the following information into a structured JSON object. If a field is not present or cannot be determined, use `null`.

## Output Schema
Return a JSON object with a single key `"representations_and_warranties"` containing an array of objects. Each object must have these fields:
- `"statement"`: (string) The exact text of the representation or warranty.
- `"section_reference"`: (string) The section, article, or schedule number where it was found (e.g., "Section 3.1(a)").
- `"party_making_statement"`: (string) The party providing the representation (e.g., "Seller", "Company").
- `"subject_matter"`: (string) A concise category for the statement (e.g., "Organization and Good Standing", "Financial Statements", "Litigation").
- `"knowledge_qualifier"`: (string or null) The exact text of any knowledge qualifier (e.g., "to the best of Seller's knowledge").
- `"materiality_qualifier"`: (string or null) The exact text of any materiality qualifier or scrape (e.g., "in all material respects", "Material Adverse Effect").
- `"survival_period"`: (string or null) The duration the representation survives closing, if specified (e.g., "12 months", "until the expiration of the applicable statute of limitations").
- `"disclosure_schedule_reference"`: (string or null) Any reference to a disclosure schedule that qualifies the statement (e.g., "except as set forth on Schedule 3.1").
- `"is_sandbagging_provision"`: (boolean) `true` if the clause explicitly addresses the buyer's right to seek indemnification for breaches it knew about before closing. Otherwise, `false`.

## Constraints
- Extract the statement text verbatim. Do not paraphrase.
- If a single sentence contains multiple representations, separate them into distinct objects.
- Pay close attention to the hierarchy of qualifiers. A knowledge qualifier can be nested inside a materiality qualifier. Capture both independently.
- If a survival period is defined in a separate survival clause but explicitly linked to this representation, capture it. If it's a general survival clause with no explicit link, use `null`.

## Input
[CONTRACT_TEXT]

To adapt this prompt, replace the [CONTRACT_TEXT] placeholder with the full text of the agreement you are analyzing. For production systems, you will likely need to pre-process the document to extract clean text and segment it into manageable chunks, as a single contract can easily exceed a model's context window. Consider pairing this extraction prompt with a document structure parsing prompt to first identify the section hierarchy, then run this extraction on individual articles. The output schema is designed to be validated programmatically; a post-processing step should check for valid JSON, correct data types, and non-null values for the statement and section_reference fields. In high-stakes M&A due diligence, a human reviewer must always verify the extracted statements against the original document, as a missed qualifier or misattributed survival period can have significant financial consequences.

This prompt is designed to be a single step within a larger document processing pipeline. It should not be called in isolation on raw, unprocessed PDFs. The upstream system must first parse the document, extract text with layout awareness, and segment it into manageable chunks—ideally at the section or article level. The prompt expects a clean text block as the [CONTRACT_SECTION] input. Feeding it an entire 80-page purchase agreement will degrade extraction quality and increase the risk of hallucinated or merged provisions. For production use, implement a pre-processing stage that identifies the 'Representations and Warranties' article using a document structure parser or a classification router before invoking this extraction prompt.

The output is a structured JSON array of representations. Each object must be validated against the defined [OUTPUT_SCHEMA] before it is stored. Implement a post-processing validation layer that checks for required fields (statement, survival_period, knowledge_qualifier, materiality_scrape, disclosure_schedule_reference), enforces enum values for knowledge_qualifier and materiality_scrape, and flags any confidence_score below a configurable threshold (e.g., 0.85) for human review. A common failure mode is the model merging two distinct representations into a single object or splitting a single complex sentence into fragments. A structural validator should check for unusually long statement strings and flag them for decomposition, and conversely, flag objects with identical disclosure_schedule_reference values that may need merging.

For high-stakes M&A workflows, a human-in-the-loop review step is non-negotiable. Route all extractions with confidence_score below your threshold, detected sandbagging provisions (sandbagging_provision: true), or missing survival periods to a review queue. Log the full prompt, the raw model response, and the validated output for auditability. When selecting a model, prioritize those with strong legal text reasoning and structured output capabilities. Implement retry logic with a maximum of two attempts for schema validation failures, using a repair prompt that includes the original input, the failed output, and the specific validation errors. If the retry also fails, escalate to human review rather than silently dropping the record. This prompt is a high-precision extraction tool, not a replacement for legal judgment; always ensure a qualified professional reviews the final output before it informs a transaction decision.