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 inside Make offers the same coverage without writing code. This guide shows how to connect Make to your DocuPipe account, automate a basic Google Drive ingestion, and extend it into a workflow that classifies documents and routes their results.

Before you start, ensure you already configured at least one Schema. Follow the Document Extraction Quick Start to define the schema elements that Make will eventually 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 choose Make an API Call. That module exposes every DocuPipe endpoint.

4. When prompted for a connection, select Add and paste your API key to create a reusable credential.

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

Once the connection succeeds, the module is ready for any DocuPipe request body.

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. Close the DocuPipe module window and 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

Keep the DocuPipe module configured as Make an API Call. 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 Workflows Dashboard. 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; the Make scenario will pass it with each upload.

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 two examples illustrate how Make can orchestrate DocuPipe uploads, webhooks, 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.