Legal contract review and executive summary generation for in-house counsel

Introduction

In-house counsel teams spend weeks every month reviewing contracts. A procurement manager sends over a vendor agreement, legal reads through 40 pages, identifies key risks, extracts dates and obligations, then writes a one-page summary for the CFO. By the time that summary lands, three days have passed. Now multiply that across dozens of contracts per month.

The problem is clear: contract review is necessary but crushingly manual. Most law firms and corporate legal departments lack dedicated tools that bridge the gap between document ingestion and actionable intelligence. You end up with either slow human review or crude PDF extraction that misses context entirely.

What if you could set up a system that takes any contract PDF, extracts its contents intelligently, analyses key sections for risk, rewrites the summary in plain English, and deposits a finished brief in your email inbox within minutes? No human handoff required between steps. This post shows you how to build that exact workflow using four tools and one orchestration platform.

The Automated Workflow

We'll use three AI tools working together: Chat with PDF by Copilotus (for intelligent document parsing), Quillbot (for polishing summaries into clear executive language), and Wispr Flow AI (for conditional logic based on contract type). The orchestration engine that ties everything together is Make (formerly Integromat), though Zapier or n8n will work if you prefer.

Architecture Overview

The workflow operates in five stages:

1. A contract PDF arrives (via email or upload).

2. Chat with PDF extracts content and answers specific questions about the contract.

3. The extracted data is cleaned and structured.

4. Quillbot rewrites the summary into executive-friendly language.

5. An email with the finished brief is sent to your team.

Wispr Flow AI acts as a classifier in the middle, routing contracts to different summary templates depending on whether they're NDAs, vendor agreements, employment contracts, or licensing deals.

Step 1:

Trigger and PDF Upload

Start with an email trigger in Make. Set it to watch a specific inbox folder (e.g., "Legal Review Queue").

Copy
{
  "trigger": "email",
  "folder": "Legal Review Queue",
  "attachment_filter": "*.pdf",
  "webhook_url": "https://hook.make.com/YOUR_WORKFLOW_ID"
}

When an email with a PDF lands in that folder, Make extracts the file and passes it to the next step. The PDF's filename becomes a variable you can reference later, which is useful for tracking.

Step 2:

Send PDF to Chat with PDF API

Chat with PDF by Copilotus has a straightforward REST API. You'll upload the PDF and ask it structured questions about the contract.

Copy
POST /api/v1/documents/upload
Host: api.chatpdf.copilotus.io
Authorization: Bearer YOUR_API_KEY
Content-Type: multipart/form-data

{
  "file": <PDF_BINARY>,
  "document_name": "{{email.attachment.filename}}"
}

This returns a document_id that you'll use in subsequent requests. Store this ID as a workflow variable in Make.

Next, ask the API for specific contract information. Send multiple queries in parallel to speed things up:

Copy
POST /api/v1/documents/{document_id}/query
Host: api.chatpdf.copilotus.io
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "queries": [
    "What is the contract start date and end date?",
    "What are the termination clauses and notice periods?",
    "What payment amounts and schedule are specified?",
    "What are the key obligations of each party?",
    "What indemnification or liability caps are included?",
    "What happens if either party breaches the contract?"
  ]
}

Chat with PDF returns structured answers to each question. In Make, set up a "HTTP Request" module for each query, then combine the responses into a single JSON object.

Step 3:

Classify Contract Type with Wispr Flow AI

Before generating a summary, you want to know what kind of contract this is. Wispr Flow AI can classify documents based on content patterns.

Copy
POST /api/v1/classify
Host: api.wispr-flow.ai
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "text": "{{step2.extracted_content}}",
  "categories": [
    "NDA",
    "Vendor Agreement",
    "Employment Contract",
    "Licensing Deal",
    "Service Agreement"
  ]
}

The API returns a confidence score for each category. Use Make's conditional routing to send the contract type downstream. If it's classified as an NDA with 85% confidence, route it to the NDA summary template. If it's a vendor agreement, use the vendor template instead.

Step 4:

Build the Executive Summary

This is where you construct the summary text from the extracted data. Create a text template in Make that includes the contract type, key dates, financial terms, and risks. Keep it to 150-200 words.

Copy
Template text in Make:

CONTRACT SUMMARY

Type: {{wispr_classification}}
Document: {{email.attachment.filename}}

Key Dates:
- Start: {{step2.start_date}}
- End: {{step2.end_date}}
- Renewal: {{step2.renewal_date}}

Financial Terms:
- Amount: {{step2.payment_amount}}
- Payment Schedule: {{step2.payment_schedule}}
- Late Payment Terms: {{step2.late_payment_terms}}

Obligations:
{{step2.obligations_summary}}

Risk Flags:
{{step2.risk_items}}

Next Steps:
Review termination clauses. Note liability cap of {{step2.liability_cap}}.

In Make, use a "Text Composer" module or a built-in template function to assemble this. The output is your raw summary.

Step 5:

Polish with Quillbot API

Raw extracted text from Chat with PDF can be awkward. Quillbot's rewrite API will polish it into professional executive language without changing meaning.

Copy
POST /api/v1/rewrites
Host: api.quillbot.com
Authorization: Bearer YOUR_QUILLBOT_API_KEY
Content-Type: application/json

{
  "text": "{{step4.raw_summary}}",
  "mode": "professional",
  "length": "shorten",
  "tone": "formal"
}

Quillbot returns a polished version. The "shorten" length parameter keeps your summary concise, and "professional" tone ensures it reads like legal correspondence, not casual writing.

Step 6:

Send Summary via Email

Finally, compose an email to your legal team with the finished brief.

Copy
POST /api/v1/send
Host: smtp.api.make.com
Authorization: Bearer YOUR_MAKE_API_KEY
Content-Type: application/json

{
  "to": "{{env.legal_team_email}}",
  "subject": "Contract Review: {{email.attachment.filename}} ({{wispr_classification}})",
  "body": "{{step5.polished_summary}}",
  "attachments": [
    {
      "filename": "{{email.attachment.filename}}",
      "content": "{{step1.pdf_binary}}"
    }
  ]
}

Include the original PDF as an attachment so your team can refer back to it if needed.

Make Workflow Configuration

Here's a rough outline of how this looks in Make's visual editor:

1. Trigger Module: Email (watch folder for new attachments).

2. HTTP Module 1: Upload PDF to Chat with PDF API (returns document_id).

3. HTTP Module 2-7: Query the document six times in parallel (dates, termination, payments, obligations, indemnification, breach clauses).

4. Text Aggregator: Combine all responses into a single JSON object.

5. HTTP Module 8: Classify with Wispr Flow AI.

6. Router Module: Route based on classification result.

7. Text Composer: Build the raw summary from extracted data (different template per route).

8. HTTP Module 9: Send summary to Quillbot for polishing.

9. Email Module: Send final email with polished summary and original PDF.

Each module takes a few minutes to configure, and Make provides a visual connection between them. Error handling modules should sit after steps 2, 4, 8, and 9 to catch API failures and notify you if something breaks.

The Manual Alternative

If you want more granular control, you can skip full automation and use a "semi-automated" approach instead. Manually upload each contract to Chat with PDF's web interface, review the extracted answers yourself, then copy them into a summary template. From there, paste the summary into Quillbot's web app for one final polish before sending.

This cuts the time per contract from 45 minutes to about 15 minutes, and you maintain veto power over the classification and summary before it reaches your team. It's useful if your contracts are highly unusual or if you want to train the system with feedback before fully automating.

Wispr Flow AI can still run automatically in the background to suggest contract types, giving you a prompt without enforcing a decision.

Pro Tips

Error handling and retries: The Chat with PDF API occasionally times out on large documents (over 100 pages). In Make, add a retry module that waits 30 seconds and tries the upload again. Set it to retry up to 3 times before sending a failure notification to your inbox.

Rate limits: Both Chat with PDF and Quillbot have rate limits on their free and pro plans. Chat with PDF allows 100 documents per day on the free tier. If your firm reviews more than 100 contracts monthly, upgrade to their professional plan or stagger uploads across multiple hours using Make's scheduling feature.

Cost optimisation: Don't send every extracted field to Quillbot. Only polish the final summary paragraph, not the raw extracted data. This reduces API calls to Quillbot by about 70% and cuts your monthly cost significantly.

Contract type accuracy: Wispr Flow AI's classification is 92% accurate on common contract types (NDAs, vendor agreements) but drops to 75% on unusual ones (complex M&A side letters). For high-stakes contracts, set a confidence threshold of 90% and flag anything below that for manual review instead of auto-routing.

Data privacy: If your contracts contain sensitive information (client names, pricing tiers, confidential terms), ensure you're using paid API tiers with data encryption and no logging. Most free tiers log requests for model improvement. Verify with each vendor's privacy policy before processing.

Cost Breakdown

At 150 contracts per month, your per-contract cost is roughly £0.40. A single hour of lawyer time (even at the junior associate level) costs £75-150. If this workflow saves 30 minutes per contract, you're saving £1,125-2,250 monthly in labour costs alone.

If your firm processes 500+ contracts per month, volume discounts on Chat with PDF and Make bring the total to around £80-90, or £0.16-0.18 per contract.

Next Steps

Start by setting up the workflow in Make with just the first three modules: email trigger, PDF upload, and a single Chat with PDF query (e.g., "Summarise this contract in one paragraph"). Test it with a real contract from your queue. Once that works smoothly, add the classification and multi-query steps. Finally, integrate Quillbot and email.

This phased approach means you'll catch API connection issues early and can refine your questions to Chat with PDF before the system is fully live.