Organizations across industries face the same bottleneck: structured data exists in their systems, but converting that data into properly formatted documents for customers, partners, and stakeholders requires manual work. Teams copy-paste data between systems, format documents inconsistently, and spend hours on tasks that should take minutes.
In this example, we’re generating insurance claims documents by simulating data gathered from various systems of record. The workflow is orchestrated using n8n, using the Box MCP server to interface with Box DocGen features. This demonstrates how disparate data sources can be unified into consistent, professional documents without manual intervention — turning what’s typically a time-intensive process into an automated pipeline that scales with demand.
Components Used
- Source: JSON data representing claims from core systems
- Template: Word document with
{{ }}placeholders for dynamic content - Orchestration: n8n workflow that reads JSON and triggers document generation
- Output: Individual PDF claims documents, properly formatted and ready for distribution
- Box DocGen: Handles template processing and PDF generation
- n8n: Orchestrates the workflow and data transformation
- Box MCP Server: Provides the API bridge for DocGen operations
DocGen template
The template was created using a Word document with {{ }} placeholders for dynamic content, and it looks like this:
n8n Workflow
The workflow is fairly simple, it reads data from a JSON, simulating multiple data sources from existing systems of record.
In production environments, this same workflow pattern can consume data from REST APIs connected to core business systems, database queries from policy management platforms, webhook data from third-party integrations, or manual uploads for handling exceptions.
This flexibility means you can start with simple file-based processing and gradually connect to live systems as your automation matures, all while using the same document templates and generation logic.
Generating the claims
In our simulation we have data for 10 Claims, and although DocGen can process all 10 of them in one call, I’ve decided to split those into each individual claim. Imagine you need to insert some individual post processing once you gathered the data.
The DocGen Merge input looks like this:
[
{
"generated_file_name": "CLAIM-G8947892834455-John Doe",
"user_input": {
"claim_number": "G8947892834455",
"date_reported": "July 28, 2024",
"policy_number": "1234567",
"loss_type": "Vehicle Collision",
"status": "Under Investigation",
...
}
},
{
...
}
]
And the end result is a properly filled and formatted insurance claim:
Beyond the Demo: What This Enables
The real power of this approach becomes apparent when you consider the broader applications across business operations.
CRM systems can automatically generate policy documents the moment deals close, eliminating the delay between sale and delivery. Claims processing workflows can produce investigation reports as cases progress, keeping all stakeholders informed without manual intervention. Regulatory reporting transforms from a monthly scramble into scheduled, automatic generation of compliance documents that are always ready when auditors come calling.
Customer communications particularly benefit from this automation. Personalized letters acknowledging policy changes, detailed statements explaining coverage adjustments, or renewal notices with updated terms can all be generated based on triggers from your existing systems. What once required dedicated staff to format and review individual communications now happens automatically, ensuring customers receive timely, accurate information while freeing your team to focus on more complex customer service challenges.
Making It Real
This demo shows something important: the gap between having data and having useful documents doesn’t require complex custom development or expensive enterprise solutions. With tools like Box DocGen, n8n, and the Box MCP server, you can build document automation that actually works — without a team of developers or months of integration work.
The insurance claims example is just the beginning. Every organization has data trapped in systems and people spending time on formatting tasks that could be automated. Whether you’re generating contracts, compliance reports, customer statements, or internal documentation, the same principles apply: create templates, connect your data, orchestrate the workflow, and let the system handle the repetitive work.
Start with one document type that’s currently eating up your team’s time. Build a simple workflow. See how it changes the way work gets done. Then expand from there.
The tools exist. The APIs are available. The question isn’t whether you can build this — it’s whether you’re ready to change how document generation works in your organization.
This workflow is available on out n8n workflow collection hosted on our community GitHub repo.
