How to Automate PDF Generation in Make

To automate PDF generation in Make, build a scenario that starts with a trigger, maps its data into a document template or HTML, generates the PDF with a compatible module, retrieves the file content when needed, and sends or stores the result. A practical template-based route uses the Plumsail Documents app: trigger → Start Document Generation Process → retrieve the generated file → Drive, email, or another destination. Make scenarios pass data from a trigger through actions and modules; choose the modules to suit the source, document format, and destination.

This guide walks through the setup, data mapping, file handling, alternate generation routes, and checks to make before scheduling. For the Plumsail connector’s current requirements and module list, see Plumsail Documents in Make.

1. Choose a trigger and define the output

Start with the event that should create a document. Common patterns include a new spreadsheet row, a form submission, or a record created in another connected app. In Make, the trigger supplies bundles of data to later modules. Decide what each run should create and where it should go before building the scenario.

One document per event: Generate an invoice, confirmation, report, or certificate for each incoming record.
HTML-driven output: Use this when the document content is already assembled as HTML and you need it rendered as a PDF.
Convert an existing file: Use a conversion action when the input is a DOCX, XLSX, PPTX, image, or another supported format.
Destination: Choose a storage module, email module, or another downstream app that accepts a file. Confirm whether it needs a file URL or the actual file data.

Consider the shape and reliability of the trigger data. Identify required fields, optional fields, date and number formats, and a stable identifier for naming or deduplicating output. If one event can contain multiple line items, establish whether the template should repeat a row or whether the scenario should process items individually.

2. Prepare the template or document source

For a template-based workflow, create a process in Plumsail Documents, choose a template, configure the output as PDF, and add named tokens for the values Make will provide. The Make action starts a selected document generation process using JSON data. Its tokens and the fields mapped in Make must agree.

For a straightforward token, place a placeholder such as {{customer_name}} in the document template, then map the corresponding source field to that token in the Make module. Prepare the document layout, page breaks, repeated content, and output naming convention before connecting the scenario. The exact template syntax and supported data structures depend on the selected document process and connector.

If your source content is HTML rather than a DOCX template, the Plumsail connector lists a Convert HTML to PDF action. It renders supplied HTML as a web page and converts it to PDF. For existing office files, the connector lists conversion actions including DOCX to PDF, XLSX to PDF, and PPTX to PDF, as well as a general Convert to PDF action. Check that the specific input format is supported before relying on the general converter.

3. Connect the document service in Make

Add the relevant Plumsail Documents module to your Make scenario.
Create or select a Plumsail Documents connection when prompted.
Use an active Plumsail account and API key. The connector documentation describes creating an API key in the account and entering it when making the connection.
Keep credentials in the service connection rather than placing secrets in ordinary template fields or scenario data.

Connections and authentication differ by app. For any source or destination app, grant the access that the workflow needs and confirm the connection can reach the intended account, folder, or mailbox. Make’s HTTP app is a possible fallback when a service has a suitable API but no direct Make integration; that does not guarantee every API can be used without additional authentication or request setup.

4. Build the PDF generation sequence

Add the trigger. Select the source app and event, such as a new row or submitted form.
Add the generation action. For the Plumsail template route, select Start Document Generation Process and choose the configured process.
Map each token. Match the trigger’s values to the corresponding fields expected by the process. Check field names and nesting carefully; the connector notes that deeply nested tokens may not be supported in its Make action interface.
Set output details. Configure the document output and any available name or process settings in the selected action and process.
Retrieve the generated file if necessary. The documented Plumsail walkthrough uses an HTTP Get a file module with the generated PDF URL. This is the step that turns a URL reference into file content for downstream modules that require a binary file.
Deliver or retain it. Add the storage, email, or other destination action and map the file content, file name, and destination fields it requires.

Plumsail’s Make connector also lists a Watch Finished Process webhook action for workflows that need a trigger when a process completes. Select the sequence that fits the process lifecycle documented for your setup.

5. Map fields and handle file output correctly

Generation and delivery are separate stages. A generated-file URL points to a result; a downstream module may require the file bytes rather than that URL. If a storage or email action expects file content, retrieve the file first and map the returned data and filename into the destination module.

Data or output	Check
Required template token	Map it from a trigger field that is present for every qualifying event.
Optional value	Decide whether to omit the content, use a safe default, or route incomplete records for review.
Dates and amounts	Confirm the value is formatted as the template expects; don’t assume display formatting in the source app is preserved automatically.
Generated PDF URL	Use a file retrieval step if the next module requires binary file content.
Filename	Use a stable record identifier and avoid characters that the destination rejects.
Multiple line items	Confirm the process supports the data structure and that all rows appear in the intended order.

Avoid mapping a whole nested object into a simple text token unless the process supports that shape. If the desired field is deeply nested and the connector’s interface cannot expose it, reshape or extract the data in an earlier Make module, or use a template and process configuration that accepts a supported structure.

6. Pick the route that matches your source

Need	Possible route in Make	Important check
Reusable business document with named fields	Plumsail Documents process and DOCX template	Configure the process and ensure token names match the mapped data.
Render supplied markup	Plumsail Documents Convert HTML to PDF	Supply the complete HTML content and check the rendered layout.
Convert an office file	Plumsail conversion action for supported DOCX, XLSX, or PPTX input	Choose the action matching the source format and verify its output.
Create or fill a document in Google Docs	Google Docs actions include creating a document from HTML or copying a template and replacing tags	The cited actions alone do not establish a universal export-to-PDF sequence. Verify the required export or conversion step for your specific setup.
Service without a direct Make app	Make HTTP app calling a suitable service API	Check API authentication, request format, file response handling, and service-specific limits.

The right choice depends on the source data, template versus HTML requirements, batch needs, conversion or processing requirements, destination, authentication, and retention. Make’s Google Docs app documentation covers the available Docs actions and account connection; verify any additional PDF export step in the implementation you choose.

7. Test before scheduling

Run the scenario with representative records before turning on a schedule or relying on the trigger. This is a setup checklist, not a claim that a scenario was run for this article.

Use a record with all required fields and one with optional fields missing.
Inspect the generated PDF for correct values, formatting, page breaks, and line-item order.
Verify that a retrieval step returns actual file content when the destination needs it.
Confirm the filename and destination folder, email recipient, or other routing fields.
Check how duplicate events, retries, and partially completed runs will be handled.
Review scenario history and the process run history to understand where a failed step occurred.
Only then schedule the scenario or enable its live trigger.

8. Common problems and fixes

Symptom	Likely cause	Fix
The Plumsail connection cannot be created	The account is not active, the API key is missing or incorrect, or the wrong credential was entered.	Confirm an active account, create or copy the API key from the account, then recreate or update the Make connection.
A field appears blank in the PDF	The token name and mapped field do not match, the trigger field is empty, or the value is nested in a structure the action does not expose.	Compare the template token with the process mapping, inspect the trigger bundle, and reshape nested data before generation if needed.
The scenario returns a URL but the destination rejects the result	The destination expects file content, while the generation step returned a URL.	Add the documented file retrieval step and map the retrieved data and filename to the destination.
The PDF is generated but not retained	Generation completed without a later storage or delivery action. Plumsail process run history makes generated files available for 24 hours.	Add an explicit upload or email step if the workflow needs longer retention; do not use process history as long-term storage.
Google Docs content is created but no PDF arrives	Creating or copying a Docs file is not by itself proof of a complete PDF export flow.	Verify and add the export or conversion step appropriate to your Google Docs and Drive setup.
Some runs fail while others succeed	Input records may omit a required field, contain an unexpected format, or include a value the template cannot process.	Inspect the failed bundle, validate required values before generation, and route malformed records to a review path.
Repeated files appear	The same event may have been processed more than once or retried.	Use a stable source record ID in the filename or downstream record, and define a duplicate-handling rule appropriate to the destination.

9. Reliability, performance, and cost considerations

Reliability: Treat generation, retrieval, and delivery as separate steps so scenario history can show which stage failed. Make sure retries do not unintentionally create duplicate documents or send duplicate emails. For business-critical documents, use a stable record identifier and keep a durable copy in the destination you control.

Retention: Generated files are available in Plumsail process run history for 24 hours according to the cited documentation. Add storage or delivery in the scenario when the file needs to remain available longer.

Performance: Keep templates and data structures focused, avoid unnecessary conversions, and retrieve the file only when the next module needs the content. Batch behavior and throughput depend on the chosen apps, service limits, and scenario design; the documentation reviewed here does not establish a universal speed figure.

Cost: Account for the usage or subscription terms of Make, the document-generation service, and destination apps. The sources used for this guide do not establish a neutral price comparison, so check each provider’s current plan and usage terms for your expected run volume.

Or skip the browser setup

If a workflow needs a website screenshot as an input or attachment, ScreenshotNeo returns an image or PDF from one API request. It is a website screenshot API and MCP server; it does not replace the template-driven document-generation steps above. See the ScreenshotNeo API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Cookie banners, newsletter popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. Response headers report the page verdict and billing status.
An MCP server lets AI agents using Claude, Cursor, or another MCP client take screenshots, get page information, and capture PDFs.
1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000 screenshots. Every feature is available on every plan.

FAQ

Can Make generate one PDF for each new spreadsheet row?

Yes. Use a row-created trigger, map that row into the document process, then retrieve and route the resulting file. Ensure the trigger provides all required values.

Does the generated-file URL count as the PDF attachment?

Not necessarily. A URL and file content are different outputs. Add a file retrieval module when the destination expects the binary content.

Can I use Google Docs for the template?

Make documents Google Docs actions for creating documents from HTML or copying a template and replacing tags. Confirm the export-to-PDF step required for your particular scenario.

How long does Plumsail keep a generated file in process history?

The documented retention is 24 hours. Add a storage or delivery action for longer retention.