Resources · Make integration

Parseur Make integrationAutomate Parseur with Make.

What happens to a document once Parseur has finished reading it? The Parseur Make integration answers that with 17 modules: 6 triggers, 9 actions and 2 searches. This guide is for teams who already use Parseur and want their mailboxes to feed other tools without code.

Try the Parseur integration on MakeSee the 17 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Parseur Make integration do for you?

The Parseur Make integration links your Parseur account to Make, a no-code tool where you build a scenario: an automation made of modules, each one a single brick such as a trigger, an action or a search. Parseur then tells Make when a document has been processed, and Make can upload documents, manage mailboxes or look up past files for you.

Hand off every processed document. Start a scenario on Watch Document Processed and pass what Parseur produced to the next app in the chain. If the next app expects plain rows rather than nested tables, Watch Document Processed Flattened is the better starting point.

Feed a mailbox from somewhere else. Files often land in a shared drive or a form before anyone thinks of Parseur. Upload a Document sends each of them to the right mailbox, so nobody forwards attachments by hand anymore.

Catch what went wrong. Watch Process Failed and Watch Failed Exports let a scenario notice problems, and Reprocess a Document gives a file a second pass once the template has been fixed. Watch Template Needed tells you when Parseur has no template for a document yet.

Make does not replace your Parseur settings: templates still live in Parseur, and the official doc warns that its own text is AI-generated and may contain mistakes, so check anything critical against Parseur. When a Parseur node also exists on the other side, the n8n vs Make comparison lays out the criteria. To learn the editor properly, see the Make training, and Make pricing explains how operations are counted.

Connect

How do you connect Parseur to Make?

  1. 01

    Create an API key in Parseur

    Log in to Parseur, open the Account section, then the API keys tab, and click Create new API key. Give it a name you will recognize, set an expiration in months if you want one, and copy the key shown in the window.

  2. 02

    Add a Parseur module in Make

    In your Make scenario, add any Parseur module and click Create a connection. The connection is your Parseur account linked to Make once; every Parseur module in your scenarios reuses it. The Connection name field is optional.

  3. 03

    Paste the key and save

    Paste the API key you copied from Parseur, or follow the instructions Make shows on screen, then save. Make can now list your mailboxes and documents in the module fields instead of asking you to type identifiers.

First scenario

Build your first scenario with Parseur

GoalWhen a new file shows up in another app, Make sends it to a Parseur mailbox with Upload a Document.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the big +. This first module decides when the scenario starts: pick the app where your files arrive and its trigger for new files.

  2. 02

    Add Upload a Document

    Click the + on the right of that first module, search for Parseur and choose Upload a Document. Link your account with Create a connection if you have not done it yet.

  3. 03

    Pick the mailbox and map the file

    Make lists your Parseur mailboxes once the connection exists, so choose the one that holds the right template. Then map the file coming from the first module, which Make passes along as a bundle: one item flowing to the next module.

  4. 04

    Test with Run once

    Drop a sample file where the first app watches, then click Run once. Open the bubble above each module to read the bundles it received and check that the document now sits in the Parseur mailbox.

  5. 05

    Schedule it and switch it on

    Open the clock on the first module to set how often Make checks: a new scenario runs every 15 minutes by default. Switch the scenario on, and every new file follows the same path without you.

Triggers

Which Parseur triggers can start a scenario?

6 modules start a scenario when something happens in Parseur. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Parseur as soon as it happens.

Parseur1Watch Document Processed

Watch Document Processed

Instant trigger

In Make“Triggers when a document is processed.”

This trigger starts your scenario right after Parseur finishes processing a document, so the result can travel on to a spreadsheet, a CRM or an accounting tool without anyone copying it.

How it fires
instant, Parseur calls Make through a webhook as soon as the document is processed.
When to use it
it is the default entry point for most Parseur scenarios, whenever each processed document should lead to one action elsewhere.
Watch out
click Create a webhook before Create a connection, otherwise the module cannot receive anything.
Parseur2Watch Document Processed Flattened

Watch Document Processed Flattened

Instant trigger

In Make“Triggers when a document is processed. Returns "flattened" table fields.”

Same moment as the previous trigger, a document has just been processed, but table fields come back "flattened", which spares you from unpacking nested data in the next module.

How it fires
instant, Parseur warns Make through a webhook the moment processing ends.
When to use it
choose it when the destination wants simple columns, for example one row in a sheet per document, and nested table data would only get in the way.
Watch out
if two active scenarios use both document triggers toward the same destination, each document lands there twice.
Parseur3Watch Table Processed

Watch Table Processed

Instant trigger

In Make“Triggers when a table is processed.”

Here the event is a processed table rather than a whole document. Your scenario receives it as soon as Parseur is done, ready to be written line by line into another tool.

How it fires
instant, the app calls Make by webhook as soon as the table is processed.
When to use it
documents built around a table, like order lines or item lists, where the table is the part your team actually needs downstream.
Watch out
a table usually holds several lines, so plan the next module for more than one bundle and test with Run once on a real sample.
Parseur4Watch Template Needed

Watch Template Needed

Instant trigger

In Make“Triggers when a template is needed.”

Parseur raises this event when a document arrives that it cannot read without a template. The scenario can alert whoever maintains your templates, so a new layout never waits unnoticed in a mailbox.

How it fires
instant, Parseur notifies Make through a webhook when a template is needed.
When to use it
a supplier changes its invoice layout, or a brand new sender starts writing to your mailbox, and someone has to teach Parseur the new format.
Watch out
the document itself is not fixed by this trigger; once the template exists, Reprocess a Document runs it again.
Parseur5Watch Failed Exports

Watch Failed Exports

triggerIn the docs only

Going by its name, this trigger picks up Parseur exports that failed, so a broken handoff shows up in a scenario instead of being discovered much later by the person expecting the data.

How it fires
scheduled, Make checks Parseur on the scenario's schedule, every 15 minutes by default for a new scenario.
When to use it
you already send Parseur data to other tools and want a message to a channel or a ticket each time one of those sends fails.
Watch out
the doc lists this module without a description, so run it once on your own account to see what a bundle contains before mapping anything.
Parseur6Watch Process Failed

Watch Process Failed

triggerIn the docs only

Its name points to documents that Parseur failed to process, where the previous trigger covers exports. It gives your team a list of files to look at rather than silent gaps in the data.

How it fires
scheduled, Make queries Parseur at the pace set in the scenario's clock.
When to use it
a mailbox receives scans or odd formats and you want every failure logged in a sheet or sent to the person in charge.
Watch out
the doc gives no description for it either; read the bundles from a Run once test before relying on any field.
Modules

What can Make do in Parseur?

Parseur gives you 11 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Parseur1

Create a Mailbox

Action

In Make“Creates a new mailbox.”

Creates a new Parseur mailbox from inside a scenario, which saves you a detour through the Parseur interface when a new stream of documents begins.

When to use it
a new client or supplier is signed and should get its own mailbox the moment its record is created in your CRM.
Watch out
pair it with Watch Template Needed in another scenario, so the first documents that Parseur cannot read yet reach someone who can set things up.
Parseur2

Delete a Document

Action

In Make“Deletes an existing document.”

Removes one document from Parseur once you no longer need it, which keeps mailboxes tidy after the data has safely reached its destination.

When to use it
as the last step of a scenario, after the next app has confirmed it stored the result.
Watch out
a deletion cannot be undone, so place it after the modules that copy the data, never before, and test the whole chain with Run once.
Parseur3

Delete a Mailbox

Action

In Make“Deletes an exisitng mailbox.”

Deletes a whole Parseur mailbox, the counterpart of Create a Mailbox when a client relationship or a project comes to an end.

When to use it
an offboarding scenario that closes every account tied to a client, including the mailbox that received its documents.
Watch out
this is the heaviest action of the list and it cannot be reversed; add a filter or a manual approval before it rather than letting it run on any bundle.
Parseur4

Get a Document

Action

In Make“Retrieves an existing document.”

Fetches one existing document by its identity, so a later module can read its details even when the scenario did not start from a Parseur trigger.

When to use it
another app stores a Parseur document reference and you need the full document again to complete a record.
Watch out
it returns a single document; to find documents by criteria, Search Documents is the right module.
Parseur5

Get a Mailbox

Action

In Make“Retrieves an existing mailbox.”

Reads the details of one mailbox, which is handy when a scenario must check how a mailbox is set up before sending it anything.

When to use it
before Update a Mailbox, to see the current state, or to include mailbox details in a report sent to your team.
Watch out
you need the mailbox already identified; when you only know part of the picture, run Search Mailboxes first.
Parseur6

Make an API Call

Action

In Make“Performs an arbitrary authorized API Call.”

Calls any endpoint of the Parseur API with the connection you already set up, which covers whatever the ten other action and search modules do not.

When to use it
the Parseur API offers an operation that has no dedicated module in Make and you would rather not build a separate authentication.
Watch out
you write the request yourself, so keep the Parseur API documentation open and test the call with Run once before adding modules after it.
Parseur7

Reprocess a Document

Action

In Make“Reprocesses an exisitng document.”

Sends an existing document through Parseur again, so a file that failed or was read with an old template gets a fresh result without being uploaded twice.

When to use it
right after someone fixes or adds a template, to rerun the documents that were stuck.
Watch out
reprocessing a document before the template is fixed will likely end the same way; pair it with Watch Template Needed and a human check.
Parseur8

Update a Mailbox

Action

In Make“Updates an existing mailbox.”

Changes the settings of an existing mailbox from a scenario, so a change decided elsewhere is applied in Parseur without anyone logging in.

When to use it
a client record is renamed in your CRM and the matching mailbox should follow.
Watch out
read the mailbox with Get a Mailbox first, so you know exactly what you are about to change and can map the right values.
Parseur9

Upload a Document

Action

In Make“Uploads a document to a mailbox.”

Drops a file into a Parseur mailbox, the entry point for documents that do not arrive by email: attachments saved in a drive, files sent through a form.

When to use it
whenever the file starts life in another app, as in the first scenario above.
Watch out
on the Make Free plan, files are capped at 5 MB, so large scans may need a paid plan.
Parseur10

Search Documents

Search

In Make“Retrieves a list of documents by criteria.”

Returns the documents that match your criteria, each as its own bundle, which lets a scenario work through a batch in one run.

When to use it
to collect every document from a mailbox that needs another pass, then feed them to Reprocess a Document.
Watch out
a search can return zero, one or many documents, and each one costs operations in the modules that follow.
Parseur11

Search Mailboxes

Search

In Make“Retrieves a list of mailboxes for the account.”

Lists the mailboxes of your Parseur account, one bundle per mailbox, so a scenario can act on all of them or pick the right one by name.

When to use it
an audit of your mailboxes, or finding the mailbox tied to a client before Upload a Document.
Watch out
when nothing matches, the modules after it simply do not run, which can look like a silent failure during a test.
Need help

Need help automating Parseur with Make?

A person reads every message.

FAQ

Questions people ask about Parseur and Make

01Is the Parseur Make integration free?
Yes, on the Make side. Parseur is a standard app, available from the Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes per execution, files up to 5 MB and 512 MB of data transfer. Paid plans drop the interval to 1 minute and allow 40 minutes per run. Make counts usage in operations, one per module per bundle. Your Parseur subscription is separate and is set on the Parseur side.
02What do you need to connect Parseur to Make?
An active Parseur account and an API token. In Parseur, open Account, go to the API keys tab, click Create new API key, name it and copy the key. In Make, add a Parseur module, click Create a connection and paste that key. For instant triggers, click Create a webhook first. If you set an expiration on the key, note the date, since the connection will need a new key after it.
03Do Parseur triggers in Make fire in real time?
Four of them do. Watch Document Processed, Watch Document Processed Flattened, Watch Table Processed and Watch Template Needed are instant: Parseur calls Make through a webhook as soon as the event happens. Watch Failed Exports and Watch Process Failed are scheduled: Make checks Parseur on the scenario's schedule, every 15 minutes by default, and no faster than every 15 minutes on the Free plan. To test either kind, click Run once and read the bundles each module received.
04What if a Parseur module you need is missing in Make?
Use Make an API Call. It reaches any endpoint of the Parseur API through the connection you already have, so an operation without a dedicated module is still within reach. You write the request yourself, which means reading the Parseur API documentation. The Make doc for Parseur also states that its text is AI-generated and may contain mistakes, so confirm anything critical directly with Parseur. For a routine need, check the 11 action and search modules first, since a dedicated module is easier to maintain.
05Should you use Make or n8n for Parseur?
It depends on the tool your team already runs. In Make, Parseur comes with 17 modules, four instant triggers and a guided editor where each step is a visible bubble, which suits people who build their first automations. If your workflows already live in n8n, check whether a Parseur node exists there before moving anything. The n8n vs Make comparison on this site sets out the criteria without ranking the two.
Same platform

Other docs you might need on this stack.

Browse all integrations