How to Dynamically Upload Multiple Files to HighLevel Custom Fields Using Make.com
Struggling to get multiple files from texts, forms, or emails into HighLevel custom fields? Manual uploads waste hours and create errors. This Make.com workflow automates the entire process - handling dynamic file arrays, preserving original formats, and integrating with any source system.
The File Upload Challenge
Businesses receiving multiple files through various channels (text messages, web forms, email attachments) face a tedious manual process to get these files into HighLevel custom fields. Each upload requires navigating interfaces, renaming files, and ensuring proper field assignment - consuming valuable time that could be spent on revenue-generating activities.
The breakthrough comes when you realize Make.com can automate this entire process. By treating file uploads as data workflows rather than manual tasks, you eliminate the bottlenecks holding back your team's productivity.
Time savings: What takes 15-20 minutes per batch manually becomes a 30-second automated process that runs while you focus on higher-value work.
Workflow Overview
This Make.com workflow solves the multi-file upload challenge through four key stages that handle everything from dynamic file arrays to proper HighLevel integration. The process maintains data integrity while being flexible enough to work with files from any source system.
At 2:15 in the video tutorial, you'll see how the workflow begins with a simulated MMS message containing multiple image URLs. This demonstrates the pattern that works equally well for files from webhooks, forms, or other triggers.
- Process file arrays: Iterate through dynamic lists of file URLs
- Download files: Retrieve each file's binary data
- Prepare metadata: Generate proper filenames and preserve extensions
- Upload to HighLevel: Send files to the correct custom field
Step 1: Processing File Arrays
The workflow begins by receiving an array of file URLs from your trigger source. This could be multiple images from a text message (MMS), document attachments from a form submission, or files from a cloud storage service.
Make.com's iterator module processes each file URL separately while maintaining the relationship to the original contact or record. At 3:30 in the video, you'll see how the iterator creates separate bundles for each file while preserving the context of which contact they belong to.
Key configuration: Ensure your iterator sources from the correct array in your trigger payload. The example uses images array but yours might be attachments or files depending on the source.
Step 2: Downloading Files
Each file URL from the array needs to be downloaded to access its binary data for upload to HighLevel. Make.com's HTTP module handles this with a simple GET request to each URL.
The critical insight here is that Make.com now combines file downloading into its standard HTTP module (shown at 4:10 in the video). You don't need a separate "Get File" module - just configure a GET request and Make.com will automatically return the binary data needed for upload.
Pro tip: For temporary URLs that expire quickly, add a delay module right after your trigger to ensure files are downloaded while still accessible.
Step 3: Preparing File Metadata
HighLevel requires specific metadata for each file upload, including a filename and the custom field ID. This step ensures each file is properly identified and routed in your CRM.
The workflow demonstrates two clever techniques at 5:45 in the video: First, generating sequential filenames (file-1, file-2) when no natural names exist, and second, dynamically preserving the original file extension by splitting the URL at the last dot.
- Set base filename (e.g., "file-[bundle order position]")
- Extract file extension from URL (everything after last dot)
- Combine for complete filename (e.g., "file-1.jpg")
- Map custom field ID from HighLevel settings
Step 4: Uploading to HighLevel
With files downloaded and metadata prepared, the workflow uses the GHL Grow Tools connector to upload files to the specified HighLevel custom field. The array aggregator combines all processed files into a single payload for efficient upload.
At 7:20 in the video, you'll see the critical configuration detail: The array aggregator must source from the iterator (not the initial trigger) and target the GHL upload file structure. This ensures each file is processed exactly once and formatted correctly for HighLevel's API.
Verification: The tutorial shows checking the contact record at 8:30 to confirm both files uploaded successfully with their proper names and formats intact.
HighLevel Configuration
For this workflow to succeed, your HighLevel custom field must be properly configured to accept multiple files. At 9:10 in the video, you'll see the essential settings that must be enabled before running the workflow.
Navigate to Settings → Custom Fields and edit your target field. Enable "Allow multiple files" and set your preferred maximum count. You can also restrict file types if needed (e.g., only images or only PDFs). These settings ensure the API will accept your automated uploads.
Remember: Without enabling multiple files in HighLevel settings, your uploads will fail regardless of how perfect your Make.com workflow is configured.
Watch the Full Tutorial
See the complete workflow in action from start to finish, including the critical configuration details that make it work reliably. The video demonstrates each step with clear explanations of the "why" behind key decisions.
Key Takeaways
Automating multi-file uploads to HighLevel eliminates a major operational bottleneck for businesses dealing with documents, images, or other files from customers and team members. This workflow demonstrates how to handle dynamic file arrays while preserving original formats and proper field assignment.
In summary: Configure HighLevel for multiple files, process arrays with Make.com iterators, download files via HTTP GET, prepare metadata including dynamic filenames, and upload via GHL Grow Tools connector. The result is a seamless automated pipeline for all your file upload needs.
Frequently Asked Questions
Common questions about this topic
This Make.com workflow supports uploading any file type that HighLevel allows, including JPEG, PNG, GIF, PDF, and more. The system automatically preserves the original file extension during upload.
You can configure file type restrictions in HighLevel's custom field settings if needed. For example, you might limit a field to only accept images or only PDF documents depending on your business requirements.
- Works with all common image, document, and media formats
- Preserves original file extensions automatically
- File type restrictions can be set in HighLevel settings
The workflow is source-agnostic - it can process files from text messages (MMS), web forms, email attachments, or any system that provides file URLs. The key requirement is that the files are accessible via URL so Make.com can download them before uploading to HighLevel.
In the tutorial example, we simulated an MMS message with image URLs, but the same pattern works for files from Google Drive, Dropbox, form submissions, or other sources. The workflow focuses on processing the file URLs regardless of their origin.
- Handles files from any source providing accessible URLs
- Common sources include MMS, forms, email, cloud storage
- Only requirement is files must be downloadable via URL
The HighLevel custom field must be configured to accept multiple files in its settings. If not enabled, the uploads will fail. You can check and modify this setting under Settings > Custom Fields by editing the specific field and enabling the 'Allow multiple files' option.
When configuring a new custom field for file uploads, be sure to set both the "Allow multiple files" option and your preferred maximum number of files. These settings ensure HighLevel's API will accept your automated multi-file uploads.
- Field must have "Allow multiple files" enabled
- Configure in Settings > Custom Fields
- Set maximum files if desired
Yes, the workflow includes flexible file naming options. You can use simple sequential names (file-1, file-2) or incorporate data from the source payload like customer names or dates. The tutorial shows how to dynamically preserve original file extensions while customizing the base name.
For example, you might create filenames like "invoice-[customerID]-[date].pdf" or "property-[address]-photo-[number].jpg" by combining data from your workflow triggers with the sequential numbering system.
- Supports sequential names (file-1, file-2)
- Can incorporate data from trigger payload
- Preserves original file extensions automatically
Make.com can process dozens of files in a single workflow run, limited primarily by HighLevel's custom field settings which allow you to set a maximum files per field. Performance is best with batches of 10-20 files, but the workflow can handle larger sets with proper error handling.
For very large batches (50+ files), consider breaking them into smaller groups or adding delays between processing chunks to avoid timeouts or rate limiting from HighLevel's API.
- Limited by HighLevel's max files per field setting
- Optimal performance with 10-20 file batches
- Larger batches possible with added error handling
For time-sensitive URLs (like temporary cloud storage links), we recommend adding a delay module to immediately download files when the workflow triggers. Alternatively, you can implement error handling to notify you if downloads fail so you can manually intervene.
Some systems provide webhooks when new files arrive - configuring these to trigger your workflow immediately helps ensure files are processed while URLs are still valid. You might also consider copying files to permanent storage as part of the workflow.
- Add delay module for immediate processing
- Implement error notifications for failed downloads
- Consider permanent storage for critical files
Yes, you'll need API access to HighLevel and the appropriate permissions to modify custom fields. The workflow uses the GHL Grow Tools connector for Make.com, which requires installation and configuration with your HighLevel API credentials.
Ensure your HighLevel user account has permissions to manage custom fields and that your API credentials (used in the GHL Grow Tools connector) have not expired. These are the only special requirements beyond normal Make.com access.
- Requires HighLevel API access
- Needs permissions to manage custom fields
- Uses GHL Grow Tools connector for Make.com
GrowwStacks specializes in building custom automation workflows for HighLevel users. We can implement this multi-file upload solution tailored to your specific sources and requirements, add error handling, and integrate it with your existing systems.
Our team handles all the technical setup including connector configuration, workflow design, and testing. We'll ensure the solution works seamlessly with your file sources and HighLevel implementation so you can focus on your business.
- Custom workflow design for your specific needs
- Full implementation and testing
- Integration with your existing systems
Automate Your HighLevel File Uploads Today
Stop wasting time manually uploading files to HighLevel. Let GrowwStacks build you a custom automation that handles multiple files from any source - perfectly formatted and uploaded to the right custom fields automatically.