How to generate PDFs from a no-code tool (Zapier, Make, n8n)

One HTTP request, three no-code tools

Zapier, Make, and n8n all solve PDF generation the same way under the hood: an HTTP/webhook action that sends a JSON body to an API and gets a file back. The trigger (a new Airtable row, a Google Sheets update, a form submission) is different in every automation, but the PDF step itself is identical across tools. Learn the request once and you can drop it into any of the three — or any future automation platform — without re-learning anything.

That request is a single POST to https://docweave.dev/api/v1/pdf with an Authorization: Bearer dw_live_your_key header, a JSON body describing what to render, and (when you want the raw file rather than a JSON wrapper) an Accept: application/pdf header. The rest of this post is that one request, then the three or four clicks each tool needs to fire it.

The request body

Docweave accepts three kinds of source: raw html, a url to render, or a stored templateId plus a data object for merge fields. For automations, HTML built from your trigger's fields is usually the fastest path to get running, and a saved template (see generate-pdf for the full source reference) is the better long-term choice once the layout stabilizes:

{
  "source": {
    "type": "html",
    "html": "<h1>Invoice #{{invoice_number}}</h1><p>Total: {{total}}</p>"
  },
  "filename": "invoice-{{invoice_number}}.pdf",
  "idempotencyKey": "{{trigger_id}}"
}

Swap the {{...}} placeholders for whatever field-mapping syntax your tool uses (Zapier's field pills, Make's mapping panel, n8n's expression editor) — the JSON shape sent to Docweave doesn't change.

Setting up in Zapier

Add a **Webhooks by Zapier** action, choose **POST**, set the URL to https://docweave.dev/api/v1/pdf, and add the Authorization and Accept headers above. The catch: Zapier's built-in webhook action returns text/JSON by default, so pulling a binary PDF back out of it and into, say, Google Drive or an email attachment takes an extra step or a small Code by Zapier block. generate-pdf-from-zapier walks through that binary-handling detail end to end.

Setting up in Make

Make's HTTP module ("Make a request") is the most straightforward of the three for this: add the same headers and JSON body, and toggle the module to parse the response as a file rather than text. That file output then plugs directly into Make's Google Drive, Dropbox, or Email modules with no conversion step. generate-pdf-from-make has the module-by-module screenshots.

Setting up in n8n

In n8n, use the **HTTP Request** node, set the method to POST, add the two headers, paste the JSON body (or build it with the node's expression editor), and — this is the part people miss — set **Response Format** to **File** under Options. Without that, n8n will try to parse the PDF bytes as JSON and choke. generate-pdf-from-n8n covers the node configuration in detail.

Test the request with curl first

Before wiring anything into a no-code canvas, it's worth confirming the request works with a plain curl call. It isolates "is my JSON body right" from "is my no-code tool configured right" — two different failure modes that are much slower to debug when tangled together inside a visual editor:

curl https://docweave.dev/api/v1/pdf \
  -H "Authorization: Bearer dw_live_your_key" \
  -H "Accept: application/pdf" \
  -H "Content-Type: application/json" \
  -d '{"source":{"type":"html","html":"<h1>Test invoice</h1>"}}' \
  --output test.pdf

If test.pdf opens as a real PDF, your body shape is correct and any remaining issue is in how the no-code tool handles the binary response.

Don't let a retried trigger double-bill you

No-code platforms retry steps on timeouts and rate limits, which means the same trigger can fire the same HTTP action twice. Docweave de-duplicates renders when you pass a stable idempotencyKey — the trigger's own record ID is usually the right value, since it's unique per event and identical across retries of that event. See docs for how the key is scoped and how long it's honored.

Picking a source type for automation

Inline HTML (as above) is the quickest way to get a working Zap, Make scenario, or n8n workflow, because you can build and tweak the markup right in the JSON body. Once the layout is settled — a recurring invoice, a certificate, a report — move the HTML into a saved Docweave template and send only a templateId plus a data object from the automation. That keeps the no-code workflow simple (map fields, don't maintain markup) and lets you edit the visual design without touching the Zap/scenario/workflow at all. use-cases/invoices shows what that looks like for a typical billing automation.

The no-code tool's only job is to map your trigger's fields into the JSON body and hand the response to wherever the file needs to go next — everything about the PDF itself lives in the request, not the automation.