Academic literature review synthesis from research papers

Academic literature reviews consume enormous amounts of time. You read papers, extract key findings, summarise arguments, cross-reference concepts, then manually compile everything into a coherent synthesis. Most researchers do this by hand: opening PDFs, highlighting passages, switching between tabs, pasting excerpts into documents, and wrestling with formatting....... For more on this, see Academic research paper summarisation and citation extrac.... For more on this, see Academic research synthesis and citation-ready literature.... For more on this, see Academic paper research and literature review synthesis.

There is a better way. By combining three complementary AI tools, you can build an automated workflow that pulls insights directly from research papers, extracts their essential arguments, summarises findings at scale, and delivers structured synthesis ready for your own analysis. No copy-paste. No manual compilation. No context-switching between tools.

This workflow sits at the intermediate level because it requires basic configuration knowledge, but you do not need to write complex code. You will wire together existing APIs using orchestration platforms like Zapier, n8n, or Make, then let the system run whilst you focus on the intellectual work of evaluating the synthesised results.

The Automated Workflow

What You Are Building

The workflow takes a folder of research papers (or a list of paper URLs) as input, then produces a structured literature review document with summaries, key arguments, and thematic connections. Here is the flow:

1. ChatWithPDF extracts full text and key passages from each paper
2. ExplainPaper identifies main arguments and concepts
3. Resoomer condenses findings into bullet points
4. An orchestration tool collects all outputs and formats them into a single synthesis document

The entire process requires zero manual handoff between steps.

Choosing Your Orchestration Tool

You have three realistic options: Zapier, n8n, or Make. Here is how they differ for this particular task:

• Zapier works well if you want the simplest setup with pre-built connectors. It requires minimal configuration but costs more per API call, making it expensive for high-volume workflows.

• n8n is self-hosted or cloud-based, offers lower per-execution costs, and gives you fine-grained control over data transformation. It is ideal if you are processing 50+ papers regularly.

• Make sits between the two; it has reasonable pricing, decent pre-built integrations, and a visual editor that feels intuitive. For most researchers, Make offers the best balance of simplicity and cost.

For this guide, we will show Make alongside code examples you can adapt to n8n or build yourself in Claude Code if you prefer a fully custom solution.

Step 1: Extract Text from PDFs

ChatWithPDF by Copilotus provides an API that accepts a PDF URL or file and returns the full text content. You will use this as your entry point.

Endpoint documentation for ChatWithPDF:

Copy
POST https://api.copilotus.app/v1/pdf/extract
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json

Body:
{
  "pdf_url": "https://example.com/paper.pdf",
  "extract_type": "full_text"
}

Response:
{
  "text": "Full paper text here...",
  "pages": 12,
  "title": "Paper title",
  "url": "https://example.com/paper.pdf"
}

In Make, you would add an HTTP module configured like this:

Copy
Method: POST
URL: https://api.copilotus.app/v1/pdf/extract
Headers:
  Authorization: Bearer {{YOUR_API_KEY}}
  Content-Type: application/json
Body:
  pdf_url: {{trigger.pdf_url}}
  extract_type: "full_text"

The output (the extracted text) feeds directly into the next module.

Step 2: Identify Main Arguments with ExplainPaper

ExplainPaper has an API endpoint that analyses extracted text and identifies the core thesis, methodology, key findings, and limitations. This is where the synthesis begins to take shape.

ExplainPaper API endpoint:

Copy
POST https://api.explainpaper.com/v1/analyse
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json

Body:
{
  "text": "Full paper text from step 1",
  "analysis_type": "structured"
}

Response:
{
  "thesis": "The main argument of the paper",
  "methodology": "How the research was conducted",
  "key_findings": [
    "Finding 1",
    "Finding 2",
    "Finding 3"
  ],
  "limitations": "Stated limitations and gaps",
  "concepts": ["concept1", "concept2", "concept3"]
}

In Make, map the output from Step 1 into Step 2:

Copy
Method: POST
URL: https://api.explainpaper.com/v1/analyse
Headers:
  Authorization: Bearer {{YOUR_API_KEY}}
  Content-Type: application/json
Body:
  text: {{step1.text}}
  analysis_type: "structured"

Store the response. You now have structured metadata for each paper.

Step 3: Generate Concise Summaries with Resoomer

Resoomer specialises in creating condensed summaries. Its API takes the full text and produces bullet-point summaries at varying compression levels. For a literature review, you want summaries at about 30% of original length.

Resoomer API endpoint:

Copy
POST https://api.resoomer.com/v1/summarise
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json

Body:
{
  "text": "Full paper text from step 1",
  "compression_level": 0.3,
  "output_format": "bullets"
}

Response:
{
  "summary": "• Finding 1\n• Finding 2\n• Methodology detail\n• Limitation 1",
  "compression_ratio": 0.31,
  "original_length": 5200,
  "summary_length": 1612
}

In Make:

Copy
Method: POST
URL: https://api.resoomer.com/v1/summarise
Headers:
  Authorization: Bearer {{YOUR_API_KEY}}
  Content-Type: application/json
Body:
  text: {{step1.text}}
  compression_level: 0.3
  output_format: "bullets"

Step 4: Aggregate and Format the Synthesis

This is where orchestration tools shine. You have extracted text, structured analysis, and condensed summaries for each paper. Now you combine them into a single document.

In Make, use an Array Aggregator module to collect results from all papers processed in a loop, then a Create Text File or Send Email module to deliver the final synthesis.

Here is a template for how the aggregated output should be structured (using a text composition module in Make):

Copy
Literature Review Synthesis
Generated: {{now}}
Papers Analysed: {{array.length}}

{{#each papers}}

## Paper {{@index + 1}}: {{this.title}}

**Authors/Source:** {{this.url}}

**Thesis:**
{{this.thesis}}

**Methodology:**
{{this.methodology}}

**Key Findings:**
{{#each this.key_findings}}
- {{this}}
{{/each}}

**Summary:**
{{this.summary}}

**Limitations:**
{{this.limitations}}

**Concepts Covered:** {{this.concepts.join(', ')}}

{{/each}}

## Cross-Paper Themes

{{#each identified_themes}}
- {{this.theme}}: Papers {{this.paper_ids.join(', ')}}
{{/each}}

To identify cross-paper themes automatically, you can add one final step using Claude's API (or another LLM). Send all the extracted concepts to Claude with a prompt asking it to identify recurring themes.

Full n8n Example (Self-Hosted Alternative)

If you prefer n8n for better cost control and transparency, here is a simplified workflow configuration:

Copy{
  "nodes": [
    {
      "name": "Trigger - Folder of PDFs",
      "type": "n8n-nodes-base.trigger",
      "position": [250, 300],
      "typeVersion": 1,
      "parameters": {
        "triggerOn": "folder_new_file"
      }
    },
    {
      "name": "Extract with ChatWithPDF",
      "type": "n8n-nodes-base.httpRequest",
      "position": [450, 300],
      "typeVersion": 4,
      "parameters": {
        "method": "POST",
        "url": "https://api.copilotus.app/v1/pdf/extract",
        "headerParameters": {
          "parameters": [
            {
              "name": "Authorization",
              "value": "Bearer {{ $env.CHATPDF_API_KEY }}"
            }
          ]
        },
        "bodyParameters": {
          "parameters": [
            {
              "name": "pdf_url",
              "value": "{{ $node['Trigger'].data.url }}"
            }
          ]
        }
      }
    },
    {
      "name": "Analyse with ExplainPaper",
      "type": "n8n-nodes-base.httpRequest",
      "position": [650, 300],
      "typeVersion": 4,
      "parameters": {
        "method": "POST",
        "url": "https://api.explainpaper.com/v1/analyse",
        "bodyParameters": {
          "parameters": [
            {
              "name": "text",
              "value": "{{ $node['Extract with ChatWithPDF'].json.text }}"
            }
          ]
        }
      }
    },
    {
      "name": "Summarise with Resoomer",
      "type": "n8n-nodes-base.httpRequest",
      "position": [850, 300],
      "typeVersion": 4,
      "parameters": {
        "method": "POST",
        "url": "https://api.resoomer.com/v1/summarise",
        "bodyParameters": {
          "parameters": [
            {
              "name": "text",
              "value": "{{ $node['Extract with ChatWithPDF'].json.text }}"
            },
            {
              "name": "compression_level",
              "value": 0.3
            }
          ]
        }
      }
    },
    {
      "name": "Aggregate Results",
      "type": "n8n-nodes-base.merge",
      "position": [1050, 300]
    },
    {
      "name": "Save to Google [Docs](/tools/docs)",
      "type": "n8n-nodes-base.googleDocs",
      "position": [1250, 300]
    }
  ]
}

This configuration processes each PDF in a folder, extracts and analyses it, aggregates all results, then writes them to a Google Doc.

Using Claude Code for Full Customisation

If you want maximum flexibility, you can write a Python script using Claude Code (or run it locally) that orchestrates all API calls:

Copyimport requests
import json
from datetime import datetime

class LiteratureReviewSynthesiser:
    def __init__(self, copilot_key, explain_key, resoomer_key):
        self.copilot_key = copilot_key
        self.explain_key = explain_key
        self.resoomer_key = resoomer_key
        self.papers = []

    def extract_pdf(self, pdf_url):
        headers = {
            "Authorization": f"Bearer {self.copilot_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "pdf_url": pdf_url,
            "extract_type": "full_text"
        }
        response = requests.post(
            "https://api.copilotus.app/v1/pdf/extract",
            headers=headers,
            json=payload
        )
        return response.json()

    def analyse_paper(self, text):
        headers = {
            "Authorization": f"Bearer {self.explain_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "text": text,
            "analysis_type": "structured"
        }
        response = requests.post(
            "https://api.explainpaper.com/v1/analyse",
            headers=headers,
            json=payload
        )
        return response.json()

    def summarise_paper(self, text):
        headers = {
            "Authorization": f"Bearer {self.resoomer_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "text": text,
            "compression_level": 0.3,
            "output_format": "bullets"
        }
        response = requests.post(
            "https://api.resoomer.com/v1/summarise",
            headers=headers,
            json=payload
        )
        return response.json()

    def process_papers(self, pdf_urls):
        for url in pdf_urls:
            print(f"Processing: {url}")
            extracted = self.extract_pdf(url)
            analysis = self.analyse_paper(extracted["text"])
            summary = self.summarise_paper(extracted["text"])

            paper = {
                "url": url,
                "title": extracted.get("title", "Unknown"),
                "text": extracted["text"],
                "thesis": analysis.get("thesis"),
                "methodology": analysis.get("methodology"),
                "key_findings": analysis.get("key_findings", []),
                "concepts": analysis.get("concepts", []),
                "summary": summary.get("summary"),
                "limitations": analysis.get("limitations")
            }
            self.papers.append(paper)

        return self.papers

    def generate_synthesis(self):
        output = f"# Literature Review Synthesis\nGenerated: {datetime.now().isoformat()}\n"
        output += f"Papers Analysed: {len(self.papers)}\n\n"

        for i, paper in enumerate(self.papers, 1):
            output += f"

## Paper {i}: {paper['title']}\n\n"
            output += f"**Source:** {paper['url']}\n\n"
            output += f"**Thesis:** {paper['thesis']}\n\n"
            output += f"**Methodology:** {paper['methodology']}\n\n"
            output += "**Key Findings:**\n"
            for finding in paper['key_findings']:
                output += f"- {finding}\n"
            output += f"\n**Summary:**\n{paper['summary']}\n\n"
            output += f"**Limitations:** {paper['limitations']}\n\n"
            output += f"**Concepts:** {', '.join(paper['concepts'])}\n\n"

        return output

synthesiser = LiteratureReviewSynthesiser(
    copilot_key="your_key",
    explain_key="your_key",
    resoomer_key="your_key"
)
papers = synthesiser.process_papers([
    "https://example.com/paper1.pdf",
    "https://example.com/paper2.pdf",
    "https://example.com/paper3.pdf"
])
synthesis = synthesiser.generate_synthesis()
print(synthesis)

This script processes multiple papers sequentially, then outputs a formatted synthesis document you can save or print.

The Manual Alternative

If you prefer not to automate this workflow, you can still use these three tools together efficiently. Open each paper in ChatWithPDF, copy the extracted text into ExplainPaper, read the structured analysis, then paste the text into Resoomer for a summary. Repeat for each paper, then manually compile findings into a document.

This takes roughly 15 to 20 minutes per paper, depending on length and complexity. For a 20-paper review, expect 5 to 6 hours of manual work. The automated approach reduces that to perhaps 30 minutes of setup time plus 30 minutes of review and quality checking.

The manual approach gives you more control over which sections to emphasise and how to interpret results. It is reasonable if you are reviewing fewer than 10 papers or if you need to make detailed judgement calls on each paper's relevance.

Pro Tips

1. Rate Limits and Batching

ChatWithPDF, ExplainPaper, and Resoomer all enforce rate limits. ChatWithPDF typically allows 100 requests per hour on free plans, ExplainPaper allows 50 per hour, and Resoomer allows 30 per hour. If you are processing more than 25 papers, upgrade to paid plans or space out your workflow over several hours. In Make or n8n, add delay modules between API calls (2 to 5 second delays are usually safe).

2. Error Handling

PDFs sometimes fail to extract cleanly, especially if they contain scanned images instead of digital text. Add error handlers to your workflow that skip malformed PDFs and log them separately. In Make, use a "Route" module to catch HTTP errors and send a notification instead of failing the entire workflow.

3. De-Duplication

If you are pulling from multiple databases (arXiv, Google Scholar, institutional repositories), you may accidentally process the same paper twice. Store paper titles and DOIs in a database lookup, and check new papers against it before processing.

4. Cost Optimisation

If you have 100+ papers to process, consider downloading the PDFs locally and using n8n self-hosted rather than Make or Zapier. Hosting n8n costs roughly £5 to £10 per month on a basic cloud instance, whilst making 1000 API calls on Zapier can cost £50 to £100. For regular researchers, the self-hosted model pays for itself within weeks.

5. Quality Control

Automated synthesis is fast but not perfect. Always review the generated synthesis document and manually verify key claims against the original papers. The tools often miss nuance in highly theoretical work. Use the automated output as a first draft, not a final deliverable....

Cost Breakdown

For a single literature review of 20 to 30 papers, the Make approach costs roughly £35 to £45 total. For ongoing research work processing papers monthly, investing in n8n self-hosting or Claude Code pays dividends quickly.