PDF automation in Make scenarios.
Every ASHDOCS tool is one “HTTP → Make a request” module away — generate, convert, edit and extract documents inside any scenario.
Prerequisites
- An ASHDOCS account — the free tier includes 100 monthly credits, no card required.
- An API key from the dashboard (Keys page). Sandbox keys (prefix ash_test_) run everything without consuming credits.
Test the key before building anything:
curl https://www.ashdocs.com/api/v1/me -H "X-API-Key: ash_live_..."
Setup, step by step
- 1
Add the HTTP module
In your scenario, add “HTTP → Make a request”. This built-in module is all you need — there is nothing to install.
- 2
Set the URL and method
Method: POST. URL: the tool endpoint — swap the slug for any of the 30 tools.
https://www.ashdocs.com/api/v1/tools/html-to-pdf
- 3
Add the headers
Under Headers, add Item 1: Name “X-API-Key”, Value your key. For JSON tools (html-to-pdf, url-to-pdf, invoice-pdf, qr-code) add Item 2: Name “Content-Type”, Value “application/json”. For file uploads leave Content-Type unset — Make sets the multipart boundary itself.
- 4
Body for JSON tools
Body type: Raw. Content type: JSON (application/json). Request content: your payload, with scenario variables mapped in.
{"html": "<h1>Invoice {{1.invoice_no}}</h1>", "options": {"format": "A4"}} - 5
Body for file tools
Body type: Multipart/form-data. Add a field with Key exactly “files”, set Field type to “File”, and map the Data from the previous module (for example Google Drive “Download a file”). Add a second “files” item for tools that take several files, like merge.
- 6
Read the response
Set “Parse response” to Yes. The API returns JSON — not raw bytes — containing signed download URLs. Map output_files[].url (or add "output": "url" inside options and map the flat file_url field) into an “HTTP → Get a file” module; that module outputs the actual PDF binary for Drive, email or Dropbox steps.
Files in
Upload bytes as multipart with the field name “files” (repeat the field for multi-file tools like merge), or skip the upload entirely: when the upstream module gives you a downloadable link, send a JSON body with “file_url” and the API fetches it server-side.
Files out
Responses are JSON with signed URLs that expire after 60 minutes. Add "output": "url" inside options to get a flat file_url field, then use “HTTP → Get a file” to turn that URL into a binary for the next module.
Three ready-made recipes
Watch a Drive folder → convert Office files to PDF
- Google Drive → “Watch Files in a Folder” (trigger).
- Google Drive → “Download a file”.
- HTTP → “Make a request”: POST https://www.ashdocs.com/api/v1/tools/office-to-pdf, multipart field “files” mapped to the downloaded Data.
- HTTP → “Get a file”: URL mapped from output_files[].url in the JSON response.
- Google Drive → “Upload a file” with the binary from step 4.
Airtable record → invoice PDF → email attachment
- Airtable → “Watch Records” (trigger).
- HTTP → “Make a request”: POST https://www.ashdocs.com/api/v1/tools/html-to-pdf with a JSON body built from record fields and "options": {"format": "A4", "output": "url"}.
- HTTP → “Get a file”: URL mapped from the file_url field.
- Email → “Send an email” with the downloaded PDF as attachment.
Async: trigger a scenario when any job completesasync / webhook
- Add a “Custom webhook” trigger in Make and copy its URL.
- Register it once with the ASHDOCS webhook API:
curl -X POST https://www.ashdocs.com/api/webhooks \ -H "X-API-Key: ash_live_..." \ -H "Content-Type: application/json" \ -d '{"url": "https://hook.make.com/your-webhook", "events": ["job.completed"]}'- Every completed job now starts the scenario. The signed payload contains job_id, tool and outputs[].url — map an “HTTP → Get a file” module on that URL to fetch the result.
Popular recipes
beta — report import issuesImportable scenario blueprints. After import, reconnect your own accounts and replace YOUR_API_KEY.
Airtable record → invoice PDF → email
~10 min setupEvery new Airtable record becomes a rendered invoice PDF, emailed as a 60-minute download link.
Download blueprintImport: Scenario → ⋯ → Import Blueprint. Reconnect your own accounts after import.
Drive folder → Office files to PDF
~15 min setupWatch a Google Drive folder and convert every new DOCX/XLSX/PPTX to PDF, uploaded back to Drive.
Download blueprintImport: Scenario → ⋯ → Import Blueprint. Reconnect your own accounts after import.
Webhook in → compressed PDF URL out
~10 min setupA custom webhook receives a file_url and instantly responds with the compressed file's URL.
Download blueprintImport: Scenario → ⋯ → Import Blueprint. Reconnect your own accounts after import.
Troubleshooting
| Symptom | Fix |
|---|---|
| The next module receives JSON text instead of a PDF | That JSON is the job envelope. Map output_files[].url (or set options.output to “url” and map file_url) into an “HTTP → Get a file” module — that module outputs the binary. |
| 401 Unauthorized | The header name must be exactly X-API-Key — not Authorization, not Api-Key. |
| “Files required” or the multipart field is rejected | The multipart field key must be exactly “files”, with Field type set to File and Data mapped from the previous module. |
| Large files fail to upload | Upload limits follow your ASHDOCS plan: 10 MB (Free), 25 MB (Starter), 50 MB (Growth), 100 MB (Pro). |
Frequently asked questions
Do I need a custom Make app?
No. The built-in HTTP module is all you need — it speaks to the ASHDOCS REST API directly, and there is nothing to install or authorize beyond your API key header.
Does sandbox mode work in Make?
Yes. Keys with the ash_test_ prefix run every tool end-to-end through the exact same modules without consuming credits — build and test the whole scenario on a sandbox key, then swap in the live key.
Do credits cost the same via Make?
Yes. One credit per successful operation, exactly the same as calling the API directly. Failed jobs are never charged.
Can I chain multiple tools in one scenario?
Yes — chain HTTP modules and pass each output URL forward as the next tool's file_url. For fixed sequences, ASHDOCS server-side pipelines run the whole chain in a single call, which is faster and uses one module instead of five.