No Code Integration Using Make.com

Overview

DocuPipe exposes a full API so you can orchestrate document flows from any programming language. When you prefer a visual builder, the DocuPipe app in Make gives you a module for each step: upload a document, standardize it, classify it, split it, run a Workflow, and start a scenario when any of these finishes. This guide shows how to connect Make to your DocuPipe account, what each module does, and two complete examples.

Before you start, create at least one Schema. Follow the Document Extraction Quick Start to define the fields Make will map into each scenario.

Connect Make to DocuPipe

1. Retrieve your DocuPipe API key from Settings → General.
2. Create a Make account (or sign in) and choose Create a new scenario.
3. In the canvas, click the plus sign, search for "DocuPipe", and pick a module.
4. When prompted for a connection, select Add and paste your API key to create a reusable credential. Every DocuPipe module uses the same connection.

Make immediately validates the key. Use the error diagnostic below to double-check the token if the connection fails.

The DocuPipe modules

Actions

Triggers

The triggers register their own webhook with DocuPipe when you create them in Make, so you don't need to visit the webhook portal.

Waiting for results

Standardize a document, Upload and standardize and Split a document have a Wait for the result option. When it's on, the module waits for DocuPipe to finish and returns the result in the same run. If the result isn't ready in time, the module still succeeds: it returns the IDs with status processing, and the matching Watch trigger picks the result up when it's done.

For anything that runs unattended, we recommend two scenarios: one that submits documents, and one that starts from a Watch trigger and writes the results. Long documents and busy periods then never leave a result behind.

Mapping extracted fields

When you pick a schema in Standardize a document or Upload and standardize, the schema's fields show up in Make's mapping panel, so you can map invoiceNumber or total straight into the next module. Get a standardization and Watch standardizations have a Schema (for mapping) setting that does the same when the standardization ID comes from an earlier step.

To pass the whole result to another app (for example an HTTP module or a database), turn on Include data as JSON text. The module then adds the extracted data as a single JSON text field.

Example: Invoices from Google Drive into Google Sheets

This example extracts every invoice dropped into a Google Drive folder and adds one row per invoice to a Google Sheet. It uses two scenarios: the first uploads, the second writes the rows.

Scenario 1: upload new files

1. Add Google Drive → Watch files in a folder and select the folder to monitor.
2. Add Google Drive → Download a file and map the file ID from the watch module.
3. Add DocuPipe → Upload and standardize:
   • Source: File. Map the file name and data from the download module.
   • Schema: your invoice schema.
   • Metadata: add a key such as driveFileId with the Google Drive file ID. It comes back with the result, so you can tell which file each row came from.
   • Wait for the result: off. Scenario 2 handles the results.

Scenario 2: write the results

1. Start a new scenario with DocuPipe → Watch standardizations. Create a webhook for it and set:
   • Only this schema: your invoice schema, so standardizations of other schemas don't start this scenario.
   • Schema (for mapping): the same schema, so its fields appear in the mapping panel.
2. Add Google Sheets → Add a row and map the extracted fields (invoice number, date, vendor, total) and the driveFileId metadata into the columns.
3. Turn the scenario on.

Turn on scenario 1 as well. Drop an invoice into the folder, and a row appears in the sheet once the standardization finishes.

Example: Run a workflow

To send each file through a Workflow you built in the dashboard or in Architect (for example classify, then standardize each class with its own schema):

1. Add DocuPipe → Run a workflow after the module that provides the file, and pick the workflow from the dropdown.
2. For an Architect workflow, the module returns the run's job ID. Read the outputs with Get a job, or start a second scenario with Watch workflows, which fires when the run finishes.
3. For a classic workflow, use the Watch trigger for the step you care about, for example Watch standardizations for a classify-then-standardize workflow.

Workflows with more than one input, or a document stack input, aren't listed in Run a workflow. Call them with Make an API call.

Using Make an API call

Make an API call sends any request to the DocuPipe API, with the body written by hand. The two examples below use it with the DocuPipe webhook portal instead of the dedicated modules, which is useful when you want full control over every request parameter.

Example: Parsing a PDF from Google Drive and email the text

This example uses two Make scenarios: one watches a Google Drive folder and uploads PDFs to DocuPipe, and the other waits for DocuPipe webhooks so it can email the Parsing output.

Add the Google Drive import

1. Add a DocuPipe Make an API call module, then click the plus icon beneath it to add another module.

2. Search for Google Drive and select Watch files in a folder.

3. Position the new module before DocuPipe to reflect the data flow, then open it to set up the Google Drive connection.

4. Select the folder you want to monitor for new files.

5. Add a second Google Drive module to download each file, and choose Download a file.

6. Map the file ID from the watch module into the download module.

7. Connect the download module to DocuPipe and add a filter so only PDF files continue.

Set up the DocuPipe upload

Use a DocuPipe Make an API call module. Map the base64-encoded file contents and filename from the Google Drive modules into the document.file.contents and document.filename fields. The result is a self-contained upload request whenever a PDF lands in the folder.

Capture Parsing output with a webhook

1. In the same Make scenario, add another module and search for Webhook → Custom webhook. Choose Add, then Copy address to clipboard.

2. In DocuPipe, open Settings and click Go to Webhooks Portal.

3. Select Add Endpoint, paste the Make URL, and subscribe to the document.processed.success event.

4. Back in Make, click Run once so the scenario waits for the webhook callback.

5. From the webhook portal, use the Testing tab, choose document.processed.success, and click Send Example.

6. Confirm the Make scenario receives the sample payload.

Once the webhook is verified, every processed document will trigger downstream actions.

Email the extraction

Add an Email → Send an email module to the scenario.

Map the Parsing text from the webhook payload into the email body to deliver the result automatically.

Running both Make scenarios (upload and webhook) with Run once results in an end-to-end Parsing-to-email flow.

Example: Workflow with classification and standardization

This example extends the previous setup by invoking a DocuPipe workflow that classifies each document, optionally standardizes it, and emails the structured JSON. The workflow logic determines whether standardization runs.

Prepare the workflow

Create a workflow via the Dashboard, you can read how to do so on This Guide.

Choose the classify -> standardize template so every upload triggers Classification immediately after Parsing. After Classification completes, configure the workflow to run standardization when a target class is assigned. Note the resulting workflowId. We'll use our Make scenario to upload documents into this workflow by using this workflowId.

Add the Google Drive import

Reuse the watch and download modules from the previous example (or duplicate the Make scenario) so every new PDF in Google Drive becomes an input.

Configure the DocuPipe upload with the workflow

Add the workflow ID to the DocuPipe request body so the workflow executes automatically.

{
  "document": {
    "file": {
      "contents": "{{base64(6.data)}}"
    },
    "filename": "{{2.name}}",
    "fileExtension": "pdf",
    "fileType": "pdf"
  },
  "parseVersion": 3,
  "dataset": "Google Drive Test",
  "workflowId": "4c8eb679"
}

Webhook for standardization results

Create another Make scenario with a Custom webhook module to capture standardization.processed.success events and copy the generated URL.

Register that URL in the DocuPipe webhook portal and subscribe to standardization.processed.success.

Use Run once plus the webhook portal's Send Example action to confirm the payload reaches Make.

Email the structured output

Attach an Email → Send an email module to the webhook scenario and map the JSON body into the email.

Add an optional filter so only records from the intended dataset (for example, Google Drive Test) trigger the email.

Validate end-to-end

Open the upload and webhook scenarios in separate tabs, clear the Google Drive folder, add a PDF, and click Run once on both scenarios. You should receive an email containing the structured JSON emitted by the workflow.

Where to go next

These examples show how Make can orchestrate DocuPipe uploads, results and routing logic without code. Extend the blueprint by swapping Google Drive for Salesforce, ERPs, or any other connector, and route the resulting structured data to downstream systems once your DocuPipe workflow returns the fields defined in your Schema.