Resources · Make integration

DocsParse Make integrationAutomate DocsParse with Make.

Can Make hand your documents to DocsParse for you? Yes. The DocsParse Make integration gives you 4 action modules to upload a file or a link and start a parse. This guide covers the API key, a first scenario and each module in plain words.

Try the DocsParse integration on MakeSee the 4 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the DocsParse Make integration let you automate?

The DocsParse Make integration links your DocsParse account to Make so a scenario, the automation you build in Make, can send documents to DocsParse and start a parse without you opening DocsParse. Each step of that automation is a module, and all four DocsParse modules are actions: they do something when the scenario reaches them.

Parse attachments as they arrive. Another app catches a new file, Upload a Document (File) sends it to DocsParse, then Parse a Document (Async) starts the parse. This is the flow the first scenario below builds.

Work from links instead of files. When your documents already live online, Upload a Document (URL) passes the address rather than the file itself, which keeps the scenario simple when the source only gives you a link.

Reach the rest of the API. Make an API Call uses the same connection to call any endpoint of the DocsParse API the three named modules leave out.

What the integration does not include: a trigger. Nothing in DocsParse starts a scenario on its own, so the first module comes from another app or from a schedule. The DocsParse documentation on Make also warns that its content is AI-generated and may contain mistakes, so check important details with DocsParse. If you are new to the editor, the Make training walks through the basics, and Make pricing explains how operations are counted. DocsParse may also have an n8n node; n8n vs Make sets the two tools side by side.

Connect

How do you connect your DocsParse account to Make?

  1. 01

    Generate your API token in DocsParse

    In DocsParse, open Workflow in the main menu, then Integrations and API. Click Generate token if you do not have one yet, and copy the token shown on screen. You need an active DocsParse account for this.

  2. 02

    Add a DocsParse module in Make

    In your scenario, add any DocsParse module and click Create a connection. The Connection name field is optional; a clear name helps once you link several accounts. A connection is simply your DocsParse account linked to Make once.

  3. 03

    Paste the token and save

    Paste the API token you copied, or follow the on-screen instructions, and save. Every DocsParse module in any scenario can now reuse this connection, so you will not paste the token again.

First scenario

Build your first scenario with DocsParse

GoalWhen another app hands Make a new file, Make uploads it to DocsParse and starts the parse.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the + to add the first module. Since DocsParse has no trigger, pick the app where your files arrive.

  2. 02

    Set up the source module

    Choose the module of that app which returns a file, link its account with Create a connection and fill its fields. Make lists what it can read once the connection exists.

  3. 03

    Add Upload a Document (File)

    Click the + on the right, search DocsParse and pick Upload a Document (File). Connect your account, then map the file coming from the previous module.

  4. 04

    Add Parse a Document (Async)

    Add Parse a Document (Async) after the upload and map the data it needs from the upload step. It reuses the same DocsParse connection.

  5. 05

    Test with Run once

    Click Run once and open each module to read the bundles it received. A bundle is one item passing between modules, here one file.

  6. 06

    Schedule and switch it on

    Set the schedule on the first module, every 15 minutes by default, and switch the scenario on. On the Free plan, 15 minutes is also the shortest interval.

Modules

What can each DocsParse module do?

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

DocsParse1

Make an API Call

ActionIn the docs only

This module gives you access to any endpoint of the DocsParse API from your scenario, with the connection you already set up. You get the actions the three named modules do not cover.

When to use it
once you have found an endpoint in the DocsParse API documentation that none of the other modules offers.
Watch out
you write the request yourself, so keep the API documentation open while you fill it.
DocsParse2

Parse a Document (Async)

ActionIn the docs only

Here is the step that asks DocsParse to parse a document, placed after an upload in most scenarios. The name marks it as asynchronous, so treat it as starting the job.

When to use it
right after one of the upload modules, when the document is in DocsParse and ready to be read.
Watch out
the Make documentation does not describe how the result comes back, so check what the module returns with Run once before building on it.
DocsParse3

Upload a Document (File)

ActionIn the docs only

With this action, a file that another module produced lands in your DocsParse account, with no download or manual upload on your side. It is usually the second module of the scenario.

When to use it
your source app hands Make the file itself, such as an email attachment or a file from cloud storage.
Watch out
on the Free plan, Make handles files up to 5 MB, so larger scans need a paid plan.
DocsParse4

Upload a Document (URL)

ActionIn the docs only

Sending an address rather than a file, this module points DocsParse to a document that already sits online. As the name suggests, only the link travels through your scenario, not the file.

When to use it
the source only gives you a link, for example a form that stores uploads and returns their address.
Watch out
pick File or URL based on what the previous module outputs: a link where a file is expected, or the reverse, is the classic mapping mistake.
Need help

Need help automating DocsParse with Make?

A person reads every message.

FAQ

DocsParse and Make: common questions

01Is the DocsParse Make integration free?
Yes, on the Make side. DocsParse is a standard app, available from the Free plan. That plan allows 2 active scenarios, a scheduled run every 15 minutes at most often, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) bring the interval down to 1 minute and remove the cap on active scenarios. Your DocsParse subscription is separate: check the DocsParse pricing page for it.
02What do you need to connect DocsParse to Make?
An active DocsParse account and an API token. In DocsParse, go to Workflow, then Integrations, then API, click Generate token if needed and copy it. In Make, add a DocsParse module, click Create a connection, give it a name if you like, and paste the token. The connection is then shared by every DocsParse module you add later, in this scenario or any other. If the token ever changes in DocsParse, update the connection in Make once and every module picks up the new value.
03Can DocsParse start a Make scenario in real time?
No, because DocsParse has no trigger in Make. The scenario has to start elsewhere. You can open it with an instant trigger from another app, which calls Make through a webhook as soon as something happens, such as a new file. Or you can run it on a schedule set on the first module, every 15 minutes by default. Either way, the DocsParse modules come after that first step. Whichever start you choose, test the whole chain with Run once before you switch the scenario on.
04What if a DocsParse action is missing in Make?
Use Make an API Call. It reaches any endpoint of the DocsParse API with the connection you already created, so you are not limited to uploads and parsing. Keep in mind that the DocsParse documentation on Make is AI-generated and may contain mistakes; for anything important, confirm details in the DocsParse API documentation or with DocsParse directly before you rely on them in a scenario. Test the call with Run once and read the bundle it returns before mapping it into later modules.
05Should you use Make or n8n with DocsParse?
It depends on the tool your team already works in. DocsParse may also have an n8n node, so both routes can exist. In Make, you get 4 action modules, including Make an API Call for the rest of the API, and a visual editor where you test with Run once. Pick the platform where your other scenarios live, so connections and habits stay in one place. Both tools can call the DocsParse API, so the choice rests on your team and not on the app itself.
Same platform

Other docs you might need on this stack.

Browse all integrations