> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blinkpdf.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Use Blink PDF in n8n, Make, and Zapier Automation Flows
> Connect Blink PDF to n8n, Make (Integromat), and Zapier using a standard HTTP node. No custom integration needed — just configure and go.
Because Blink PDF exposes a plain REST endpoint, it works out of the box with every major no-code and low-code automation platform. You don't need a dedicated integration or plugin — any tool that can make an HTTP POST request can call `/v1/render` and receive a PDF. This guide walks you through the exact configuration for n8n, Make (formerly Integromat), and Zapier.
## How the Integration Works
Every automation platform listed here has a native HTTP node. You configure it with:
* **Method:** POST
* **URL:** `https://api.blinkpdf.io/v1/render`
* **Header:** `x-api-key: bp_...`
* **Header:** `Accept: application/pdf`
* **Body (JSON):** `{ "markdown": "...", "metadata": { "title": "..." } }`
* **Response type:** Binary (the response is a PDF file)
The Markdown content you send in the body typically comes from an earlier step in your workflow — a form submission, a database query, a CRM record, or an AI node.
```text theme={null}
Trigger → Build Markdown → HTTP Node (Blink PDF) → Store / Email PDF
```
Your API key is a secret credential. Store it in your platform's built-in credential or environment variable manager rather than hardcoding it directly in the node configuration.
***
## n8n
### Create or open your workflow
Open n8n and create a new workflow (or open an existing one where you want to add PDF generation). Identify the node whose output contains the Markdown text you want to render.
### Add an HTTP Request node
Click the **+** button after your Markdown-producing node and search for **HTTP Request**. Add it to the canvas.
### Configure the request
In the HTTP Request node settings, set the following:
* **Method:** `POST`
* **URL:** `https://api.blinkpdf.io/v1/render`
* **Authentication:** Select **Header Auth**, then enter:
* **Name:** `x-api-key`
* **Value:** `bp_xxxxxxxxxxxxxxxxxxxx`
* **Body Content Type:** `JSON`
* **Body:** Switch to **JSON / RAW** mode and enter:
```json theme={null}
{
"markdown": "{{ $json.markdownContent }}",
"metadata": {
"title": "{{ $json.documentTitle }}"
}
}
```
Replace `$json.markdownContent` and `$json.documentTitle` with the actual expression paths from your upstream node.
### Set the response format to binary
In the **Options** section of the HTTP Request node, set **Response Format** to **File**. This tells n8n to handle the `application/pdf` response as a binary file rather than trying to parse it as JSON or text.
### Handle the PDF output
Connect the HTTP Request node to a downstream action — for example:
* **Write Binary File** — save the PDF to disk on your n8n host.
* **Send Email** — attach the binary output to an email via Gmail or SMTP nodes.
* **Google Drive / S3** — upload using the respective storage node.
### Test the workflow
Trigger the workflow manually using **Execute Workflow** and inspect the HTTP Request node's output. You should see a binary file in the output panel. Check the `X-Request-Id` header in the response metadata (and a `200` status) to confirm the render completed successfully.
In n8n, use the **Set** node before the HTTP Request node to assemble your Markdown string from multiple upstream fields. This keeps your HTTP node body clean and easy to read.
***
## Make (Integromat)
### Add an HTTP module to your scenario
Open your Make scenario and click the **+** icon to add a new module. Search for **HTTP** and choose **Make a Request**.
### Fill in the request details
Configure the module with these settings:
* **URL:** `https://api.blinkpdf.io/v1/render`
* **Method:** `POST`
* **Headers:**
* Click **Add item**, set **Name** to `x-api-key` and **Value** to `bp_xxxxxxxxxxxxxxxxxxxx`
* Add a second header: **Name** `Content-Type`, **Value** `application/json`
* Add a third header: **Name** `Accept`, **Value** `application/pdf`
* **Body type:** `Raw`
* **Content type:** `JSON (application/json)`
* **Request content:** Enter the JSON body, mapping fields from previous modules:
```json theme={null}
{
"markdown": "{{1.markdownContent}}",
"metadata": {
"title": "{{1.documentTitle}}"
}
}
```
### Set the response to binary
Under **Parse response**, leave it **disabled** — Make should receive the raw binary response, not attempt JSON parsing. Enable **Return the response as binary** if your Make version surfaces that option.
### Map the PDF to a downstream module
Connect the HTTP module to a storage or messaging module:
* **Google Drive → Upload a File** — set the file data to the binary output from the HTTP module and name it `invoice.pdf` or similar.
* **Email → Send an Email** — attach the binary as a file attachment.
* **Dropbox / OneDrive** — use the respective upload module.
### Run the scenario
Use **Run once** to test. Inspect the HTTP module's output bundle to verify it contains binary data. If you see a `200` status and a non-empty response body, the render succeeded.
***
## Zapier
### Choose "Webhooks by Zapier" as your action
In your Zap, after the trigger and any intermediate steps that produce your Markdown content, add a new **Action** step. Search for **Webhooks by Zapier** and select the **POST** action type.
### Configure the webhook
Fill in the Webhooks action with the following:
* **URL:** `https://api.blinkpdf.io/v1/render`
* **Payload Type:** `JSON`
* **Data (JSON body):**
```json theme={null}
{
"markdown": "Your Markdown content here",
"metadata": {
"title": "Document Title"
}
}
```
Map the Markdown content and title from earlier Zap steps using Zapier's field mapper.
* **Headers:**
* `x-api-key`: `bp_xxxxxxxxxxxxxxxxxxxx`
* `Accept`: `application/pdf`
* `Content-Type`: `application/json`
### Handle the binary response
Zapier's Webhooks action returns the raw response. Because Zapier does not natively handle binary PDF responses as file objects, the recommended pattern is to use Blink PDF as a **middle step** and then upload the response to a storage service:
* Pass the raw response body to a **Google Drive** or **Dropbox** action set to upload file content.
* Alternatively, use a **Code by Zapier** step (Python or JavaScript) to base64-decode the response and write it before passing it downstream.
### Test the step
Click **Test step** in Zapier. A successful test shows a `200` status code in the response. If you see a `401`, verify your `x-api-key` header value. If you see a `429`, you've hit your plan's rate limit — wait a minute and retry.
Zapier's free and lower-tier plans throttle the number of tasks per month. Each call to Blink PDF counts as one Zapier task. Factor this into your plan selection on both the Zapier and Blink PDF sides.
***
## Common Automation Patterns
A form submission triggers the workflow. The form data is assembled into a Markdown summary or receipt, rendered by Blink PDF, and emailed to the submitter as an attachment.
A new deal or order in your CRM triggers invoice generation. Line item data fills a Markdown template, Blink PDF renders it, and the PDF is saved to Google Drive or Dropbox.
A daily or weekly schedule trigger pulls data from a database or analytics tool, formats it as a Markdown report, renders to PDF, and posts the file to a Slack channel.
An AI node (like n8n's OpenAI integration) generates a Markdown summary from raw input. Blink PDF converts it to PDF, and the file is saved for archival or sharing.
Blink PDF's median render time of \~100ms means it adds negligible latency to your automation workflows. Even at Free plan rates (10 requests/min), you can process a document every six seconds continuously — and Pro (120/min) leaves plenty of headroom.