Resources · Make integration

Paperless.io Make integrationAutomate Paperless.io with Make.

Can Make handle your Paperless.io documents without a line of code? The Paperless.io Make integration gives you 8 modules: 1 trigger, 5 actions and 2 searches. This guide shows who it suits, how to link your account and how to build a first working scenario.

Try the Paperless.io integration on MakeSee the 8 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Paperless.io Make integration do for you?

The Paperless.io Make integration lets Make read and change your Paperless.io documents and templates for you. You build a scenario, the automation itself, out of modules, and each module is one step: a trigger that starts things, an action that does something, or a search that finds records.

Documents that start from your other tools. A new client added in your CRM or a form answer can open the flow, and Create a Document produces the Paperless.io document without anyone copying data by hand. Pair it with Search Templates or Get a Template when you first need to pick the right model.

A follow-up on what already exists. Watch Documents brings Paperless.io documents into a scenario when Make checks the account, so a sales assistant or an office manager can log them, share them or pass them to the next app. Search Documents does the same on demand, in the middle of a flow.

Clean records. Update a Document corrects a document once another tool holds better data, and Delete a Document removes one that is no longer needed. Test both carefully before you switch anything on.

The Make documentation lists no specific limit for this app, so the limits of your Make plan are the ones to know; Make pricing sums them up. When a listed module falls short, Make an API Call reaches the rest of the Paperless.io API. Weighing another tool? Read n8n vs Make, and if you would rather learn the editor step by step, Make training is the place to start.

Connect

How do you connect Paperless.io to Make?

  1. 01

    Create an API key in Paperless.io

    Open your Paperless.io account settings (top right), choose Integrations, then click Create Integration and give it a name. Create a new API key, name it, select all access permissions and copy the key shown on screen.

  2. 02

    Add a Paperless.io module in Make

    In your Make scenario, add any Paperless.io module and click Create a connection. A connection is your Paperless.io account linked to Make once, then reused by every Paperless.io module you add later.

  3. 03

    Paste the key and save

    Fill the optional Connection name field with something you will recognize, for example the workspace it belongs to. Paste the API key you copied and confirm. Make can now list what it is allowed to read in your account.

First scenario

Your first scenario with Paperless.io

GoalWhen a new client lands in another app, Make creates the matching document in Paperless.io.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the big +. Pick the app where your new clients appear first, a CRM or a form tool, and choose its trigger.

  2. 02

    Add Create a Document

    Click the + on the right of that first module, search for Paperless.io and pick Create a Document. Click Create a connection and paste your API key if it is not linked yet.

  3. 03

    Map the client data

    Fill the fields of Create a Document. Click inside a field and Make offers the values of the previous module, such as the client name, so you map them instead of typing fixed text.

  4. 04

    Test with Run once

    Click Run once, then add a test client in the first app. Each module shows the bundles it received, a bundle being one item passed along, here one client. Check the new document in Paperless.io.

  5. 05

    Schedule and switch it on

    Open the clock on the first module to set how often Make checks it (every 15 minutes by default), save, then switch the scenario on. Each module run counts as one operation on your plan.

Triggers

What starts a Paperless.io scenario

1 module starts a scenario when something happens in Paperless.io. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Paperless.io as soon as it happens.

Paperless.io1Watch Documents

Watch Documents

triggerIn the docs only

Watch Documents gives your scenario a starting point inside Paperless.io: each document it picks up becomes a bundle that the next modules can log, share or copy elsewhere. The Make documentation does not say whether it catches new documents only or changes as well, so run it once on a test account and look at what comes out.

How it fires
scheduled. Make checks Paperless.io on the scenario's schedule, every 15 minutes by default and never faster than that on the Free plan.
When to use it
when a Paperless.io document should kick off work in another tool, such as a row in a tracking sheet.
Watch out
avoid pairing it with Update a Document on the same records, or each update may wake the scenario again.
Modules

What the Paperless.io modules do

Paperless.io gives you 7 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Paperless.io1

Create a Document

ActionIn the docs only

You get a new Paperless.io document without opening the app, filled with the data your scenario already carries. It is the module most first scenarios end on, since it turns a record in another tool into a document.

When to use it
a new client or a signed quote appears in your CRM and the paperwork should follow on its own.
Watch out
every run adds a document, so test with fake data first.
Paperless.io2

Delete a Document

ActionIn the docs only

Drafts and duplicates stop piling up: this module removes a Paperless.io document for you. It acts on one document at a time, the one whose identifier you map from an earlier module.

When to use it
a deal is cancelled in another tool and its document should disappear with it.
Watch out
treat every deletion as final, so place a filter before it and test on a throwaway document.
Paperless.io3

Get a Template

ActionIn the docs only

Get a Template returns the details of one template you already know, ready to be mapped into the next module. Choose it over Search Templates when the scenario always works with the same model and you have its identifier.

When to use it
every new contract should start from the same house template.
Watch out
copying the identifier by hand invites typos, so read it from a Run once of Search Templates and paste it from there.
Paperless.io4

Make an API Call

ActionIn the docs only

Make an API Call is your way out when the seven other modules do not cover a need: it calls any endpoint of the Paperless.io API with the connection you already set up. Its answer arrives as a bundle you can map.

When to use it
the action you want exists in the Paperless.io API but has no dedicated module in Make.
Watch out
you write the request yourself, so keep the Paperless.io API reference open next to the editor.
Paperless.io5

Search Documents

SearchIn the docs only

Search Documents finds the Paperless.io documents that match what you ask for, in the middle of a scenario rather than at its start. It can return zero, one or several bundles, and every following module runs once per document found.

When to use it
before updating a client file, to find the document that belongs to that client.
Watch out
plan for the empty result and for several matches, otherwise the next steps may run more often than you expect.
Paperless.io6

Search Templates

SearchIn the docs only

With Search Templates, the scenario picks the right Paperless.io template on its own instead of relying on a fixed choice. Like any search, it can come back with no template, one, or a list of them.

When to use it
your templates differ by offer or by language and the incoming data tells you which one fits.
Watch out
if several templates match, keep only the first result or add a filter before Create a Document.
Paperless.io7

Update a Document

ActionIn the docs only

Update a Document changes an existing Paperless.io document so it matches the latest data from your other tools. It works on one document, so it usually follows Search Documents, which supplies the right identifier.

When to use it
a client corrects an address in your CRM and the document still shows the old one.
Watch out
map only the fields you want to change, and never place it right after Watch Documents on the same document, or the scenario can loop.
Need help

Need help automating Paperless.io with Make?

A person reads every message.

FAQ

Paperless.io and Make: frequent questions

01Is the Paperless.io Make integration free?
Yes, on the Make side. Paperless.io is a standard app, so its modules are available from the Free plan. That plan allows 2 active scenarios, at least 15 minutes between two scheduled runs, runs of 5 minutes at most, files up to 5 MB and 512 MB of data transfer. Paid plans drop the interval to 1 minute and lift the active scenario cap. You still need an active Paperless.io account, and its own pricing is set by Paperless.io.
02What do you need to connect Paperless.io to Make?
Two things: an active Paperless.io account and an API key created in it. In Paperless.io, open the account settings, go to Integrations, click Create Integration, then create an API key with all access permissions and copy it. In Make, add a Paperless.io module, click Create a connection and paste the key. The connection is saved once and reused by every Paperless.io module in your scenarios, so this setup happens a single time.
03Does the Paperless.io trigger in Make react in real time?
No. Watch Documents is a scheduled trigger: Make checks Paperless.io on the schedule you set on the first module. A new scenario checks every 15 minutes by default, which is also the shortest interval on the Free plan; paid plans go down to 1 minute. If a few minutes of delay is a problem, start the scenario from another app that calls Make at once and use the Paperless.io modules as actions further down.
04What if a Paperless.io module you need is missing in Make?
Use Make an API Call. It sends a request to any endpoint of the Paperless.io API with the connection you already created, so you are not limited to the 7 other modules. The Make documentation lists no app-specific limit for Paperless.io, which means the constraints you meet come from your Make plan, such as file size or run length. Keep the Paperless.io API reference at hand, since you write that request yourself.
05Should you use Make or n8n for Paperless.io?
It depends on the tool your team already knows. On Make, Paperless.io offers 8 ready modules, one API key to connect. The same app often has an n8n node as well. Compare the modules each side offers for the actions you need, then decide by where the rest of your automations already live. Keeping everything in one tool makes maintenance easier. Starting from scratch? Build the same small case on both, such as a document created for a new client, and keep the one you find clearer.
Same platform

Other docs you might need on this stack.

Browse all integrations