Make.com Document Automation: Generate PDFs from Any Scenario

How Make.com + document automation actually works

Make.com (rebranded from Integromat in February 2022) is the strongest visual scenario builder on the market. 2,000+ apps, real branching, real iteration, and pricing that scales on operations rather than per-Zap headcount. What it doesn't do, natively, is generate documents. There's no built-in PDF module, no template engine, no merge fields. The visual builder ends at "move this JSON somewhere."

To generate a PDF in Make.com, add an HTTP module that calls an external document API — GJSDocs is built for this — and the API returns a finished PDF URL you pass to a delivery module. The full pattern is five modules: trigger → data prep → HTTP call to the document API → parse the response → delivery (Drive, email, Slack, e-sign). That's the whole loop, and it runs in under 8 seconds end-to-end for a typical invoice.

The pattern is the same whether you're generating 10 documents a month or 10,000 — only the trigger module changes.

Build your first PDF scenario in Make.com (step-by-step)

Concrete example: generate a branded invoice every time a new "Ready to invoice" row appears in Airtable, then upload the PDF to a Google Drive folder. Five modules, about 12 minutes of setup, around 4 operations per run.

Step 1 — Trigger: Airtable > Watch Records

Add an Airtable > Watch Records module. Connect your Airtable account, pick the base and table, and set the trigger field to your Status column with a filter for "Ready to invoice". Set max records per run to 10 — high enough to catch a busy hour, low enough to bail out fast if a bug starts firing.

[Screenshot: Airtable Watch Records module with the trigger field highlighted and "Ready to invoice" entered in the filter.]

Step 2 — Data prep: Set Variable

Add a Tools > Set Multiple Variables module. This is where you translate Airtable's field names into the variable names your GJSDocs template expects. Skipping this and mapping fields directly into the HTTP body works once and breaks the moment someone renames an Airtable column.

client_name ← {{1.fields.`Client Name`}}

client_email ← {{1.fields.`Contact Email`}}

invoice_number ← {{1.fields.`Invoice #`}}

invoice_amount ← {{1.fields.`Amount Due`}}

invoice_due_date ← {{formatDate(1.fields.`Due Date`; "DD MMM YYYY")}}

line_items_json ← {{1.fields.`Line Items`}}

[Screenshot: Set Multiple Variables panel with all six variables filled in.]

Step 3 — HTTP: POST to GJSDocs API

Add an HTTP > Make a request module. URL: https://gjsdocs.com/api/documents/generate. Method: POST. Body type: Raw, content type: JSON (application/json).

// Headers

Authorization: Bearer {{connections.gjsdocs.apiKey}}

Content-Type: application/json

// Body

{

"template_id": "tpl_invoice_v3",

"format": "pdf",

"variables": {

"client": {

"name": "{{2.client_name}}",

"email": "{{2.client_email}}"

"invoice": {

"number": "{{2.invoice_number}}",

"amount": {{2.invoice_amount}},

"due_date": "{{2.invoice_due_date}}",

"line_items": {{2.line_items_json}}

}

Tick Parse response at the bottom of the module so Make.com handles the JSON for you instead of returning a raw string. Set the API key once in Connections and reference it — never paste it into the headers field directly.

[Screenshot: HTTP module with URL, headers, and JSON body filled in, Parse response checked.]

Step 4 — Parse: extract the PDF URL

GJSDocs returns a JSON payload that looks like this:

{

"id": "doc_8K2pXr",

"status": "ready",

"pdf_url": "https://gjsdocs.com/files/doc_8K2pXr.pdf",

"expires_at": "2026-05-30T12:00:00Z"

}

If you ticked Parse response in step 3, you can reference {{3.pdf_url}} directly in the next module. If not, drop a Tools > Parse JSON module here, paste the example payload above into the data structure builder, and point it at the HTTP response body.

Step 5 — Delivery: Google Drive > Upload a File

Add a Google Drive > Upload a File module. For Source file pick URL and paste {{3.pdf_url}}. Set the destination folder, name the file Invoice-{{2.invoice_number}}.pdf, and run the scenario once with a single test record to confirm the file lands.

[Screenshot: Completed five-module scenario in the Make.com canvas with arrows connecting Airtable → Set Variables → HTTP → Parse → Drive.]

Total: roughly 4 operations per invoice (1 trigger, 1 variable set, 1 HTTP, 1 Drive upload — Parse JSON is free if you used the inline Parse response checkbox). At Make.com's $10.59/mo Core plan with 10,000 ops, that's about 2,500 invoices a month before you hit the next pricing tier.

5 ready-to-clone Make.com scenarios for documents

Same pattern, different triggers and delivery modules. Each of these is in production at real teams — copy the shape and swap the template ID.

1. Stripe payment received → Branded invoice PDF → Email to customer

Trigger: Stripe > Watch Events (charge.succeeded). Modules: Set Variables → HTTP (GJSDocs invoice template) → Email module with PDF URL as attachment via URL. Sends a branded PDF receipt within 30 seconds of payment — replaces Stripe's default ugly emailed receipt. ~5 operations per payment.

2. HubSpot deal stage = "Closed Won" → Contract PDF → DocuSign

Trigger: HubSpot > Watch Deals filtered on stage. Modules: Router (route by deal type to the right contract template) → HTTP (GJSDocs) → DocuSign > Send Envelope with the PDF and the contact's email. Contract is in the buyer's inbox while the rep is still on the closing call. ~6 operations per deal.

3. Typeform submission → Certificate PDF → Slack to channel

Trigger: Typeform > Watch Responses (course completion form). Modules: Set Variables → HTTP (GJSDocs certificate template with the student's name) → Slack > Upload a File posting the PDF to #new-graduates. Internal celebration plus an audit trail. ~4 operations.

4. Calendly booking → Meeting brief PDF → Google Drive

Trigger: Calendly > Watch Event Created. Modules: HubSpot > Get Contact (enrich with company data) → HTTP (GJSDocs meeting brief template) → Google Drive > Upload a File into a per-AE folder. AE walks into every meeting with a 1-page brief on the prospect, generated 30 minutes before the call. ~5 operations.

5. Airtable status = "Approved" → Statement of Work → Client email

Trigger: Airtable > Watch Records filtered on Status. Modules: Iterator over the scope line items → Array Aggregator → HTTP (GJSDocs SOW template) → Gmail > Send Email with PDF link in the body. Account managers stop hand-building SOWs in Google Docs. ~7 operations per SOW.

Make.com vs Zapier for document automation

Honest comparison. If you're picking between the two specifically for document workflows:

Dimension	Make.com	Zapier
Price at 1,000 docs/mo	~$10.59 (Core, 10K ops)	~$73 (Pro, 2K tasks)
Builder style	Visual canvas, branching	Linear top-to-bottom
App catalog	2,000+	7,000+
Routers and conditional logic	Native, multi-branch	Paths (Pro+ only), 1 condition deep
Error handlers / retry	Per-module, configurable	Coarse, mostly all-or-nothing
Learning curve	2-3 days	2-3 hours

Verdict: use Make.com if you're generating more than 1,000 documents a month, or any number with conditional routing — different templates per deal type, region, or product line. Use Zapier if your flow is linear (trigger → generate → send) and you value the larger app catalog or already have a Zapier seat in the building. We covered the Zapier flow end-to-end in the Zapier document automation guide if that's the shape that fits.

Common mistakes that break Make.com document scenarios

Hardcoding values instead of mapping
Pasting "Acme Corp" into a JSON body field instead of mapping the Airtable variable. Works for one record, silently wrong for every record after. Use the variable picker for every dynamic value — if you typed it, it's a bug.
Not handling the async PDF generation response
Large templates (50+ pages, embedded images) can take 5-15 seconds to render. If your HTTP module times out at the default 40 seconds and you don't check status: "ready" before passing pdf_url, you ship empty file URLs. Either bump the timeout or add a small Sleep + re-poll loop.
Forgetting to filter test records
Running a fresh scenario without a "Test = true" filter and watching it fire 1,000 invoices to "Test User" at [email protected]. Always add a filter module on the trigger output during build, and disable the scenario before clearing test data.
Storing the API key in plain text
Pasting your GJSDocs API key directly into the Authorization header field. It then leaks into every scenario export and exists in the audit log as plain text. Use Make.com Connections — the key is encrypted at rest and rotates without editing every scenario.
No error handler module
Without a right-click → Add error handler on the HTTP module, a single 429 or 500 from the document API silently kills the bundle, eats the operations, and leaves no log. Add a Break or Resume error handler that retries 3 times and posts to Slack on final failure.

FAQ

Can Make.com generate PDFs natively?

No. Make.com has no native PDF or document module. You generate PDFs by calling an external document API from an HTTP module — GJSDocs, PDFMonkey, or DocRaptor are the common picks. The API returns a PDF URL the rest of your scenario can consume.

How much does Make.com cost for document automation?

A typical 5-module document scenario uses 4-5 operations per run. On the Core plan ($10.59/mo, 10,000 ops) you get roughly 2,000-2,500 documents a month before upgrading. Add your document API cost on top — GJSDocs starts free, $19/mo for unlimited generation.

Is Make.com better than Zapier for PDFs?

For volume and conditional logic, yes. Make.com is roughly 7x cheaper per operation at 1,000+ docs/month and handles routing (different template per deal type, region, or customer tier) without paying for a Zapier Pro Paths upgrade. For simple linear flows on apps Make.com doesn't support, Zapier wins on the catalog.