Parse documents in a Make scenario
ParseForMe connects to Make through the HTTP “Make a request” module. Because Make carries real file data between modules, the scenario uploads the bytes directly as multipart form data, and either waits inline for the result or receives it later on a Custom webhook.
Can Make send a file to ParseForMe?
Yes, directly. A Make scenario carries the file itself between modules, so the HTTP module posts it as multipart form data in a field named file — no intermediate storage and no public URL required. PDF, DOCX, PNG, JPEG, TIFF and WebP up to 20 MB are accepted.
Wait inline, or receive a webhook
A short scenario can add wait to the upload call and hold for up to 25 seconds for a terminal status, so the parsed fields are in the same bundle as the upload. A longer document is better handled by a second scenario that starts on a Custom webhook.
Mapping the fields
The API returns the nine document kinds and the fields each extracts, so Make’s mapping panel is filled from real field names rather than a guess. Every value arrives with a confidence score alongside it, which is what a router should branch on when a document needs a human.
What this integration is not
There is no ParseForMe app in Make’s catalogue, so you configure an HTTP module rather than picking actions from a list. Make’s Custom webhook has no signature check of its own either — the URL is the secret, and an optional auth header is the stronger option.
How to set it up
Create an API key
Nothing else works without one. Keys are created in the ParseForMe dashboard — under Settings → API keys, or from the inline form on any in-app integration guide. The key is shown once, starts with pfm_live_ and is 52 characters long; store it in your automation platform’s credential store, never in a step’s visible fields. Owners and admins can create keys, a workspace can hold up to 10 active keys, and revoking one takes effect immediately. Send it as a bearer token and check it with /v1/me before you build anything else.
curl -s https://api.parseforme.com/v1/me \ -H "Authorization: Bearer pfm_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # {"workspaceId":"…","workspaceName":"Acme","keyName":"Zapier","balance":420}Add an HTTP → “Make a request” module
Make carries real file data between modules, so upload the bytes: method POST, URL https://api.parseforme.com/v1/documents, Body type multipart/form-data, and one field of type File named exactly file, mapped to the file from the previous module. Add the Authorization header and leave Content-Type to Make — it sets the multipart boundary. Files up to 20 MB: PDF, DOCX, PNG, JPEG, TIFF or WebP.
URL POST https://api.parseforme.com/v1/documents Headers Authorization: Bearer pfm_live_… Body multipart/form-data file (File) ← 1. Google Drive › Download a file filename (Text) ← {{1.name}} kind (Text) invoice (optional — omit to auto-detect)Wait for the result inside the same scenario
For a short scenario you can skip webhooks entirely: add ?wait=25 to the upload URL and the response holds on for up to 25 seconds for a terminal status. When it comes back with status parsed the extracted fields are already in result.fields, ready to map into the next module. If it comes back still processing, fall back to the webhook or to the polling step below rather than looping the scenario.
URL POST https://api.parseforme.com/v1/documents?wait=25 → {"id":"…","status":"parsed","kind":"invoice", "result":{"schemaVersion":"invoice_v1","fields":{…},"confidence":{…}}}Trigger a scenario with a Custom webhook
Add Webhooks → Custom webhook as the first module of a second scenario and copy the URL Make generates, then register it with POST /v1/webhooks. Turn includeResult on so the parsed fields arrive with the event. Run the scenario once in listening mode and send a test event so Make learns the payload structure. Registering an endpoint emails the workspace owners and admins — that is the notice working, not an alarm.
curl -s -X POST https://api.parseforme.com/v1/webhooks \ -H "Authorization: Bearer pfm_live_…" \ -H "Content-Type: application/json" \ -d '{ "url": "https://hook.eu2.make.com/abcdefghijklmnopqrstuvwxyz", "events": ["document.parsed", "document.failed"], "includeResult": true }'What secures a Make webhook, honestly
Make’s Custom webhook has no built-in signature check, so its security rests on the URL being unguessable — treat it as a secret and regenerate it if it leaks. You can register the endpoint with an authHeader and ParseForMe will send that header on every delivery, giving a first module something to check before the scenario does any work. Every delivery also comes from 46.62.162.196 and follows no redirects.
POST https://api.parseforme.com/v1/webhooks { "url": "https://hook.eu2.make.com/abcdefghijklmnopqrstuvwxyz", "events": ["document.parsed"], "authHeader": { "name": "X-Make-Token", "value": "a-long-random-string" } }Send a test event
POST /v1/webhooks/{id}/test delivers a synthetic document.parsed and reports the status your endpoint returned — the quickest way to have Make determine the data structure before a real document exists.
curl -s -X POST https://api.parseforme.com/v1/webhooks/1f8c…/test \ -H "Authorization: Bearer pfm_live_…" # {"delivered":true,"status":200}Keep a polling backstop
Webhooks are the fast path, not the only one. GET /v1/documents returns documents newest first by creation time, each with a stable id, so a scheduled run picks up anything a delivery missed — and two things only polling sees: an event lost before it was queued (delivery is at-most-once), and a document whose event you missed while an endpoint was disabled. since= filters that same creation time — not the parse time — so set it a little before your last successful check and keep the window wide enough to cover a slow parse: a document created before your watermark but parsed after it will not reappear. Ask for up to 100 with limit=; the response is items only, with no cursor to follow. Deduplicate on the document id.
GET /v1/documents?status=parsed&since=2026-09-02T08:00:00Z&limit=50 Host: api.parseforme.com Authorization: Bearer pfm_live_… # → { "items": [ { "id": "8f14e45f-…", "status": "parsed", "kind": "invoice" } ] }Map the fields you care about
GET /v1/document-types returns the nine document kinds and the fields each one extracts, so your mapping step can be built against the real field names instead of a guess. Parsed values arrive under result.fields, with a matching entry in result.confidence — route anything you want a human to check on that, rather than on a total.
curl -s https://api.parseforme.com/v1/document-types \ -H "Authorization: Bearer pfm_live_…"
Frequently asked questions
Is there a ParseForMe module in Make?
Not in the catalogue. You use Make’s built-in HTTP “Make a request” module to upload, and a Custom webhook to receive parsed documents.
Does the scenario have to host the file somewhere first?
No. Make passes the file data between modules, so the HTTP module uploads the bytes as multipart form data in a field named file.
Can a scenario get the parsed fields without a second scenario?
Often, yes — add wait to the upload call and the response holds for up to 25 seconds for a terminal status, returning the extracted fields inline.
How do I know a webhook call really came from ParseForMe?
Make’s Custom webhook has no signature check of its own, so the URL is the secret. Register the endpoint with an auth header of your choosing and ParseForMe sends it on every delivery, giving your first module something to check. Every delivery also comes from one fixed IP address.
Make is a trademark of Celonis SE. ParseForMe is not affiliated with, endorsed by or sponsored by Make.
Try it on your own document
Drop a document to see the structured data come back.