Make Integration (Re:port Flow app)
You can generate PDFs from a Make scenario using the official Re:port Flow app. The app has passed Make's app review, so you can find it by searching "Re:port Flow" in the scenario editor's module picker.
This page assumes the reviewed official app (1 trigger, 8 actions).
What do I need to generate PDFs from Make?
You need a Re:port Flow workspace, at least one template, and a Make account. The template is needed for picking a design and generating PDFs, so you can also add it after connecting. No application key is required — the connection is authorized through OAuth 2.0.
- A Re:port Flow workspace (create one at re-port-flow.com)
- At least one template to render to PDF. If you don't have one yet, copy one from the Template Gallery
- A Make account
How do I connect Re:port Flow to Make?
Add a module in the Make scenario editor and search for Re:port Flow. When creating the connection, choose Add connection; on the authorization screen, log in to Re:port Flow, pick the workspace to use, and authorize.
The Re:port Flow app connects via OAuth 2.0 (Authorization Code + PKCE) only — there is no field to paste an application key directly. Authorization requests the following scopes:
| Scope | Purpose |
|---|---|
openid / profile | Identify the connecting user |
designs:read | List templates and fetch parameter structure (Design ID selection, Get design parameters) |
templates:read | Fetch template-related metadata |
pdf:generate | Generate and download PDFs |
For why third-party integrations like Make use OAuth, see OAuth 2.0 Authentication (Make.com-style external integrations are the recommended use case for OAuth 2.0 Authorization Code + PKCE).
Adding the Watch file completed trigger to a scenario makes Make create a dedicated Webhook endpoint for that scenario via the endpoint-management API (POST /workspace/:workspaceId/webhook-endpoints, among others), and delete it when the trigger is removed — the trigger's Design ID / Version settings become that endpoint's design filter. Registering or removing it requires workspace administrator (ADMIN) permission, so the Re:port Flow account used for the connection must be an administrator (see Webhook notifications).
Connecting with a non-administrator account returns a 403 (this operation requires administrator permission) as soon as you enable the trigger. Actions that only generate PDFs (Generate ... PDF (sync/async), etc.) do not require administrator permission.
Which Re:port Flow modules are available in Make?
The official app provides 1 trigger and 8 actions. The trigger starts a scenario when a PDF finishes generating; the actions cover sync and async PDF generation, downloading files, fetching a template's parameters, and making arbitrary API calls.
| Type | Module name (as shown in Make) | Purpose |
|---|---|---|
| Trigger (Instant) | Watch file completed | Starts the scenario when a PDF finishes generating. Receives the download ID, file name, share URL, and the parameters used |
| Action | Generate single PDF (sync) | Generates a single PDF synchronously; returns the file URL and request ID immediately |
| Action | Generate multiple PDFs (sync) | Generates multiple PDFs synchronously; returns a ZIP URL immediately |
| Action | Generate single PDF (async) | Starts asynchronous generation of a single PDF; returns requestId immediately |
| Action | Generate multiple PDFs (async) | Starts asynchronous generation of multiple PDFs in one call — more efficient than looping |
| Action | Download file | Downloads a PDF for a given requestId; leave File ID empty to download all files as a ZIP |
| Action | Get design parameters | Returns the parameter structure required by a template |
| Action | Build content item | Helper that assembles one item (file name, share settings, parameters) for a multi-PDF generation call |
| Action | Make an API call | Generic module for making an arbitrary authenticated request to the Re:port Flow API |
The Design ID picker in each generation module is populated from your connected workspace's templates, and Template parameters fields are built dynamically by Make based on the selected template and version. Don't hardcode parameters — fill in whatever fields are fetched for that template.
How do I generate a PDF in a Make scenario?
Put the Generate single PDF (sync) action after any trigger, pick a template, and map the trigger's values to the template parameters. The module returns the result immediately (the PDF data and its share URL), so you can pass it straight to a downstream module.
- Add any trigger (a Google Forms response, a new Google Sheets row, etc.)
- Add a Re:port Flow module and select Generate single PDF (sync)
- Configure:
- Design ID: pick the target template from the list
- Version: the version number
- File name: the output file name (e.g.
invoice.pdf) - Share type:
Workspace(default) /Invited/Public - Passcode protection: enable if needed
- Template parameters: map values from the trigger to the template's parameters
- Pass the module's output (the
databinary, orfiles[].share.url) to a downstream module such as Google Drive or Gmail
Should I use sync or async generation?
Use sync when the PDF is lightweight and you need the result immediately — sync calls time out after 60 seconds. Use async for PDFs that take longer to render or for bulk generation, and detect completion with the Watch file completed trigger or by polling Download file.
| Sync | Async | |
|---|---|---|
| Timeout | 60 seconds | None |
| Response | Returns the PDF / ZIP immediately | Returns requestId immediately (generation continues in the background) |
| Best for | On-the-spot downloads triggered by a user action; lightweight PDFs | PDFs that take longer to render; bulk generation such as monthly batches |
| Detecting completion | Not needed — the response is the result | The Watch file completed trigger, or poll Download file with the requestId |
When processing many records, use Build content item to assemble each item (file name, parameters, etc.) before passing them to Generate multiple PDFs (sync/async) — this reduces the Operations consumed by looping per record.
How do I fix errors and rate limits?
A 401 means the connection expired or was never authorized, and a 400 means the designId doesn't exist or the parameters don't satisfy the template's required fields. A 403 on Watch file completed means the trigger was connected with a non-administrator account; for any other 403, check the response message (for example, a plan limit) as described in Error Handling. If you hit the rate limit (429), wait the number of seconds in the Retry-After header before retrying.
| Symptom | Cause | Fix |
|---|---|---|
401 Unauthorized | The connection expired or was never authorized | Reconnect Re:port Flow from Make's Connections |
400 Bad Request | designId doesn't exist, or Template parameters doesn't satisfy the template's required fields | Re-check required fields and key names with Get design parameters |
403 (administrator permission required) | Watch file completed was connected with a non-administrator account | Reconnect with an administrator account (see How do I connect Re:port Flow to Make? above) |
429 Too Many Requests | Workspace-level rate limit exceeded (30 req/min for sync, 100 req/min for async/download) | Wait the number of seconds in the response's Retry-After header before retrying |
See Error Handling and Limitations for details.
Troubleshooting
Why don't any templates show up in the picker?
Check that the connected workspace has templates. If it doesn't yet, copy one from the Template Gallery and it will appear in the picker.
Why doesn't Watch file completed fire?
Confirm you connected with an administrator account (see the warning above). If you've scoped the trigger to a specific template, also check that its Design ID / Version filter matches what you're generating.
Why isn't the generated PDF what I expected?
Check whether any parameter values are empty or the wrong type by comparing them against the output of Get design parameters.
Next steps
- Designing async workflows — best practices for bulk generation
- Webhook notifications — how completion notifications work, and the administrator permission requirement
- OAuth 2.0 Authentication — authorization flow and scopes