Unbounce

Your Webflow site carries the brand, the CMS, and the pages you expect to keep for years. Paid campaigns want something else: a page you can put up on Monday, test two ways on Tuesday, and retire on Friday. Popups and sticky bars that fire on exit, scroll, or a timer need a script on every page where they run, and leads captured on a separate platform never reach your Webflow site on their own.

Unbounce covers those jobs, and it does them on its own hosting, in its own account. So the connection between the two is real but specific, and worth stating plainly: neither product ships a native connector for the other. What you get instead is a script for popups and sticky bars, a subdomain for campaign pages, an automation or a webhook for the lead data, and a pair of MCP servers that let one AI assistant work in both accounts.

This setup fits growth and performance marketers who launch PPC pages weekly and want them off the developer queue. Agencies running many client campaigns from one Unbounce account use it to leave each client's Webflow site alone. Developers who need Unbounce lead data inside Webflow collections get webhook and API paths for the sync.

How to integrate Unbounce with Webflow

What is Unbounce? Unbounce is a landing page platform with a drag-and-drop Classic Builder, an AI-assisted Smart Builder, and an MCP server that builds pages from an AI assistant. It adds popups, sticky bars, unlimited A/B tests on the Experiment plan and higher, and Smart Traffic, an algorithm that sends each visitor to the variant they are most likely to convert on. Form submissions flow out through more than 60 built-in integrations powered by Zapier, through Zapier itself, and through webhooks.

Teams pair the two when the Webflow site is the brand home and campaign pages need a faster iteration loop than a publish cycle allows. Unbounce hosts the campaign pages, so variants and Smart Traffic run without touching Webflow. Because neither platform lists the other as a native integration, every connection runs through an agent, a script, DNS, an automation tool, or the two APIs.

The Unbounce and Webflow pairing supports five approaches:

• MCP servers on both sides: one AI assistant builds and publishes Unbounce pages and manages your Webflow site in the same conversation.
• The Unbounce embed script adds popups and sticky bars to Webflow pages through custom code.
• Subdomain hosting publishes Unbounce landing pages at a subdomain while your Webflow site keeps the root domain.
• Zapier, Make, and viaSocket move Unbounce form submissions into Webflow CMS items without code.
• The Webflow Data API and Unbounce API give you full control over lead sync, at the cost of server-side development.

Most implementations combine two or more of these depending on how much of the campaign lives outside Webflow.

Run both platforms from one AI assistant with MCP

Unbounce and Webflow each publish an MCP server, so a single assistant can draft a campaign page in Unbounce and update the Webflow site that links to it without you switching tools. The Unbounce MCP server connects to Claude Desktop, Claude Code, ChatGPT Desktop, and the Codex CLI through the unbounce/agent-plugins marketplace, and ChatGPT on the web is not supported yet. The Webflow MCP server covers the Webflow half, including CMS content, analytics, automation, and per-site governance.

What the Unbounce server will and will not do shapes the rest of this page:

• Pages and variants: the assistant builds a page from a plain-language brief, adds variants, sets a weighted traffic split or turns on Smart Traffic, and promotes a champion.
• Publishing stays yours: content, variant, and traffic changes stage as drafts until you ask for a publish, and changing a page URL is the one action that takes effect immediately.
• Builder lock-in runs both ways: a page created through MCP cannot be opened in the visual Unbounce builder, and a Classic Builder page cannot be edited or exported through the assistant, though it can be copied into an MCP-managed page.
• No lead data: Unbounce documents that the server exposes aggregate lead volume only, with individual submissions, visitor PII, and IP addresses removed.
• Popups, sticky bars, and domains are out of scope: Unbounce lists those, along with payments and permanent asset deletion, as work you still do in the Unbounce app.

That last limit is the reason the next two sections exist: the popup script and the subdomain are set up by hand, whatever your assistant is doing with the pages themselves.

Add Unbounce popups and sticky bars with custom code

The Installation panel in Unbounce gives you one line of JavaScript for any Webflow page where a popup or sticky bar will run, and Unbounce's own instructions for a platform it does not document are to install the embed code in the head section of the site's HTML. The item goes live only after the snippet is in place and you publish it in Unbounce. You need the Unbounce Build plan or higher, since Starter excludes popups and sticky bars. On the Webflow side, custom code needs a Core, Growth, Agency, or Freelancer Workspace, or an active Site plan.

Once installed, the snippet fires popups and sticky bars on five documented triggers:

• On arrival: the popup appears as soon as the visitor loads the page, which suits an offer you want every visitor to see once.
• After a delay: the popup waits a set number of seconds, so a reader gets to the content before the offer interrupts.
• On exit: cursor movement out of the browser window fires the popup 1.5 seconds later, and Unbounce documents this trigger as desktop only.
• On scroll: either a scroll up the page or a set percentage of the way down, which works well on long Webflow blog posts.
• On click: a click on any element you can address by CSS selector, ID, or class, so a Webflow button can open an Unbounce popup.

Location, cookie, and referrer targeting, plus scheduling, sit behind a higher tier: the article on targeting your popup lists them as Optimize 2024, Accelerate 2020, and Concierge features. Plain URL targeting is available on every plan that includes popups.

Install the snippet site-wide in Site settings

Placing the snippet in Head code loads it on every published page, which lets marketers publish new popups and sticky bars from Unbounce without another Webflow edit. Choose this path when popups target many pages, or when marketing owns the campaign calendar and you do not want to be in the loop for each one.

To install the snippet across your site:

1. In Unbounce, open the popup or sticky bar, scroll to the Installation panel, and click Copy.
2. In Webflow, go to Site settings > Custom code > Head code and paste the snippet.
3. Click Save changes and publish your site.
4. In Unbounce, set URL Targeting to match your Webflow domain exactly, including www, then click Publish.

Each custom code field holds up to 50,000 characters, which leaves room for the snippet alongside analytics tags. If the domain in URL Targeting does not match the domain the Webflow page is served from, the popup never shows, and that is the most common reason a correctly installed snippet appears to do nothing.

Load the snippet on one page with Code Embed

Campaigns limited to a single landing page or blog post can use page-level code instead. A Code Embed element places the code anywhere on the canvas or inside a rich text element. If you prefer a head placement, open Page settings > Custom code and paste into the Inside <head> tag field. Page-level code appears after any site-wide custom code in the published markup.

To add the snippet with Code Embed:

1. Open the page in Webflow and open the Add panel.
2. Drag a Code Embed element onto the canvas.
3. Paste the Unbounce snippet and click Save and close.
4. Publish the site, then publish the popup or sticky bar in Unbounce.

Do not install the snippet both site-wide and on the page. Unbounce allows only one embed code per client on a page, and if two are present only the first to load will fire. Sticky bars also cannot launch popups or lightboxes, so build a popup directly when you need one.

Publish Unbounce landing pages on a subdomain of your Webflow domain

This is a DNS arrangement rather than a product integration, and the distinction matters. A CNAME at a prefix such as get sends that subdomain's traffic to Unbounce, while your existing Webflow records keep serving the apex and www. Unbounce's guide to connecting your domain is explicit that a site already living at the root domain needs a different subdomain, because Unbounce landing pages cannot sit at the same URL as your homepage. Any paid Unbounce plan includes unlimited subdomains, and the Webflow root domain still needs its own Site plan.

To connect the subdomain manually:

1. In Unbounce, open the Domains tab, enter your subdomain and root domain, then click Copy to Clipboard to grab the unique CNAME value.
2. At your DNS provider, create a CNAME record with host get (or your chosen prefix) and the Unbounce value as the destination.
3. Leave your Webflow apex records alone. Webflow's guide to manually connect a domain sets out an A record at @ pointing to 198.202.211.1, a CNAME at www pointing to cdn.webflow.com, and a _webflow TXT verification record. Sites created before April 21, 2025 may need a different set, so copy what Site settings > Publishing > Production shows rather than these values.
4. Return to the Unbounce Domains tab. Status reads Configuring until the CNAME propagates, which Unbounce describes as anything from a few moments to a few days.
5. Toggle Force HTTPS on all non-WordPress domains, then open the landing page's Page Overview, click the current URL, pick the new domain, and save.

On the Launch, Build, Experiment, Optimize, Accelerate, or Concierge plans, Unbounce can set the CNAME for you through Entri instead, using your DNS provider credentials. Once the subdomain resolves, pages on it get features that stay off your Webflow pages:

• Unlimited A/B variants: available on the Experiment plan and higher, tested and swapped without a Webflow publish.
• Smart Traffic routing: available on the Optimize plan and higher, and only on Unbounce pages connected to a custom domain.
• Dynamic Text Replacement: matches headlines to a visitor's search terms, and appears from the Experiment plan up.
• Automatic SSL: Unbounce provisions a certificate for the subdomain once the CNAME connects, on every paid plan.

Two constraints are worth knowing before you start. Do not also add the Unbounce subdomain under Site settings > Publishing > Production in Webflow, because that prefix already resolves to Unbounce and cannot point at both. And Unbounce does not support or recommend proxies or CDN services in front of a connected domain, which rules out the reverse-proxy setups some Webflow sites run at the apex. Check your Webflow DNS first if the site predates April 21, 2025: publishing to a custom domain still on the legacy records has been blocked since January 13, 2026, per the Cloudflare migration guide.

Connect with Zapier, Make, or viaSocket

Zapier is the shortest route, because Unbounce's New Form Submission trigger is an instant trigger rather than a poll: Zapier's own listing describes it as an event that starts a Zap instantly, so a lead reaches Webflow in seconds rather than on a 15-minute polling cycle. Zapier ships one prebuilt template for the pair, built on that trigger and the Webflow Update Item action. Make and viaSocket both carry connectors for the two products, and Make publishes no template for this specific pairing.

The documented pairs worth building:

• New lead into a new CMS item: the Unbounce New Form Submission trigger feeding Webflow Create Item or Create Live Item, which is the usual starting point.
• New lead into an existing item: the same trigger feeding Update Item or Update Live Item, which is what the prebuilt template does.
• New Unbounce page into the CMS: viaSocket exposes a New Landing Page Created trigger, so a campaign page can register itself in a Webflow collection when it is built.
• Webflow form into Unbounce: viaSocket runs the arrow the other way with a Create Page Lead action, which is useful when a Webflow form should feed the same lead record.

Two limits shape the mapping. Zapier documents that CMS reference and multi-reference fields cannot be mapped when creating or updating items, so keep synced collections flat or move to the API path below. And n8n has a Webflow node and a Webflow Trigger node but no Unbounce node at all, so an n8n route has to start from a Webhook node receiving the Unbounce webhook described next.

Build with the Webflow and Unbounce APIs

Reference fields, custom field handling, and deduplication logic need your own endpoint to receive the Unbounce Form Submit Webhook and call the Webflow Data API. This path costs server-side development and an Unbounce plan that includes integrations, which starts at Build. Webflow API v1 was deprecated on March 31, 2025, so every call goes to https://api.webflow.com/v2 with a Bearer token. The Unbounce API is documented at version 0.4, requires HTTPS on every connection, and is rate limited to 500 requests per minute per account and IP.

The APIs and events in play:

• Unbounce REST API: handles accounts, clients, domains, page groups, pages, form fields, and lead retrieval, with API keys acting at account administrator level.
• Unbounce Form Submit Webhook: posts every submission to your endpoint as form-encoded data by default, or as JSON or XML if you change the content type.
• Webflow CMS endpoints: you can create a CMS item, list collections, and read form submissions for a site, all under the CMS:write or matching read scope.
• Webflow webhooks: Webflow webhooks cover 14 event types including form_submission and collection_item_created, with three retries ten minutes apart before a webhook is deactivated.

Webflow Cloud can host the receiving endpoint next to the site, since server-side API route handlers run on its Edge runtime, as the bring your own app guide sets out. Note that the Edge runtime has limited API support, so use fetch rather than a client library such as axios.

Sync Unbounce form submissions to Webflow CMS items

The Form Submit Webhook sends the same event for submissions from landing pages, popups, and sticky bars, so one endpoint covers all three. Your endpoint receives the POST, reshapes the fields, and creates a CMS item. Unbounce needs an HTTP 200 back to treat the delivery as successful.

To implement the sync:

1. In Unbounce, open the Page Overview, then Integrations > Webhooks, and click +Add Webhook. Enter your endpoint URL, set the Content-Type to JSON, add an X-API-Key custom header for authentication, and click Save Changes.
2. Parse the payload. Unbounce wraps every value in a single-element array, as its own data.json sample shows:

   {
     "email":          ["test@test.com"],
     "ip_address":     ["1.1.1.1"],
     "page_uuid":      ["a2838d98-4cf4-11df-a3fd-00163e372d58"],
     "variant":        ["a"],
     "time_submitted": ["10:57 PM UTC"],
     "date_submitted": ["2023-06-06"],
     "page_url":       ["http://my-landing-page.ca/"],
     "page_name":      ["My Landing Page"]
   }

3. Create a Site token in Webflow under Site settings > Apps & integrations > API access with the cms:write scope.
4. Unwrap the arrays and call POST https://api.webflow.com/v2/collections/{collection_id}/items with Authorization: Bearer YOUR_ACCESS_TOKEN. The fieldData object must include name and slug. Call /items/live instead to create and publish in one step.
5. For staged items, call POST https://api.webflow.com/v2/collections/{collection_id}/items/publish, then return 200 to Unbounce.

Map date_submitted to a DateTime field, since it arrives as a valid ISO 8601 date. time_submitted is UTC only and not ISO 8601, so store it as PlainText or merge it with the date. Allowlist both documented Unbounce outbound addresses, 54.241.34.25 and 50.19.99.184, if your endpoint sits behind a firewall. To confirm a delivery landed, open the lead in the Leads tab and look for the green checkmark under Integration Details. Unbounce also warns that it has no visibility into your webhook setup, and points GDPR-sensitive teams at its Zapier integrations instead.

Backfill historical Unbounce leads with the Unbounce API

Webhook delivery starts only when you save the webhook, so earlier submissions have to come from the API before you write them to Webflow in bulk. API access is not self-serve: you request it with your Unbounce login email and support confirms it, which Unbounce says takes a couple of days. Authenticate with HTTP Basic Auth using your API key as the username and nothing as the password, and send Accept: application/vnd.unbounce.api.v0.4+json on every request, as the Unbounce getting started guide describes.

To backfill leads:

1. Request API access, then create an API key under Manage Account > API Access.
2. Call GET https://api.unbounce.com/pages/{page_id}/form_fields to list the form fields across every variant of the page.
3. Call GET https://api.unbounce.com/pages/{page_id}/leads to retrieve every lead for that page, popup, or sticky bar.
4. Map each lead to a Webflow item and send them in batches of up to 100 with POST https://api.webflow.com/v2/collections/{collection_id}/items/bulk.
5. Publish the new items with POST https://api.webflow.com/v2/collections/{collection_id}/items/publish.

Two endpoints need OAuth rather than an API key: the top-level GET /pages resource, which reaches pages on clients other than your own, and DELETE /pages/{page_id}/leads/{lead_id}, which Unbounce restricts to the account owner and documents as unavailable to API keys. OAuth access tokens expire after 600 seconds and refresh with grant_type=refresh_token at https://api.unbounce.com/oauth/token.

What you can build with the Unbounce Webflow integration

Campaign work stays outside the publish queue while landing pages, popups, and lead data run alongside the main Webflow site.

Four patterns come up most often:

• Paid campaign pages on a subdomain: a Webflow marketing site at www.yoursite.com and PPC pages at get.yoursite.com, each with its own variants and its own iteration speed.
• Popups and sticky bars on Webflow blog posts: an exit-intent newsletter popup or a scroll-triggered bar across every article, published from Unbounce after a one-time script install.
• A branded page per customer or product: agency Apexure documents Chorus running its marketing site on Webflow with a modular Unbounce layout that becomes a page per artist, in a case study published in May 2025.
• Lead-driven CMS content: an Unbounce registration form that creates a Webflow item through Zapier and renders it through a Collection List, which is how a webinar speaker list or a growing partner directory gets built.

If the automation layer is where most of your work will sit, our guide to building a marketing automation hub covers the cross-tool patterns in more depth. For anything Zapier cannot map, the API path handles custom fields, deduplication, and writes to reference fields.