SnapPDFSnapPDF
integration · automation · live

SnapPDF + Make

Visual scenarios with branching, error routes, and every SnapPDF endpoint as a module.

Make (formerly Integromat) is the canonical pick for scenarios that need branching, iterators, and error handlers. The SnapPDF Make app exposes all 15 PDF operations as first-class modules, plus an Async/Webhook pair for jobs longer than 45 seconds. Scenarios can fan-in/fan-out, which is ideal for bulk certificate generation or multi-file merge flows.

What you can build

  • Every endpoint is a module with typed inputs and outputs.
  • Iterator module lets you loop over arrays (e.g. 500 certificates in one scenario run).
  • Error-handler routes catch SnapPDF 4xx/5xx and can retry, skip, or email an operator.
  • Data stores hold intermediate PDFs for multi-step pipelines without touching external storage.
  • Run history includes the full SnapPDF response JSON for each call — easier debugging than Zapier.

Setup

  1. 01
    Install the SnapPDF Make app
    From Make → Apps → search "SnapPDF" → Connect. Alternatively, visit make.com/en/hq/apps/snappdf.
  2. 02
    Add a connection
    Paste a live or test key; Make stores it encrypted. One account can hold multiple connections (prod + staging).
  3. 03
    Drop in a module
    In the scenario editor, click the + button and pick a SnapPDF operation. Each operation is a separate module, so there is no enum-field misery.
  4. 04
    Map inputs
    Use Make's dot-mapping to pull fields from earlier modules. File inputs accept base64, URL, or Make-internal file references.
  5. 05
    Add an iterator if you need a loop
    Make's `Flow Control → Iterator` turns an array into sequential executions. Follow with an Aggregator to collect the SnapPDF outputs back into one bundle.
  6. 06
    Set up error handling
    Right-click any SnapPDF module → Add error handler. Route `pdf.encrypted` to a human-review notifier; auto-retry network errors.
  7. 07
    Schedule and run
    Schedule options: instant (webhook-triggered), every X minutes, cron, or one-off. Use instant with SnapPDF webhooks for async pipelines.

Code example

Bulk certificate generation scenario: Airtable records → fill-form → metadata → Dropbox upload.

Module 1: Airtable → Search Records (view: "Graduates Pending Cert")
Module 2: Flow Control → Iterator (array: {{1.records}})
Module 3: SnapPDF → Fill Form
  file: https://cdn.acme.edu/templates/cert-v4.pdf
  values:
    student_name: "{{2.fields.full_name}}"
    course_title: "{{2.fields.program}}"
    completion_date: "{{2.fields.grad_date}}"
    credential_id: "{{2.fields.credential_id}}"
  flatten: true
Module 4: SnapPDF → Set Metadata
  file: {{3.pdf}}
  metadata:
    title: "{{2.fields.program}} Certificate"
    subject: "{{2.fields.credential_id}}"
Module 5: Dropbox → Upload File
  path: "/certs/{{2.fields.credential_id}}.pdf"
  data: {{4.pdf}}
Module 6: Airtable → Update Record
  id: {{2.id}}
  fields:
    cert_delivered: true
    cert_delivered_at: {{now}}

Known limits

  • · Iterator + SnapPDF can chew through ops fast — monitor usage in /dashboard/usage.
  • · Data Store cell limit is 5MB — compressed PDFs only.

Pricing notes

Make integration is available on every paid SnapPDF tier from Starter. Make's own pricing is separate and ops-based (1 Make op per module execution).

Available from the Starter plan.

FAQ

Do Make operations count against my SnapPDF quota?

Yes. Each module execution that calls the SnapPDF API is one billed operation. Iterator runs multiply that by the array length — budget accordingly.

Can I use the async API with Make?

Yes. Use the "Create Async Job" module, then a "Watch Webhook" module listening for the job.completed event. Make routes the webhook back into the same scenario.

What's the timeout on a single module call?

Make's internal HTTP timeout is 40 seconds. Use async for anything heavier (large OCR jobs, 500MB compress). Sync operations complete well within the window for 95% of inputs.

Does Make store my PDFs?

Only for the duration of the scenario run, in its internal data buffer. Execution history retains metadata for 3-30 days depending on your Make plan; binaries are dropped immediately unless you explicitly store them in a Data Store.

Can I version scenarios?

Make has scenario-level versioning on paid plans. We recommend exporting the scenario JSON into git for true versioning alongside your application code.

Start freeRead the quickstartOpen Make

Related integrations