How to Connect Make (Integromat) to UniLink (Build Advanced Automations)
How to Connect Make (Integromat) to UniLink (Build Advanced Automations)
Use Make.com webhooks to build sophisticated multi-step automations that fire every time a visitor interacts with your UniLink page.
- Copy your webhook URL from Dashboard → Integrations → Make, then paste it into a Make.com scenario as a Custom Webhook trigger.
- Make's visual scenario builder supports hundreds of apps and complex logic — far beyond what native integrations can do.
- Every form submission, new contact, or store purchase on your UniLink page can trigger a multi-step automated workflow in Make.
Make.com — formerly Integromat — is the automation platform of choice for users who need more than simple one-to-one app connections. Where Zapier moves data from A to B, Make can orchestrate A to B to C to D with conditional branches, iterators, error handlers, and data transformations along the way. Connecting it to UniLink via webhooks gives your page a direct line into one of the most capable automation platforms available, without writing a single line of code.
What Make Does
Make is a visual automation platform built around the concept of scenarios — flowcharts that connect apps and services through a drag-and-drop interface. Each scenario has a trigger (the event that starts the workflow) and a series of modules (actions that process, transform, and route data). Make supports over 1,500 app integrations and allows complex operations like looping through arrays, aggregating data, parsing text, and handling errors with custom retry logic.
When triggered by a UniLink webhook, Make receives the data from your page (form fields, order details, visitor information) and can do virtually anything with it: create records in a CRM, send personalized emails, post Slack notifications, update spreadsheets, generate PDFs, trigger SMS messages, push data to a database, and more — all in a single automated sequence that runs in seconds.
Make's pricing model (operations-based rather than task-based like Zapier) often makes it significantly more cost-effective for complex automations that involve many steps. A single lead captured on UniLink might trigger 8 Make modules — creating a CRM contact, sending a welcome email, notifying Slack, adding a task to Asana, tagging the contact in Mailchimp, and creating a calendar event — all counted as a single scenario run.
How to Get Started
- In the UniLink dashboard at app.unilink.us, go to Integrations and click the Make card (or use the generic Webhook integration). Click Generate Webhook URL and copy the URL provided.
- Log in to your Make.com account and click Create a new scenario. In the scenario builder, click the + to add the first module. Search for Webhooks and select Custom Webhook.
- In the Custom Webhook module, click Add to create a new webhook. Name it (e.g., "UniLink Form Submissions"), paste the UniLink webhook URL into the Webhook URL field, and save.
- Click Run Once in Make to put the scenario in listening mode. Then go to your live UniLink page and submit a test form. Make will capture the payload and display the data structure — you can now reference specific fields (name, email, message) in subsequent modules.
- Add your action modules after the trigger — for example: Google Sheets (add row), Gmail (send email), HubSpot (create contact). Connect each module, map the incoming UniLink data to the correct fields, and click Activate to go live.
How to Use Make
- For a lead nurture workflow, trigger a Make scenario when a visitor submits a contact form on UniLink. Have Make create a contact in HubSpot, add them to a Mailchimp sequence, and send a personalized welcome email via Gmail — all three steps in one scenario activated by a single form submission.
- For e-commerce order processing, trigger Make on a new UniLink store purchase. Have Make create an order in Airtable, generate an invoice PDF via a document service, and email it to the buyer automatically — no manual processing required.
- Use Make's Filter module after the webhook trigger to route different form submissions to different workflows. Submissions with "Service = Coaching" go to one pipeline; submissions with "Service = Course" go to another. One UniLink page, multiple intelligent workflows.
- Use Make's Iterator and Aggregator modules for batch processing. If UniLink sends an array of product items in an order, Make can loop through each item, look up the SKU in your inventory system, and update stock levels one by one.
- Build an error-handling route in Make that catches webhook failures. If a downstream module (e.g., a CRM API) is unavailable, Make can store the failed data in Google Sheets and send you a Slack alert so no lead is lost even when external services have downtime.
Key Settings
| Setting | What It Does | Recommended |
|---|---|---|
| Webhook URL | The unique endpoint UniLink sends data to when a trigger event occurs | Generate a unique URL per trigger type (forms, orders) to keep scenarios organized |
| Data Structure (Make) | Tells Make the shape of incoming webhook data for field mapping | Run a test submission to auto-determine the structure before building downstream modules |
| Scenario Schedule | Controls whether the scenario runs instantly (webhook) or on a timer | Use webhook-triggered (instant) for form and purchase events; scheduled for daily digests |
| Error Handler | Defines what happens when a module fails mid-scenario | Always add an error route that captures failed data to a Google Sheet or sends a Slack alert |
| Operations Budget (Make) | Monthly cap on Make operations to prevent unexpected billing | Set a soft limit in Make account settings; monitor usage weekly during initial rollout |
Get the Most Out Of Make
Make's real advantage over simpler automation tools is its data manipulation capabilities. Before passing incoming UniLink data to downstream apps, you can parse it, transform it, format dates, split strings, concatenate fields, and perform math operations using Make's built-in functions. This means the data arriving in your CRM or spreadsheet is clean and structured exactly as you need it, not whatever raw format UniLink sends.
Use Make's Subflow feature to build reusable automation components. If you have a "create contact + send welcome email" sequence that should run across multiple scenarios (new form submission, new store purchase, new booking), build it once as a Subflow and call it from each parent scenario. When you need to update the welcome email, you change one Subflow and all scenarios update automatically.
For agencies managing UniLink pages for multiple clients, Make's team workspaces allow you to share scenarios across clients while maintaining access controls. Build a standard "UniLink → CRM" template scenario and clone it for each new client, updating only the webhook URL and destination credentials. This dramatically reduces the setup time for new client onboarding.
Combine Make with UniLink's analytics events — not just form submissions, but also click events on specific links — to build sophisticated engagement scoring systems. Every time a visitor clicks your pricing link, Make can increment a score in your CRM. When that score reaches a threshold, Make automatically assigns the contact to a sales rep and sends a personalized outreach email. This is the kind of pipeline automation that normally requires enterprise marketing software.
Troubleshooting
| Problem | Cause | Fix |
|---|---|---|
| Make scenario does not trigger when form is submitted | Webhook URL in UniLink does not match the webhook created in Make, or the scenario is inactive | Verify the URLs match exactly, ensure the Make scenario is Activated (not just saved), and check Make's History for incoming events |
| Field mapping shows empty or "undefined" values | Data structure was not captured before building modules, so field names are unknown to Make | Delete the scenario modules after the trigger, click Run Once, submit a test form, then rebuild modules using the captured data structure |
| Scenario runs but downstream app shows no data | Module credentials expired or field mapping points to a wrong key | Re-authenticate the affected module, check the scenario run History for error details, and verify field names in the mapping |
| Duplicate records created in CRM or spreadsheet | Test submissions fired multiple times, or the scenario lacks a deduplication check | Add a Search module before the Create module to check if a record already exists; only create if not found |
- Visual scenario builder supports complex logic — filters, iterators, routers, error handlers — without any code
- Operations-based pricing makes complex multi-step automations more cost-effective than Zapier for high-volume use
- 1,500+ app integrations cover virtually any tool in a modern business stack
- Make History provides detailed run logs for every scenario, making debugging fast and precise
- Make's interface has a steeper learning curve than simpler automation tools — first-time users may need 30–60 minutes to build a first scenario
- Free Make plan is limited to 1,000 operations per month, which depletes quickly with complex scenarios
- Webhook-based integration means setup requires both UniLink configuration and Make scenario building — two interfaces to manage
Frequently Asked Questions
What is the difference between using Make and Zapier with UniLink?
Both use webhooks to receive UniLink events. Make excels at complex, multi-step workflows with data transformation, conditional routing, and error handling. Zapier is simpler and faster to set up for straightforward one-to-one integrations. For automations with more than two or three steps or with conditional logic, Make is typically more powerful and cost-effective.
Do I need a paid Make plan to connect to UniLink?
Make's free plan supports webhooks and up to 1,000 operations per month, which is sufficient for testing and low-volume use. For production use with regular submissions or complex multi-module scenarios, the Core plan ($9/month for 10,000 operations) is usually adequate.
What data does UniLink send in the webhook payload?
UniLink sends a JSON payload containing all form fields submitted by the visitor, a timestamp, the page URL, and any configured metadata (like UTM parameters). The exact structure depends on which blocks triggered the webhook. Run a test submission and inspect Make's incoming data to see the full payload for your specific setup.
Can I have multiple Make scenarios triggered by the same UniLink page?
Yes. You can generate multiple webhook URLs in UniLink and configure each to fire on different trigger events — one for form submissions, one for store purchases, one for specific link clicks. Each webhook URL connects to a separate Make scenario with its own workflow logic.
Is there a way to test the Make integration without publishing my page?
Yes. In UniLink, use the Test Webhook button in the integration settings to send a sample payload to Make without needing live visitor traffic. In Make, put the scenario in Run Once mode before clicking Test Webhook — Make will capture the test payload and you can build your scenario on it.
- Copy the webhook URL from Dashboard → Integrations → Make and paste it into a Make Custom Webhook trigger to connect.
- Run a test submission first to capture the data structure before building downstream modules in Make.
- Add an error handler route to every production scenario so failed runs do not silently lose lead data.
- Use Make's Filter module to route different UniLink events (different forms, different pages) to different workflows.
- Make's operations-based pricing makes it more cost-effective than Zapier for automations with many steps per trigger.
Ready to build powerful automations with Make and UniLink? Open your dashboard, navigate to Integrations, and grab your webhook URL. Not on UniLink yet? Sign up free and start connecting your stack today.
Create Your Free Link-in-Bio Page
Join thousands of creators using UniLink. 40+ blocks, analytics, e-commerce, and AI tools — all free.
Get Started Free