Make

Webflow handles site design, content management, and hosting. It does not handle the follow-up work that often needs to happen after a form submission arrives, a CMS item changes, or an order comes through. Routing that data to a CRM, email platform, project management tool, or spreadsheet usually means either manual work or a separate automation layer.

Make fills that gap with a visual scenario builder that connects directly to Webflow's API. Form submissions can trigger CRM contact creation. CMS item changes can push content to email campaigns, and ecommerce orders can start fulfillment workflows — all configured through Make's visual scenario builder. Make's native Webflow integration includes 40 modules covering triggers, actions, and searches across sites, collections, forms, products, orders, and comments.

This integration applies when site events need to trigger actions in external systems — routing form leads to a CRM, syncing CMS content to email platforms, processing ecommerce orders through fulfillment tools, or connecting comment threads to project management workflows.

How to integrate Make with Webflow

What is Make? Make is a visual workflow automation platform (formerly known as Integromat) that connects apps through drag-and-drop scenarios (Make's term for automated workflows). It supports 3,000+ app integrations with conditional branching, filters, and scheduled or instant triggers. Make's canvas-based builder renders automation logic graphically. Each step and data path is visible at a glance.

Teams use Make with Webflow when they need site events — form submissions, CMS changes, ecommerce transactions — to trigger actions in external tools automatically. Instead of manually exporting form data to a spreadsheet or copy-pasting CMS content into an email platform, a Make scenario handles the data transfer in real time. This is especially common for lead routing, content distribution, and order processing workflows.

The Make-Webflow integration supports 3 approaches:

• The Make app handles form automation, CMS synchronization, ecommerce workflows, and comment tracking through 40 native Webflow modules — configured visually.
• The webhooks via site settings method lets you send Webflow event data to Make scenarios by pasting a URL into your Webflow configuration.
• The Webflow and Make APIs give you control over custom endpoints, bulk operations, and advanced data transformations, but require server-side development.

Most implementations start with the Make app's native modules and add webhook or API methods as the workflow complexity grows.

Install the Make app

The Make app on the Webflow Marketplace is the fastest way to connect the two platforms — it handles authentication and module setup through the Marketplace install flow. It uses OAuth 2.0 authentication to grant Make access to your Webflow site data. The connection exposes 40 modules — 2 triggers, 26 actions, and 12 search modules — inside Make's scenario builder. The app is listed on the Webflow Apps directory and requires a Make account to configure.

To set up the integration:

1. Log in to your Make account, open or create a scenario, and click the + button to add a module.
2. Search for "Webflow" and select any Webflow module.
3. Click Create a Connection, optionally enter a name in the Connection name field, and click Save.
4. If prompted, log in to your Webflow account and confirm access. Make sure the "Forms data" scope is granted if you plan to use form triggers.
5. Configure the module settings for your use case.

The app covers these Webflow resources:

• Webflow CMS collections and items (create, update, publish, delete, list, search)
• Form submissions (watch, list, get, update)
• Ecommerce products, orders, and inventory (create, update, fulfill, refund)
• Site publishing, assets, pages, and comment threads

These resources cover the main Webflow workflows most teams automate first.

Once connected, you can chain Webflow modules with any of Make's 3,000+ app connectors. A common starting scenario uses the Watch Events trigger module, which acts as a webhook listener for Webflow events. It receives the full webhook payload and uses Make's Router or Filter modules to branch logic based on the event type. A single trigger can handle form submissions, CMS changes, and ecommerce events in one scenario.

Make also offers pre-built scenario templates for common Webflow workflows. These include routing Webflow form submissions to beehiiv or MailerLite subscribers, creating CMS items from RSS feeds, and syncing site updates to email notifications. Click any template on the Make integrations page to open it pre-configured in the scenario builder. Connect your accounts and activate.

One important behavior to note: creating or updating a CMS item through Make does not automatically make it visible on your live site. In CMS workflows, item publishing and site publishing are separate steps. A typical chain is Create or Update an Item → Publish an Item → Publish a Site so the changes appear publicly.

Connect Webflow to Make with webhooks

If you need more control over which events reach Make — or if you run into edge cases with the native Watch Events module — you can configure webhooks manually. This approach involves pasting a Make-generated URL into your Webflow site settings. No code beyond the URL itself is required.

Send site events via site settings webhooks

Webflow's site settings include a webhook configuration panel. You can register URLs that receive POST requests when specific events occur. This works for form submissions, CMS item changes, ecommerce orders, and site publish events.

To set up a site settings webhook:

1. In Make, create a new scenario and add a Webhooks module. Select Custom webhook and copy the generated URL.
2. In Webflow, open your site and go to Site settings > Integrations > Webhooks.
3. Paste the Make webhook URL into the Destination URL field.
4. Select the trigger event type (such as form submissions or CMS item changes) and save.
5. Back in Make, click Run once to put the scenario in listening mode. Then trigger the event in Webflow (submit a test form or update a CMS item) so Make can capture the payload structure.

After Make captures the first payload, it maps the data fields automatically. You can then add downstream modules to route that data to any connected app.

Send form data via the form action field

For form-specific webhooks, you can bypass site-level settings and configure individual forms to POST directly to Make.

To connect a form to Make:

1. Generate a Custom Webhook URL in Make (same process as above).
2. In Webflow, select the form element and open its settings panel.
3. Paste the Make webhook URL into the Form Action field and set the method to POST.
4. Publish the site and submit a test entry.

This method does not return a custom response to the page. Webflow's default form success message displays after submission. If you need dynamic confirmation messages, additional JavaScript is required.

Both webhook methods are useful when the native Watch Events module doesn't cover a specific edge case. They also help when you want to route individual forms to different Make scenarios without using a Router module inside Make.

Build with the Webflow and Make APIs

For bulk CMS operations, custom data transformations, or workflows that go beyond what the native modules expose, both platforms offer REST APIs. This path requires server-side development and familiarity with API authentication. It gives you access to every Webflow resource and Make scenario programmatically.

The relevant APIs are:

• Webflow's Data API v2 handles CMS collections, forms, ecommerce, assets, pages, and custom code with OAuth 2.0 or site token authentication
• Webflow webhooks trigger real-time events between systems when CMS items change, forms submit, or orders process
• Make's API v2 handles scenario management, execution, webhook configuration, data stores, and analytics

Together, these APIs cover the advanced integration cases that go beyond the native modules.

Make's native modules also include a Make an API Call action. It lets you hit any Webflow API endpoint not covered by the standard 40 modules. This is useful for accessing newer or beta endpoints without leaving the visual scenario builder.

Sync CMS content from external sources

A common API-level pattern is syncing content from an external database or spreadsheet into Webflow CMS with upsert logic. This creates new items when they don't exist and updates existing ones when they do.

To implement CMS content sync:

1. Use an external trigger (schedule, Google Sheets change, or Airtable update) to start the scenario.
2. Add a Search for Items module to find existing CMS items by a unique field (like a slug or external ID).
3. Add a Router module that branches based on whether a match exists. One path uses Create an Item (POST /collections/{collection_id}/items). The other uses Update an Item (PATCH /collections/{collection_id}/items/{item_id}).
4. Follow the item changes with Publish an Item, then end with a single Publish a Site module (POST /v2/sites/{site_id}/publish) to push those changes live.

When using the Make an API Call module or direct HTTP requests against Webflow's v2 API, CMS field values must be wrapped in a fieldData object. Missing this wrapper returns a 400 error. The native Webflow modules handle this automatically.

Process ecommerce orders

Ecommerce workflows often require reading order data from Webflow and writing fulfillment status back after external processing.

To automate order fulfillment:

1. Set up a Watch Events trigger filtered to ecomm_new_order events.
2. Route the order payload to external systems — a Google Sheets row for logging, a Slack message for team notification, and an email confirmation to the customer.
3. After the external fulfillment process completes, use the Mark an Order Fulfilled module (POST /v2/sites/{site_id}/orders/{order_id}/fulfill) to update the order status in Webflow.

The Webflow Ecommerce API also supports inventory updates (PATCH /v2/sites/{site_id}/inventory/{inventory_item_id}), product creation, and SKU management. All are accessible through Make's native modules or the Make an API Call fallback.

What can you build with the Make Webflow integration?

Integrating Make with Webflow lets you automate data flow between your site and external tools without building custom backend infrastructure.

• Lead capture with CRM routing: A Webflow contact form submits, and Make instantly creates a contact in HubSpot, adds the lead to a Mailchimp segment, and sends a Slack notification to the sales channel. One scenario handles it all, triggered by the form_submission event.
• Content pipeline from external sources: Writers manage blog posts in Notion or Airtable. When a row changes status to "Ready," Make creates or updates the corresponding Webflow CMS item, formats the slug, and publishes the site. The CMS plan supports up to 2,000 items. The Business plan includes 10,000 items by default and can scale higher with add-ons.
• Ecommerce order processing: A new Webflow ecommerce order triggers a Make scenario. It logs the order in Google Sheets, emails the customer a confirmation, notifies the warehouse team in Slack, and marks the order as fulfilled after shipping confirmation arrives.
• Comment-to-task automation: A new comment thread on a Webflow page triggers Make's Watch Comment Threads module. It creates a task in Asana or Jira with the comment content, assigns it based on the mentioned team member, and posts a summary to Slack.

If you need more control over membership data, the API integration path covers those cases with full flexibility.