Documentero

Webflow forms capture visitor data, but turning that data into a finished document still happens by hand. Someone copies each submission into a Word file, formats it, exports a PDF, and emails it back. At volume, manually producing contracts and certificates becomes a bottleneck; invoice workflows have the same problem. Documentero removes that manual step.

Connecting Documentero with Webflow turns site activity into generated documents. A visitor submits a form and receives a .docx or .pdf built from a template. It arrives as a download link or an email attachment. The same connection supports document-generating forms embedded on any page, automated workflows that fire on every submission, and AI agents that generate documents on request.

This integration fits teams that deliver documents as part of their site experience. Agencies generate branded proposals from intake forms, and course creators issue completion certificates. HR teams send offer letters, and property managers produce ready-to-sign lease agreements. No-code builders can run the whole flow with the marketplace app, while developers can extend it through the API.

How to integrate Documentero with Webflow

What is Documentero? Documentero is a cloud-based document generation platform that creates Word, Excel, and PDF files from customizable templates. Templates use {fieldName} curly-bracket placeholders. Web forms and spreadsheets can fill the placeholders, and API calls can supply the same data. It connects through shareable forms, a REST API, and its own MCP server. Automation connectors support Zapier, Make, and n8n.

Teams pair the two tools when a Webflow site needs to produce documents from collected data. A lease request form can return a ready-to-sign agreement, and a checkout form can email a PDF invoice. Every pattern starts from a template stored in Documentero with curly-bracket placeholders.

The Webflow and Documentero integration supports five approaches:

• MCP servers let an AI agent read your Webflow forms and generate documents from your Documentero templates in the same conversation.
• The Documentero marketplace app embeds document-generating shared forms on your pages without code.
• Shared form links and iframe embeds let you place Documentero forms anywhere with a public URL or an HTML snippet.
• Zapier, Make, and n8n connect Webflow form submissions to Documentero document generation without code.
• The Webflow Data API and Documentero API give you full control over document generation and delivery, including writing results back to your Collections, but require server-side development.

One constraint shapes the choice between them. A Code Embed element runs only HTML, CSS, and JavaScript in the visitor's browser, so it can display a Documentero form but it cannot call the Documentero API, which would mean shipping your API key to every visitor. Anything that turns a native Webflow form submission into a document needs a server in the middle, whether that server is Zapier, Make, n8n, or code you host yourself.

Generate documents from AI agents with MCP

Both sides of this integration now ship an MCP server, which makes an agent the fastest way to go from a Webflow form submission to a finished document without building anything. Documentero publishes an official Documentero MCP server distributed as the @documentero/mcp npm package, and the Webflow MCP server covers the site side, including reading forms and their schemas and listing submissions.

To connect Documentero to an MCP client, copy your API key from Documentero Account settings and add the server to your client configuration:

{
  "mcpServers": {
    "documentero": {
      "command": "npx",
      "args": ["-y", "@documentero/mcp"],
      "env": {
        "DOCUMENTERO_API_KEY": "your-api-key"
      }
    }
  }
}

Once the client reloads, the agent can list your templates, read a template's field schema, and generate a document from data you supply. Running the Webflow server alongside it lets the same agent pull a recent form submission and shape the document data from it. Webflow's server works inside your existing permissions and roles, records what the agent did in the site activity log, and accepts per-site Agent Instructions, so this path stays governable rather than being a key handed to a black box.

One boundary matters here. Neither MCP server runs on your published site, so an agent workflow serves your team rather than your visitors. For visitor-facing document generation, use one of the four methods below.

Install the Documentero app

For the fastest no-code setup, install the Documentero app from the Webflow marketplace. It turns an uploaded template into a form that generates .docx, .xlsx, or .pdf files straight from your pages. Documentero publishes the app itself, under the Documentero App workspace, with support handled at its own domain. You need a Documentero account and at least one uploaded template before you start.

To set up the integration:

1. Create a template in Documentero, then click the Share Form icon on it to generate a shared form.
2. Copy the shared form's public link.
3. Install the app from the marketplace listing, paste the link into the app, and click Apply.

Once connected, the embedded form generates .docx, .xlsx, or .pdf documents from visitor input on your pages, collects data through customizable field types including text fields, date pickers, select boxes, radio buttons, and checkboxes with conditional visibility, and delivers the finished document as a download link or an email attachment. The form UI comes from Documentero rather than Webflow's form elements, so if you want more control over placement and styling, the embed method below gives you customization parameters.

Add Documentero shared forms with Code Embed elements

Every Documentero template can become a shared form with a public URL, and that URL works in Webflow two ways. You can hyperlink to it from any button, or render the form on your page inside a Code Embed element. Code Embed needs a Core, Growth, Agency, or Freelancer Workspace, or an active Site plan. The link method works on any plan.

Link to a shared form

A shared link requires no code. Visitors click through to Documentero's hosted form, fill it out, and receive their document there.

To create and place the link:

1. Find your template in Documentero and click the Share Icon in the Action list.
2. Provide a form name and default language, then click Create & Configure to generate the public URL.
3. Set that URL as the link destination on any Webflow button or text link.

Visitors complete the form on Documentero's domain with this method, so use the iframe embed when you want them to stay on your page.

Embed the form with an iframe

The iframe keeps the form on your own page and accepts styling parameters, so it can match your site's design. Documentero's embed documentation provides the snippet.

To embed the form:

1. In Documentero, open the shared form configuration and copy the HTML iframe snippet.
2. In Webflow, drag a Code Embed element onto the page and paste the snippet:

<iframe src="https://app.documentero.com/form/53CW0Hn9mZm8Ufui6fbP"
        frameborder="0" height="600px" width="100%"></iframe>

You can adjust the form's appearance by appending URL fragment parameters to the iframe source:

• dark: turns dark mode on for input fields, and defaults to false.
• wrapper: shows or hides the wrapper, border, and extra padding, and defaults to true.
• header: shows or hides the header carrying the logo and form title, and defaults to true.
• background: sets the form background to default, transparent, or a color value.
• corners: controls corner rounding in pixels, with 0 disabling rounded corners.
• color: overrides the default blue on buttons, interface elements, and headers.

Each Code Embed element holds up to 50,000 characters, so the iframe snippet fits with plenty of room for surrounding markup.

Connect with Zapier, Make, or n8n

Use an automation platform when you want Webflow's native form elements instead of Documentero's hosted form UI. Zapier hosts an official Documentero app. Make's connector is vendor-maintained, and n8n's is partner-built and n8n-verified. All three also carry a Webflow form-submission trigger. The pattern is the same everywhere. Pick the Webflow trigger, add a Documentero action, authenticate with the API key from your Documentero Account settings, and map submitted fields to template placeholders.

On Zapier, the Webflow "New Form Submission" trigger feeds Documentero's "Generate Document" or "Generate Document and Send as Email Attachment" action, and a pre-built Zap template wires the whole flow for you. On Make, the Webflow "Watch events" trigger watching the form_submission event feeds the Documentero modules, which include "Generate Document", "Generate Document and Send as Email Attachment", and "Make an API Call". On n8n, the Webflow Trigger "Form Submission" event feeds the Documentero node and its "Generate Document" or "Generate and Email Document" operation, and you install that node under Settings > Community Nodes using the name n8n-nodes-documentero.

Two setup notes apply. Zapier needs at least one submission already received through your Webflow form before it can connect the form to a Zap. Documentero also notes that some automation actions cap execution at around 30 seconds, and recommends .docx output over .pdf plus fast-loading public image URLs to keep generation inside that window.

Build with the Webflow and Documentero APIs

The API path gives developers full control over document triggers and the workflow from template data mapping through delivery, and it requires server-side development. Documentero's usage limits documentation is explicit that the API "is designed strictly for server-to-server use and must not be accessed directly from client-side environments such as websites, browsers, or mobile applications." A serverless function or backend service therefore sits between Webflow and Documentero and holds the API key.

Available APIs:

• Documentero Cloud API: handles document generation and email delivery through a single POST endpoint.
• Webflow Data API: reads and writes Webflow CMS items using bearer token authentication.
• Webflow form submissions: you can list form submissions on demand when a polling job suits you better than a webhook.
• Webflow webhooks: push real-time events to your endpoint the moment they happen.

Documentero accepts its key either in an Authorization: apiKey [yourApiKey] header or as an apiKey field in the JSON body. The template identifier and a pre-filled JSON example for that specific template are both available from the cloud icon in Documentero, which saves you guessing at field names.

Generate documents from form submission webhooks

This sub-method fires document generation the moment a visitor submits a Webflow form, with no automation platform in the middle.

To implement it:

1. Register a webhook with the Create Webhook endpoint, POST https://api.webflow.com/v2/sites/{site_id}/webhooks, using the form_submission trigger type and the sites:write scope. This trigger supports a filter parameter to target a specific form by name.
2. In your receiving endpoint, read submitted values from payload.data and validate the x-webflow-timestamp and x-webflow-signature headers before trusting the request.
3. Call Documentero's Cloud API endpoint with the template identifier and the mapped data. The keys inside data have to match the curly-bracket placeholders in your template:

   POST https://app.documentero.com/api
   Content-Type: application/json
   Authorization: apiKey [yourApiKey]
   
   {
     "document": "[documentIdentifier]",
     "format": "pdf",
     "email": "[recipient@example.com]",
     "data": {
       "clientName": "[value from payload.data]",
       "agreementDate": "[value from payload.data]"
     }
   }
   

4. Read the download link from the response data field. It expires after 10 minutes. To skip hosting the download yourself, add an email field with up to 5 comma-separated recipient addresses.

Check the message field on every response rather than reading the status code alone, because Documentero returns generation errors, such as an unrecognized template identifier, as human-readable text in message.

Write generated documents back to the CMS

Documentero returns the file link synchronously and emits no outbound webhooks, so your service handles any CMS write-back after the response arrives. Since the download link dies in 10 minutes, store the file somewhere permanent before saving anything to Webflow.

To implement the write-back:

1. Download the file from the expirable link, then upload it to your own storage service to get a stable URL.
2. Create or update a CMS item with POST /v2/collections/{collection_id}/items or PATCH /v2/collections/{collection_id}/items/{item_id}, using the cms:write scope and putting the stable URL in fieldData.
3. Publish the staged item with POST /v2/collections/{collection_id}/items/publish.

A Collection List can then display those items on any page. The same pattern also runs in reverse. Register collection_item_created or collection_item_changed webhooks and map payload.fieldData to template placeholders to generate a document whenever CMS content changes.

What Documentero does with the data

Documents generated from a Webflow form frequently carry personal data, so it is worth knowing what the vendor says it keeps. Documentero's privacy policy summary states that its service "is intentionally designed to refrain from storing documents customer data or generated documents", and its account documentation says personal data, activity, and templates are permanently removed within up to 30 days of an account deletion. Webflow, separately, keeps the raw submission under Site settings until you delete it.

Whether that arrangement satisfies your own obligations depends on what your forms collect and where your visitors are, and neither we nor Documentero can answer that for you. Read the vendor's current policy, check it against the data your specific form gathers, and take the question to your own counsel before you route regulated data through any third party. The practical control on your side is narrow: send Documentero only the fields the template actually renders, rather than the whole submission.

What you can build with the Documentero Webflow integration

Integrating Documentero with Webflow lets you deliver finished contracts, certificates, invoices, and proposals from site activity without manually assembling a single document.

• Proposal generation from client intake: An agency intake form feeds a Documentero sales proposal template, and the prospect receives a branded PDF by email shortly after submitting.
• Automated course certificates: A course completion form triggers a personalized PDF certificate carrying the student's name and completion date, generated from a certificate template.
• Self-service lease agreements: A property site's lease request form produces a ready-to-sign commercial rent agreement in .docx, with Smart Sections including only the clauses that apply to that request.
• Invoice delivery for orders: An order form generates a PDF invoice from the submitted details and emails it to the buyer, with the file routed onward to Dropbox or Google Drive for records.

Want the same output without a third-party generator in the path? Follow our guide to build a document builder on Webflow Cloud, and compare the two before you commit.

One gap is worth naming before you plan around it: Documentero generates documents but does not sign them, and its own FAQ says there is no built-in e-signature. If the contract or lease has to come back executed, hand the generated file to a dedicated service such as DocuSign as the next step in the same automation. For everything else, connecting both MCP servers to your agent is the shortest way to test whether a template and a form actually produce the document you want.