Upload Files in Make (Integromat): Get Permanent CDN URLs

Make (formerly Integromat) is one of the most flexible automation platforms available. Its visual scenario builder, powerful data mapping, and massive library of app integrations make it a go-to tool for teams automating complex workflows. But there is one gap that trips up almost everyone eventually: file hosting.

Make can download files, pass them between modules, transform them, and attach them to outgoing requests. What it cannot do is give you a permanent public URL for a file. Once your scenario finishes running, any binary data that was flowing through the modules is gone. If you need a link you can store in a database, send in a Slack message, or embed on a web page, you need an external file hosting service.

This guide shows you how to use FilePost with Make's HTTP module to upload files and get permanent CDN URLs, step by step. We will walk through the module configuration, two real-world example scenarios, and how to handle the API response in subsequent modules.

The Problem: Make Has No Built-In File Hosting

Make handles files as binary data that flows through your scenario. A trigger module might receive a file attachment from a form submission, a webhook, or an email. You can pass that binary data to the next module, and the next, and so on. But the data only exists during execution.

This creates problems in several common situations:

• Temporary download URLs. When Make downloads a file from another service (Google Drive, Dropbox, a webhook payload), the URL it used to download the file is often temporary. It might expire in minutes or hours. You cannot store that URL and expect it to work next week.
• No file output from processing. If you use a module to convert, resize, or transform a file, the result exists only as binary data in the scenario. There is no URL for it.
• No native storage module. Unlike some platforms that offer built-in file storage, Make does not have a "host this file" module. You always need an external service.
• Multi-step workflows need URLs. If your scenario branches after the file step, maybe sending a notification to Slack, updating a CRM record, and logging to a spreadsheet, each of those downstream modules needs a URL string, not raw binary data.

The result is that developers building file-heavy Make scenarios end up cobbling together workarounds. Some upload to Google Drive and create sharing links. Others push to S3 and construct URLs manually. These work, but they add complexity, require additional authentication setup, and often produce URLs that are not CDN-backed or truly permanent.

The Solution: FilePost HTTP Module

FilePost is a file upload API built specifically for this use case. You send a file, you get back a permanent CDN URL. No buckets to configure, no IAM roles, no sharing settings. One HTTP request, one permanent link.

Here is the API call in its simplest form:

curl -X POST https://filepost.dev/v1/upload \
  -H "X-API-Key: YOUR_API_KEY" \
  -F "file=@photo.jpg"

Response:

{
  "url": "https://cdn.filepost.dev/abc123/photo.jpg",
  "file_id": "abc123",
  "name": "photo.jpg",
  "size": 45321
}

That url is permanent. It is served from Cloudflare's global CDN, so it loads fast anywhere in the world. The file stays live until you explicitly delete it through the API or the FilePost dashboard. In Make, you replicate this exact call using the HTTP module, which is built into every Make account.

Step-by-Step: Upload Files in Make

Here is how to configure the HTTP module in Make to upload a file to FilePost and get back a CDN URL. This assumes you already have a preceding module that produces binary data (a trigger, a download step, or any module with a file output).

Step 1: Add the HTTP Module

In your scenario, click the + button after the module that produces the file. Search for HTTP and select Make a request. This is Make's general-purpose HTTP module that can call any REST API.

Step 2: Configure the Request

Set the following fields in the HTTP module configuration:

• URL: https://filepost.dev/v1/upload
• Method: POST
• Headers: Add one header with name X-API-Key and value set to your FilePost API key. You can store this in a Make variable or connection if you prefer not to hardcode it.

Step 3: Configure the Body

This is the most important part. The body needs to send the file as multipart form data:

1. Set Body type to Multipart/form-data
2. Click Add item under the fields list
3. Set Field name to file
4. Set Field type to File
5. For Source file, select Map
6. In the File name field, map the filename from the previous module (for example, {{1.fileName}} or {{1.name}} depending on the source module)
7. In the Data field, map the binary data from the previous module (for example, {{1.data}})

Step 4: Parse the Response

Set Parse response to Yes. This tells Make to parse the JSON response body so you can map individual fields in subsequent modules. Without this, you get the raw response string and have to parse it yourself.

After running the module, the output will contain the full FilePost response. You can access the CDN URL as {{X.data.url}} where X is the module number of your HTTP module.

Step 5: Test the Module

Right-click the HTTP module and click Run this module only to test it in isolation. If everything is configured correctly, you will see the FilePost JSON response with the permanent CDN URL, file ID, file name, and file size. Copy the URL and open it in a browser to verify the file is accessible.

Example Scenario 1: Form Submission to Permanent URL

This scenario takes file attachments from form submissions and converts them into permanent CDN URLs, then notifies your team.

The Use Case

You have a Typeform, Google Form, or JotForm that accepts file uploads. When someone submits the form with an attachment, you want the file hosted permanently and the URL sent to your team via email or Slack. You also want the submission data logged in a spreadsheet.

Scenario Modules

1. Trigger: Watch Form Responses. Use the Typeform, Google Forms, or JotForm module to watch for new submissions. When a submission includes a file, the trigger provides a temporary download URL for the attachment.
2. HTTP Module: Download the Attachment. Add an HTTP "Make a request" module. Set the URL to the temporary file URL from the trigger module. Set the method to GET. Under Advanced settings, set the response type to Binary so Make stores the downloaded file as binary data you can pass forward.
3. HTTP Module: Upload to FilePost. Add a second HTTP module configured as described in the step-by-step section above. Map the binary data and filename from the download module. The output gives you the permanent CDN URL.
4. Email / Slack Module. Add a Slack "Send a Message" module or an Email "Send an Email" module. In the message body, include the submitter's name, email, and the FilePost CDN URL: {{3.data.url}}. Your team gets notified instantly with a working link to the file.
5. Google Sheets: Log the Submission. Add a Google Sheets "Add a Row" module. Map the columns to the submitter's name, email, submission timestamp, and the permanent file URL. Now you have a complete log of every file submission with working links.

The entire scenario is five modules. Form submissions with file attachments get a permanent URL within seconds of being submitted.

Example Scenario 2: Webhook File Processing

This scenario handles incoming files from a custom webhook, uploads them to FilePost, and stores the URLs in Google Sheets for downstream use.

The Use Case

Your application sends a webhook to Make whenever a user uploads a file. The webhook payload includes the file data or a URL to the file. You need to host the file permanently, store the URL in a spreadsheet, and optionally notify someone.

Scenario Modules

1. Trigger: Custom Webhook. Create a Webhooks module with "Custom webhook" as the trigger. Make gives you a unique webhook URL to configure in your application. When your app fires the webhook, Make receives the payload.
2. HTTP Module: Download the File (if needed). If your webhook payload contains a file URL rather than raw file data, add an HTTP module to download the file. Set response type to Binary. If your webhook sends the file data directly in the payload, you can skip this step and map the binary data straight from the webhook trigger.
3. HTTP Module: Upload to FilePost. Configure the FilePost upload module as described earlier. Map the file data from the previous module.
4. Google Sheets: Store the URL. Add a row to your tracking spreadsheet. Map the file name, size, the permanent CDN URL from FilePost, and the timestamp. This spreadsheet becomes your file registry, every file uploaded through the webhook has a row with its permanent link.

This pattern works for any application that needs to offload file hosting. Your app handles the user-facing upload, fires a webhook, and Make takes care of hosting the file and logging the URL. You can extend it with additional modules to update your database via API, send notifications, or trigger further processing.

Working with FilePost Responses in Make

When the FilePost HTTP module runs successfully, it returns a JSON object with four fields. Here is how to use each one in your subsequent Make modules.

The Response Object

{
  "url": "https://cdn.filepost.dev/abc123/photo.jpg",
  "file_id": "abc123",
  "name": "photo.jpg",
  "size": 45321
}

Mapping Fields in Subsequent Modules

Assuming the FilePost HTTP module is module number 3 in your scenario, here is how you reference each field:

• {{3.data.url}}: The permanent CDN URL. This is the field you will use most often. Store it in a database, include it in a notification, embed it in an email, or pass it to any module that needs a file link.
• {{3.data.file_id}}: The unique file identifier. Use this if you need to manage the file later (delete it, look up its metadata, or build a reference for your own database).
• {{3.data.name}}: The original file name. Useful for display purposes in notifications, spreadsheet logs, or database records.
• {{3.data.size}}: The file size in bytes. You can use this for logging, validation, or displaying human-readable file sizes in notifications.

These fields work anywhere in Make that accepts mapped values: text fields, URL fields, JSON bodies, and filter conditions. The URL is a plain string, so there is no special formatting required.

Using the URL in a JSON Body

If a downstream module needs to send the URL as part of a JSON payload (for example, updating a record via a custom API), you can include it directly in the body:

{
  "attachment_url": "{{3.data.url}}",
  "file_name": "{{3.data.name}}",
  "uploaded_at": "{{now}}"
}

Tips for Production Scenarios

Once your basic upload scenario is working, here are the things to address before running it in production.

Error Handling with Routers

The FilePost HTTP module can fail if the API key is invalid, the file exceeds your plan's size limit, or there is a network issue. In production scenarios, you should handle these failures gracefully:

1. Add an error handler. Right-click the FilePost HTTP module and select Add error handler. This creates a separate path that executes only when the module fails.
2. Log the error. In the error handler path, add a Google Sheets or Slack module that logs the error message, the file name, and the timestamp. This way you know what failed and why.
3. Retry or alert. For transient errors (network timeouts), you can add a Retry directive. For permanent errors (file too large, invalid key), send an alert to your team so someone can investigate.

Make also supports the Break directive, which pauses the scenario execution and stores the incomplete data for manual retry. This is useful for scenarios where losing a file upload is unacceptable.

Rate Limits by Plan

FilePost applies rate limits based on your plan. If your Make scenario processes many files in a short burst, you may need to account for these limits:

All plans include permanent CDN URLs, unlimited storage, unlimited bandwidth, and full API access. The differences are upload volume and maximum file size per upload.

Choosing the Right Plan

For testing and low-volume scenarios (a few form submissions per day), the Free plan works fine. If your scenario runs frequently, say processing 20 files per day, you will hit the Free plan's 30 monthly uploads in two days. The Starter plan at $9/month gives you 500 uploads, which covers roughly 16 files per day. For high-volume scenarios like webhook-driven processing or batch file operations, the Pro plan at $29/month handles up to 5,000 uploads.

Storing Your API Key Securely

Rather than hardcoding your FilePost API key directly in the HTTP module, consider using Make's Data Stores or Variables feature to store the key. This way, if you need to rotate the key, you update it in one place instead of editing every scenario that uses FilePost.

Another option is to create a Make Connection of type "API Key Auth" and configure it with the header name X-API-Key. Then you can select this connection in the HTTP module instead of manually adding the header. This keeps the key encrypted in Make's credential store.

Handling Large Files

Make has its own execution limits depending on your Make plan. The default data transfer limit per scenario execution is 100 MB on most Make plans. If you are uploading files close to the FilePost limit (50-500 MB depending on plan), check your Make plan's data transfer allowance as well. Very large files may require a Make plan with higher operation and data limits.

FAQ

Does Make have built-in file hosting?

No. Make.com can pass binary data between modules within a scenario, but it does not host files or provide permanent URLs. Once a scenario finishes executing, any file data that was not explicitly stored in an external service is gone. To get a lasting URL for a file processed in Make, you need to upload it to an external file hosting API like FilePost.

How do I get a public URL for a file in Make?

Add an HTTP module to your Make scenario that sends a POST request to a file hosting API. With FilePost, you POST the file to https://filepost.dev/v1/upload with your API key in the X-API-Key header and the file as multipart form data. The response contains a permanent CDN URL you can use in any subsequent module.

Can I upload files from Make to a CDN?

Yes. Using the HTTP module in Make, you can upload files to FilePost which stores them on Backblaze B2 and serves them through Cloudflare CDN. The URL you get back is a permanent CDN link that loads fast globally. No additional CDN configuration is needed on your end.

What file size limits does FilePost have for Make uploads?

FilePost's file size limits depend on your plan: 50 MB on the Free plan (30 uploads/month), 200 MB on the Starter plan ($9/month, 500 uploads), and 500 MB on the Pro plan ($29/month, 5,000 uploads). Files uploaded from Make follow the same limits as files uploaded through any other method.