What does a Make.com website integration do?
Make is a visual automation platform: you build scenarios out of modules, where a trigger starts the run and each module after it does one job, such as creating a CRM contact or posting to Slack. On a marketing site, the trigger is usually a form submission, and the scenario decides what happens to that lead next.
- Lead routing: a demo request creates a contact in HubSpot, Salesforce or Pipedrive and notifies the right rep in Slack.
- Enrichment: the company domain is looked up in an enrichment tool before the lead reaches sales.
- Branching: enterprise leads, partners and job applicants each follow a different path through a router.
- Follow-up: a confirmation email, a spreadsheet row for the team or a task in your project tool.
- Content operations: new CMS items, form-driven listings or scheduled updates on Webflow.
Make suits teams whose workflows have branches and data cleanup, because routers, filters and functions are built into the scenario editor. If your workflow is one form to one tool, a native integration or a simpler tool may be enough. Our comparison of Zapier vs Make for website form workflows and our Zapier integration page cover that choice.
How do you connect Make to Webflow, Framer and Next.js?
The most dependable connection on all three platforms is a webhook: the site sends each submission to a Make custom webhook URL, and the scenario starts instantly. Webflow also has an app inside Make, and each platform handles the details differently.
Task | Webflow | Framer | Next.js |
|---|---|---|---|
Send form data to Make | Make's Webflow app, or a Webflow form webhook pointed at a Make custom webhook | Form Send To set to Webhook, with the Make URL | A server route that validates the form and posts to Make |
Payload | Webflow's form fields and site details | JSON with your form input names as keys | Whatever you define |
Hidden fields for UTMs | Hidden inputs filled by a small script | Hidden inputs filled by a code component | Read from cookies or the URL on the server |
Spam protection | Webflow's form spam settings | Framer's form spam settings | Your own checks before Make runs |
Keep the webhook URL private | Stored in Webflow or Make, not in page code | Stored in Framer's form settings | Kept in a server environment variable |
Framer's help article on connecting Framer forms to a webhook says submissions arrive as JSON, can be signed with a secret, and are retried up to 5 times if your endpoint doesn't return a success status. On Next.js we post from the server so the webhook URL never reaches the browser, as in our guide to forms and integrations on Next.js. Platform options change, so we check the current Make, Webflow and Framer docs at the start of each project.
What makes a Make scenario reliable enough for leads?
A lead scenario is reliable when a failure is noticed and recovered, not when it never fails. APIs time out, CRM fields change and tokens expire, so the design has to assume a run will break at some point.
- Filters right after the trigger: spam, test submissions and empty fields stop before they reach your CRM.
- Error handler routes: a failed CRM step retries or falls back, instead of silently stopping the run.
- Incomplete executions: Make can store failed runs so you can fix the cause and resume them, which we turn on for lead scenarios.
- Alerts: a Slack or email message to a named person when a scenario errors.
- A backup copy: every submission also saved to the form platform or a sheet, so nothing depends on one scenario.
- Naming and notes: scenarios and modules named after what they do, so the next person can change them safely.
How do you keep attribution when leads pass through Make?
Attribution survives only if the site captures it and the scenario maps it. The form needs hidden fields for UTMs, the landing page and the referrer, and the Make scenario has to write each one to a matching CRM property.
We store UTMs when the visitor arrives, because they're often lost by the time someone reaches the demo page, and send them with every submission. Our guide to UTM parameters in Framer and Webflow forms shows the pattern, and connecting website analytics to your CRM covers reporting. If HubSpot is your CRM, its own forms integration can be simpler than Make for the first step, which our HubSpot integration page explains.
Hypothetical example: one demo form, three destinations
For example, suppose a Series A startup has one demo form on a Framer site. The form posts to a Make webhook. A filter drops submissions with free email domains into a separate low-priority path. A router then sends enterprise-sized companies to the account executive's Slack channel and everyone else to a round-robin queue, while every lead is created in the CRM with its UTMs. An error handler alerts the RevOps lead if the CRM step fails. This illustrates the design, not a measured result.
When should you use Make, and when not?
Use Make when the workflow after a form has real logic and several tools. Skip it when a native integration already does the job, or when the workflow is business-critical enough to belong in your own code.
Pros
- Routers, filters and data functions handle branching without code
- Instant webhook triggers from Webflow, Framer and Next.js
- Visual scenarios that non-developers can read and adjust
- Error handlers and stored incomplete runs for recovery
Cons
- Usage-based billing grows with every run and module, so check Make's current pricing
- Another vendor that holds personal data, so it belongs in your privacy policy
- Scenarios built without notes become hard to change later
- Complex, high-volume logic is often cleaner as a server route in Next.js
How do we set up Make on your site, and what does it cost?
Map the workflow
We agree what happens after each form, who gets notified and which CRM fields each one sets.
Build the forms
Forms are designed into the page with hidden fields for source data and spam protection.
Build the scenarios
Webhooks, filters, routers and CRM modules in Make, named and annotated.
Add failure handling
Error routes, stored incomplete runs, alerts and a backup copy of every submission.
Test every path
Real submissions through each branch, checked in the CRM and Slack, then a short guide for your team.
Make setup fits into our website package, $8,000 fixed for up to six pages with copy, design and the build. If your workflows change every month, our $6,000 monthly retainer covers ongoing changes, and our Webflow development page explains how we build on Webflow. Your Make plan is billed by Make. The next step is a free 30-minute call.
















