Rename and Organize Files Using Make.com

Overview

You have a folder full of invoices with meaningless filenames - numbered exports from an old AP system, scanned documents, or bulk file dumps - and you need to rename and organize them based on their contents. This guide shows how to set that up with DocuPipe and Make.com, without writing any code.

Here's what the end result looks like: you drop invoice PDFs into a Google Drive folder, and they automatically appear in an output folder, renamed and sorted into vendor subfolders:

📁 Invoices - Input/
   invoice_001.pdf
   invoice_002.pdf
   invoice_003.pdf

📁 Invoices - Output/
   📁 Acme Corp/
      Acme_Corp_INV-4821_2024-03-15.pdf
   📁 Summit Supply/
      Summit_Supply_INV-1092_2024-02-28.pdf
   📁 Riverdale Services/
      Riverdale_Services_INV-7734_2024-04-01.pdf

This requires two Make.com scenarios working together:

1. DocuPipe Listener - watches the input folder for new files, uploads each one to DocuPipe for extraction
2. DocuPipe Router - receives extraction results via webhook, downloads the original file from DocuPipe, and saves a renamed copy into the correct vendor subfolder

[screenshot: Make.com scenarios dashboard showing both "DocuPipe Listener" and "DocuPipe Router" scenarios]

📘

This guide uses invoices and vendor names as the example, but the same approach works for any document type. Swap in whatever fields make sense for your use case - contract parties, patient names, tax form types, etc.

Prerequisites

Before starting, make sure you have:

• A DocuPipe account with an API key (from Settings > General)
• A Schema configured for your invoices with the fields you'll use for naming - at minimum vendorName, invoiceNumber, and invoiceDate. Follow the Quick Start if you haven't set one up yet.
• A Make.com account - the free tier works for testing, but large batches will need a paid plan
• Two Google Drive folders: one for input files (e.g., "Invoices - Input") and one for output (e.g., "Invoices - Output")

👍

Test your schema on a few sample invoices first using the DocuPipe dashboard. Confirm the vendor name, invoice number, and date extract correctly before automating with Make.

Set up a DocuPipe Workflow

Instead of calling upload and extraction separately, create a workflow that handles both in one step. This way, every file uploaded through the Listener scenario is automatically extracted using your schema.

1. Go to the Workflows page in DocuPipe.
2. Click +WORKFLOW and select the standardize template.
3. Select your invoice schema.
4. Save the workflow and copy the Workflow ID - you'll need it when configuring the Listener scenario.

For more details on creating workflows, see Workflows Dashboard.

[screenshot: DocuPipe workflow page showing a saved workflow with the workflow ID visible]

Scenario 1: DocuPipe Listener

This scenario watches a Google Drive folder, downloads each new file, and uploads it to DocuPipe for processing.

[screenshot: the complete DocuPipe Listener scenario in Make.com showing all four modules connected: Google Drive Watch → Google Drive Download → filter → DocuPipe Upload]

Step 1: create a new scenario

1. Log in to Make.com.
2. In the left sidebar, click Scenarios.
3. Click the Create a new scenario button in the upper right.
4. You'll see an empty canvas with a single "+" icon in the center.

[screenshot: empty Make.com scenario canvas with the plus icon in the center]

Step 2: add the Google Drive watch module

1. Click the + icon on the canvas.
2. In the search bar, type Google Drive and select it.
3. From the list of triggers, choose Watch files in a folder.
4. Click Create a connection and sign in with your Google account. Grant Make.com access to your Google Drive.
5. Once connected, configure the module:
   • Choose a Drive: select My Drive (or whichever drive your folder is on)
   • Select the folder to watch: navigate to your input folder (e.g., "Invoices - Input")
   • Limit: leave at the default or set to 10 to process files in batches

[screenshot: Google Drive Watch Files module fully configured with the input folder selected]

Step 3: add the file download module

The watch module detects new files but doesn't download their contents. You need a second module for that.

1. Hover over the right edge of the Google Drive watch module until you see a + icon appear. Click it.
2. Search for Google Drive again and select Download a file.
3. It will automatically use the same Google Drive connection.
4. In the File ID field, click inside the text box. A panel of available variables will appear on the left. Select File ID from the Google Drive watch module (module 1).

[screenshot: Google Drive Download module with the File ID field mapped from the watch module]

Step 4: add a filter for PDFs only

If your input folder might contain non-PDF files, add a filter to skip them.

1. Click the dotted line connecting the download module to the next position.
2. A filter dialog will appear. Give it a label like PDFs Only.
3. Set the condition:
   • Field: select Name from the Google Drive watch module (module 1)
   • Operator: select Matches pattern (case insensitive)
   • Value: type .*\.pdf
4. Click OK.

[screenshot: filter configuration showing the PDF-only condition with the regex pattern]

📘

If all your files are PDFs, you can skip the filter. But it's good practice to have it - a stray spreadsheet or image won't break your automation.

Step 5: add the DocuPipe upload module

1. Click the + after the filter to add a new module.
2. Search for DocuPipe and select it.
3. Choose Make an API Call.
4. If this is your first time using the DocuPipe module, click Create a connection and paste your DocuPipe API key (from Settings > General).
5. Configure the module:
   • URL: /document
   • Method: POST
   • Body type: Raw
   • Content type: JSON (application/json)
   • Request content: paste the following JSON, replacing YOUR_WORKFLOW_ID with the workflow ID you copied earlier:

{
  "document": {
    "file": {
      "contents": "{{base64(2.data)}}"
    },
    "filename": "{{1.name}}",
    "fileExtension": "pdf",
    "fileType": "pdf"
  },
  "parseVersion": 3,
  "workflowId": "YOUR_WORKFLOW_ID"
}

In this JSON:

• {{base64(2.data)}} takes the downloaded file from module 2 and encodes it as base64
• {{1.name}} uses the original filename from the watch module
• workflowId tells DocuPipe to automatically run your extraction workflow after parsing

[screenshot: DocuPipe Make an API Call module fully configured with the URL, method, body type, and JSON request content]

Step 6: name and test the scenario

1. Click the scenario name at the top left (it will say something like "New scenario") and rename it to DocuPipe Listener.
2. Drop a test invoice PDF into your Google Drive input folder.
3. Click Run once at the bottom left of the canvas.
4. Wait for the scenario to execute. You should see green checkmarks on each module.
5. Verify the document appears in your DocuPipe dashboard.

[screenshot: successful DocuPipe Listener run showing green checkmarks on all modules]

Scenario 2: DocuPipe Router

This scenario receives extraction results via webhook, downloads the original file from DocuPipe, and saves it to the correct vendor subfolder with a new name.

[screenshot: the complete DocuPipe Router scenario showing all modules connected: Webhook → Set Variables → DocuPipe Download URL → HTTP Download → Google Drive Create Folder → Google Drive Upload]

Step 1: create the webhook trigger

1. Go back to the Make.com scenarios page and click Create a new scenario.
2. Click the + icon on the canvas.
3. Search for Webhooks and select Custom webhook.
4. Click Add to create a new webhook.
5. Give it a name like "DocuPipe Standardization Results".
6. Click Save.
7. A URL will appear - click Copy address to clipboard. You'll need this in the next step.

[screenshot: Custom webhook module showing the generated URL with the "Copy address to clipboard" button]

Step 2: register the webhook in DocuPipe

1. In DocuPipe, go to Settings and click Go to Webhooks Portal.
2. Click Add Endpoint.
3. Paste the Make.com webhook URL you just copied.
4. Under Message Filtering, subscribe to the standardization.processed.success event. This event fires every time DocuPipe finishes extracting data from a document.
5. Click Create.

[screenshot: DocuPipe webhook portal with the endpoint configured and standardization.processed.success event selected]

Step 3: test the webhook connection

1. Back in Make, click Run once so the scenario starts listening.
2. In the DocuPipe webhook portal, go to the Testing tab.
3. Select the standardization.processed.success event and click Send Example.
4. Confirm that Make receives the payload - you should see a green checkmark on the webhook module.

[screenshot: Make showing the successfully received test webhook payload]

🚧

After receiving the test payload, expand it in Make to examine the field structure. The extracted data lives under the data object. Note the exact field names from your schema - you'll use them in the next step.

Step 4: set variables for the filename and vendor folder

1. Click the + after the webhook module to add a new module.
2. Search for Tools and select Set multiple variables.
3. Add three variables:

Variable 1 - vendor folder name:

• Variable name: vendorFolder
• Variable value: {{1.data.vendorName}}

Variable 2 - new filename:

• Variable name: newFilename
• Variable value: {{replace(1.data.vendorName; " "; "_")}}_{{1.data.invoiceNumber}}_{{1.data.invoiceDate}}.pdf

Variable 3 - document ID:

• Variable name: documentId
• Variable value: {{1.documentId}}

The vendorFolder variable is used as-is for the subfolder name (e.g., "Acme Corp"). The newFilename replaces spaces with underscores for a clean filename (e.g., "Acme_Corp_INV-4821_2024-03-15.pdf").

[screenshot: Set multiple variables module with all three variables configured and the mapped expressions visible]

📘

The exact field paths depend on your schema. If your schema uses different field names (e.g., vendor instead of vendorName), adjust the variable mappings to match. Expand the webhook test payload from the previous step to see your actual field names.

Step 5: get the document download URL from DocuPipe

The webhook payload contains the extraction results but not the file itself. You need to call DocuPipe's download endpoint to get a URL for the original file.

1. Click the + to add another module.
2. Search for DocuPipe and select Make an API Call.
3. Use the same DocuPipe connection from the Listener scenario (or create a new one with your API key).
4. Configure the module:
   • URL: /document/{{4.documentId}}/download/original-url
   • Method: GET

This returns a response containing a presigned URL where the original file can be downloaded.

[screenshot: DocuPipe Make an API Call module configured with the download URL endpoint and the documentId variable mapped in the URL path]

Step 6: download the file

Now use the presigned URL from the previous step to actually download the file.

1. Click the + to add another module.
2. Search for HTTP and select Get a file.
3. In the URL field, map the download URL from the DocuPipe response. It will be in the response body - look for the url field under data (the exact path depends on how Make parses the response, e.g., {{5.data.url}}).
4. Leave all other settings at their defaults.

[screenshot: HTTP Get a file module with the URL field mapped from the DocuPipe download response]

Step 7: create the vendor subfolder in Google Drive

1. Click the + to add another module.
2. Search for Google Drive and select Create a folder.
3. Connect your Google account (same as the Listener scenario).
4. Configure the module:
   • Choose a Drive: My Drive
   • New folder location: navigate to your output folder (e.g., "Invoices - Output")
   • New folder name: map the vendorFolder variable (e.g., {{4.vendorFolder}})

[screenshot: Google Drive Create a Folder module with the output folder selected and the vendor folder name variable mapped]

📘

Google Drive won't create a duplicate if a folder with the same name already exists in the same location - so this module safely runs every time without creating extra folders. If it does return an error for an existing folder, add an error handler (click the small circle at the bottom of the module) and choose Resume to continue the scenario.

Step 8: upload the renamed file to the vendor subfolder

1. Click the + to add the final module.
2. Search for Google Drive and select Upload a file.
3. Configure the module:
   • Choose a Drive: My Drive
   • Select a folder: map the folder ID from the previous step's output (the "Create a folder" module returns the ID of the created or existing folder)
   • File name: map the newFilename variable (e.g., {{4.newFilename}})
   • Data: map the file data from the HTTP download module (module 6)

[screenshot: Google Drive Upload a File module with the folder ID from the create folder step, the newFilename variable, and the file data from the HTTP module all mapped]

Step 9: name and test end-to-end

1. Rename this scenario to DocuPipe Router.
2. Open both scenarios in separate browser tabs.
3. Click Run once on the DocuPipe Router first (so the webhook is listening).
4. Then click Run once on the DocuPipe Listener.
5. Drop a test invoice into the Google Drive input folder.
6. Wait for both scenarios to complete. The Listener will upload the file to DocuPipe, DocuPipe will extract the data and fire the webhook, and the Router will download the file and save it to the output folder.
7. Check your output folder - you should see a vendor subfolder with the renamed invoice inside.

[screenshot: Google Drive output folder showing a vendor subfolder (e.g., "Acme Corp") containing the renamed invoice file]

Activate both scenarios

Once you've verified the end-to-end flow:

1. DocuPipe Listener: click the toggle at the bottom left to turn on scheduling. Set the interval (e.g., every 15 minutes) to control how often it checks for new files.
2. DocuPipe Router: toggle it to Active. Since it uses a webhook trigger, it runs instantly whenever DocuPipe sends results - no polling needed.

From this point on, any file dropped into the input folder will be automatically extracted, renamed, and organized into vendor subfolders.

[screenshot: both scenarios shown as active in the Make.com scenarios dashboard]

Scaling to large batches

For large projects (thousands of files), keep these things in mind:

• Make.com operations: the free plan allows 1,000 operations per month. Each file uses roughly 4 operations on the Listener side and 5 on the Router side, so 10,000 files will need a paid Make plan.
• DocuPipe credits: each file costs about 3 credits per page (1 for parsing + 2 for extraction). For 10,000 single-page invoices, that's roughly 30,000 credits. The Premium plan ($499/month) includes 20,000 credits - two months would cover the full batch. See Credits and Billing for plan details.
• Rate limits: DocuPipe handles concurrent processing well, but very large bursts may hit rate limits. Dropping files into the input folder in batches of a few hundred at a time keeps things smooth.

👍

For a one-time project, subscribe to the plan that fits your volume, run the batch, then cancel when you're done.

Customizing the filename pattern

The filename and folder structure are entirely up to you. Adjust the variables in the Router scenario's "Set multiple variables" module to match your needs.

Here are some examples for different document types:

Use Make's built-in text functions to clean up values:

• replace(value; " "; "_") - replace spaces with underscores
• lower(value) - convert to lowercase
• trim(value) - remove leading/trailing whitespace
• substring(value; 0; 50) - truncate long values

Where to go next

• No Code Integration Using Make.com - the full Make.com integration guide, covering additional scenarios like classification workflows and email routing
• Document Extraction Quick Start - set up your schema and test extraction from the dashboard
• Credits and Billing - understand how credits work for planning your batch size