Claude API Case Study: How a Legal Tech Startup Cut Contract Review from 4 Hours to 35 Minutes

From 4 Hours to 35 Minutes: Automating Contract Redlining with Claude API

When LegalShift, a Series A legal tech startup, set out to automate contract redlining for mid-market law firms, they faced a familiar challenge: attorneys were spending an average of 4 hours per agreement on clause extraction, risk assessment, and manual tracked-changes markup. By integrating Anthropic’s Claude API into their pipeline, they reduced that cycle to 35 minutes — an 85% reduction in review time — while maintaining the quality bar required by practicing attorneys. This case study walks through the technical architecture, code implementation, and production lessons from their deployment.

Architecture Overview

The system operates in three sequential stages:

• Clause Extraction — Parsing the contract into structured clauses with metadata- Risk Scoring — Evaluating each clause against a configurable risk rubric- Tracked-Changes Output — Generating redlined suggestions in a format attorneys can review in Microsoft WordEach stage uses Claude API calls with carefully tuned system prompts and structured output schemas.

Setup and Installation

# Install dependencies pip install anthropic python-docx json-schema

export ANTHROPIC_API_KEY=“YOUR_API_KEY”

The project uses Python 3.11+ and the official Anthropic SDK. # requirements.txt anthropic>=0.39.0 python-docx>=1.1.0 pydantic>=2.5.0

Stage 1: Clause Extraction

The first API call parses raw contract text into structured clauses. Using Claude's extended thinking capability ensures the model reasons through ambiguous clause boundaries before responding. import anthropic import json

client = anthropic.Anthropic() # Uses ANTHROPIC_API_KEY env var

Return ONLY valid JSON. No commentary.""", messages=[{“role”: “user”, “content”: contract_text}] ) return json.loads(response.content[0].text)

Stage 2: Risk Scoring

Each extracted clause is scored against a configurable risk rubric. The rubric is loaded from a JSON file that legal teams can customize per client or jurisdiction. def score_clause(clause: dict, rubric: dict) -> dict: response = client.messages.create( model="claude-sonnet-4-20250514", max_tokens=2048, system=f"""You are a legal risk analyst. Score the following clause on a 1-10 risk scale using this rubric: {json.dumps(rubric, indent=2)}

Return JSON with:

• risk_score (integer 1-10)
• risk_factors (array of strings)
• recommendation (string: accept|flag_for_review|reject_and_redline)
• reasoning (string, 1-2 sentences)""", messages=[{“role”: “user”, “content”: json.dumps(clause)}] ) result = json.loads(response.content[0].text) result[“clause_id”] = clause[“clause_id”] return result

  Example rubric configuration: // risk_rubric.json { “indemnification”: { “high_risk_triggers”: [“unlimited liability”, “sole indemnification”], “threshold”: 7 }, “termination”: { “high_risk_triggers”: [“termination for convenience”, “no cure period”], “threshold”: 6 }, “ip_assignment”: { “high_risk_triggers”: [“all work product”, “pre-existing IP”], “threshold”: 8 } }

Stage 3: Tracked-Changes Output

For clauses flagged as reject_and_redline, a third API call generates alternative language. The system then uses python-docx to produce a Word document with tracked changes. def generate_redline(clause: dict, risk_result: dict) -> dict: response = client.messages.create( model="claude-sonnet-4-20250514", max_tokens=2048, system="""You are a contract drafting assistant. Given a risky clause and its risk analysis, propose revised language that: 1. Mitigates the identified risk factors 2. Preserves the commercial intent 3. Uses standard market terms

Return JSON with:

• original_text (string)
• revised_text (string)
• change_summary (string, brief description of changes)""", messages=[{“role”: “user”, “content”: json.dumps({ “clause”: clause, “risk_analysis”: risk_result })}] ) return json.loads(response.content[0].text)

  from docx import Document
  from docx.oxml.ns import qn
  from docx.oxml import OxmlElement

def create_redlined_doc(redlines: list[dict], output_path: str): doc = Document() doc.add_heading(“Contract Redline — Auto-Generated”, level=1) for item in redlines: para = doc.add_paragraph() # Strikethrough for deleted text del_run = para.add_run(item[“original_text”]) del_run.font.strike = True del_run.font.color.rgb = RGBColor(0xFF, 0x00, 0x00) para.add_run(” ”) # Underline for inserted text ins_run = para.add_run(item[“revised_text”]) ins_run.font.underline = True ins_run.font.color.rgb = RGBColor(0x00, 0x00, 0xFF) doc.add_paragraph(f”Change note: {item[‘change_summary’]}”, style=“Intense Quote”) doc.save(output_path)

Full Pipeline Orchestration

def process_contract(filepath: str, rubric_path: str) -> str:
    with open(filepath, "r") as f:
        contract_text = f.read()
    with open(rubric_path, "r") as f:
        rubric = json.load(f)

    # Stage 1
    clauses = extract_clauses(contract_text)
    print(f"Extracted {len(clauses)} clauses")

    # Stage 2
    scored = [score_clause(c, rubric) for c in clauses]
    flagged = [s for s in scored if s["recommendation"] == "reject_and_redline"]
    print(f"{len(flagged)} clauses flagged for redlining")

    # Stage 3
    redlines = []
    for flag in flagged:
        clause = next(c for c in clauses if c["clause_id"] == flag["clause_id"])
        redlines.append(generate_redline(clause, flag))

    output_path = filepath.replace(".txt", "_redlined.docx")
    create_redlined_doc(redlines, output_path)
    return output_path

Results

Can Claude API handle contracts in languages other than English?

Yes. Claude supports multilingual input and output effectively. LegalShift tested with German and French commercial agreements and achieved comparable clause extraction accuracy. Adjust the system prompt language and risk rubric terminology to match the target jurisdiction. For bilingual contracts, instruct the model to preserve the original language while providing risk analysis in your preferred language.

How does this approach handle confidentiality of sensitive legal documents?

Anthropic does not train on data submitted through the API. For additional security, use the API with a Business or Enterprise account that provides a zero-retention policy. LegalShift also implemented client-side PII redaction before API calls for matters requiring maximum confidentiality, replacing party names and financial figures with placeholders and re-inserting them post-processing.

What is the per-contract API cost at production scale?

For a typical 30-page commercial agreement with approximately 45 clauses, the pipeline uses roughly 80,000 input tokens and 15,000 output tokens across all three stages. Using Claude Sonnet at current pricing, this runs approximately $8–$15 per contract. Enabling prompt caching on the system prompt and rubric reduces this by 60-80% for subsequent contracts using the same rubric, bringing the effective cost to $2–$5 per agreement.