Axeptio

Axeptio shows a customizable consent banner before your tracking scripts run, collects visitor choices, stores proof of consent, and fires or blocks third-party scripts based on those choices. You control the banner design, copy, and behavior from Axeptio's dashboard, so updates never require changes in the Designer.

If your site runs Google Analytics, Meta Pixel, or other tracking scripts without a consent layer, you risk violating GDPR, CCPA, and other privacy regulations. Targeting the European Economic Area also means you likely need a Google-certified CMP to keep GA4 and Google Ads features available under Consent Mode v2.

How to integrate Axeptio with Webflow

What is Axeptio? Axeptio is a consent management platform that treats the consent moment as a brand interaction rather than a legal checkbox. It covers GDPR, CCPA, Law 25 (Quebec), and PIPEDA compliance from a single dashboard. Axeptio holds Google Gold CMP Partner status, IAB TCF v2.3 certification, and ISO/IEC 27001 certification.

Connect Axeptio to gate tracking scripts behind user consent, display a branded cookie banner, and maintain Google Consent Mode v2 compliance. The combination is common if you run Google Ads or GA4 in the EEA, where a Google-certified CMP is required for certain Consent Mode use cases.

You can implement Axeptio using custom code, Google Tag Manager, or the Data API paired with Axeptio's API for programmatic deployment.

• Custom code in site settings handles site-wide consent banner deployment without any additional tools.
• Google Tag Manager lets you manage all tracking tags and Axeptio consent signals from GTM, keeping your custom code minimal.
• The Data API and Axeptio API give you control over programmatic script deployment across multiple sites, but require server-side development.

Pick one method based on your technical resources and whether GTM is already part of your stack.

Add the Axeptio consent script with custom code

This method places the Axeptio JavaScript snippet directly in custom code in head and body tags at the site level. It works on any paid plan and requires no tools beyond the Axeptio dashboard. The snippet loads the consent banner on every page and stores visitor preferences in cookies. You customize the banner, including colors, text, button labels, and consent categories, in the Axeptio admin panel.

To set up the integration:

1. Create an Axeptio account at axept.io and configure your consent banner in the dashboard.
2. In the Axeptio admin, go to Integration > General, select your banner configuration from the dropdown, and click Copy to copy the script snippet.
3. Open Site settings > Custom Code and paste the Axeptio snippet into the Head Code field as the first entry, before any tracking scripts.
4. Click Save Changes, then publish your site.

Place the Axeptio snippet before any tracking scripts in the Head Code field. Scripts execute in the order they are added, so any script above the Axeptio snippet fires before consent is collected. That creates a compliance failure with no error indicator. After publishing, visit your live site, not the preview, and verify the banner appears on first load.

Block third-party scripts until consent

Once the Axeptio banner collects consent, your tracking scripts should fire only when the visitor has opted in to the relevant category. The Axeptio SDK's cookies:complete event gives you a choices object with boolean values for each vendor configured in your dashboard.

To load scripts based on consent:

1. Remove any tracking scripts that currently load unconditionally in your Head Code.
2. Add the following pattern after the Axeptio snippet in your Head Code:

window._axcb = window._axcb || [];
window._axcb.push(function(axeptio) {
  axeptio.on('cookies:complete', function(choices) {
    if (choices.google_analytics) {
      var script = document.createElement('script');
      script.src = 'https://www.googletagmanager.com/gtag/js?id=YOUR_GA_ID';
      document.head.appendChild(script);
    }
    if (choices.facebook_pixel) {
      // Load Facebook Pixel dynamically
    }
  }, { replay: true });
});

3. Replace the vendor names (google_analytics, facebook_pixel) with the exact identifiers from your Axeptio dashboard configuration.

The replay: true option matters for returning visitors whose consent is already stored in cookies. It fires the callback immediately, so scripts load without waiting for another banner interaction. Skip it, and returning visitors who already consented will not trigger their tracking scripts.

Configure banners for multilingual sites

If your site has multiple language versions, you can load different Axeptio banner configurations based on the page language. Axeptio's configuration loading reads the HTML lang attribute to select the correct banner.

To set up language-based configuration:

1. Confirm each language page has the correct lang attribute on the <html> element.
2. Replace the standard cookiesVersion string with a configuration object in your Head Code:

window.axeptioSettings = {
  clientId: '000000000000000',
  cookiesVersion: {
    type: "custom_function",
    config: {
      function: () => { return document.documentElement.lang; }
    },
    cases: {
      default: "-en",
      "fr-FR": "-fr",
    }
  }
};

3. Create a separate banner configuration in the Axeptio dashboard for each language and match the cases values to those configuration names.

Each configuration can carry its own translations, vendor lists, and consent categories. The SDK evaluates the function on page load and selects the matching banner version.

Load Axeptio through Google Tag Manager

If you already use Google Tag Manager, loading Axeptio through GTM trims your Head Code field down to a single GTM container script. All tracking tags, consent signals, and Axeptio configuration sit inside GTM. This approach also reduces the risk of script reordering, since only the GTM snippet needs to stay in the Head Code.

Axeptio publishes an official GTM tag template that supports project ID, cookies version, user cookies duration/domain/secure, Google Consent Mode v2 activation with default regional settings, dataLayer name, and server-side URL.

To set up Axeptio via GTM:

1. In your GTM container, add a new tag using the Axeptio community template from the GTM template gallery.
2. Configure the tag with your Axeptio Project ID and Cookies Version from the Axeptio dashboard.
3. Set the trigger to fire on All Pages.
4. Confirm your GTM container script is the first entry in Site settings > Custom Code > Head Code.
5. Publish your site.

GTM handles consent signal distribution to all tags in the container. When a visitor makes a consent choice, Axeptio fires GTM dataLayer events you can use as triggers for individual tracking tags. GA4, Meta Pixel, and other tags then fire only when the visitor has consented to the corresponding category.

The triggerGTMEvents parameter in axeptioSettings controls dataLayer event behavior. For detailed GTM event configuration, see the Axeptio GTM integration guide. Centralizing consent logic in GTM keeps script conditions from spreading across your pages.

Build with the Webflow and Axeptio APIs

If you manage consent across many sites or build custom consent workflows, combine the Axeptio and Webflow APIs for programmatic deployment and consent data retrieval. This path requires server-side development and suits teams that need to automate script deployment, store consent records externally, or build compliance reporting dashboards.

This guide uses these APIs:

• The Axeptio REST API (https://api.axept.io/v1/) handles consent record retrieval, project configuration, webhook registration, and statistics across 31 endpoints.
• The Custom Code API registers and applies scripts to sites and pages programmatically. You need a Webflow App with OAuth tokens; site tokens cannot call these endpoints.
• Webhooks trigger events like form_submission that you can route to your own backend for consent-aware processing.

Both APIs use Bearer token authentication. Get the Axeptio token via POST /auth/local/signin, and get your Webflow token through the OAuth 2.0 App authorization flow.

Deploy Axeptio to multiple sites programmatically

If you maintain consent compliance across a portfolio of client sites, script the full deployment sequence instead of pasting code into each site's settings by hand.

To deploy Axeptio via the Custom Code API:

1. Call GET /v2/sites with your OAuth token (scope: sites:read) to retrieve site_id values for your target sites.
2. Register the Axeptio SDK as a hosted script: POST /v2/sites/{site_id}/registered_scripts/hosted (scope: custom_code:write), with the source URL //static.axept.io/sdk.js.
3. Register your window.axeptioSettings configuration as an inline script: POST /v2/sites/{site_id}/registered_scripts/inline (scope: custom_code:write).
4. Apply both scripts to the site header: PUT /v2/sites/{site_id}/custom_code (scope: custom_code:write), setting location: "header".
5. Publish the site: POST /v2/sites/{site_id}/publish (scope: sites:write).

This sequence gives you a repeatable deployment workflow you can run across multiple sites.

The DELETE /v2/sites/{site_id}/custom_code endpoint removes all scripts applied by your app in one operation. For selective removal, use the PUT endpoint with a modified script list that omits the script you want to remove. Each site supports a maximum of 800 registered scripts. See the Custom Code API reference for request and response schemas.

Store consent records via webhook

Axeptio's webhook endpoint pushes consent records to your own server whenever a visitor completes the consent flow. Use it to create an external audit trail independent of Axeptio's storage.

To register a consent webhook:

1. Obtain an Axeptio Bearer token via POST https://api.axept.io/v1/auth/local/signin.
2. Register the webhook:

POST https://api.axept.io/v1/webhooks
Authorization: Bearer YOUR_BEARER_TOKEN
Content-Type: application/json

{
  "method": "POST",
  "url": "https://your-backend.com/consent",
  "event": "consent/YOUR_PROJECT_ID"
}

3. On your server, receive the POST payload and store the consent record in your database.

Reach for this approach when you need an external audit trail or your own consent reporting workflow.

You can also write consent records to the CMS as Collection items via middleware. Create a Collection with fields for user token, consent date, and vendor choices, then have your middleware map the Axeptio webhook payload to POST /v2/collections/{collection_id}/items/live (scope: cms:write). CMS items are capped at 2,000 on the CMS plan and 10,000 on the Business plan, so this approach suits audit sampling or low-traffic sites rather than storing every consent record from a high-traffic domain. For full webhook documentation, see the Axeptio webhooks reference. Store records in your own database for complete logging, or in the CMS for lighter internal reporting.

What can you build with the Axeptio Webflow integration?

Integrating Axeptio lets you run a privacy-compliant site with branded consent experiences without building custom consent logic or managing cookie scripts by hand.

• GDPR-compliant marketing sites: Run GA4, Meta Pixel, and Google Ads tags on a site that targets EU visitors, with all scripts gated behind consent. Axeptio's Google Consent Mode v2 support (Basic and Advanced modes) keeps conversion tracking and audience modeling available even when some visitors decline cookies.
• Multi-region compliance from one site: Serve different consent banners to visitors in the EU, California, Quebec, and other jurisdictions using Axeptio's geotargeting and configuration loading. A single site covers GDPR, CCPA, Law 25, and PIPEDA requirements without separate consent implementations for each region.
• Brand-consistent consent experiences: Replace generic legal popups with consent banners that match your site's visual identity, including custom colors, button styles, logos, and even embedded video. Axeptio's built-in A/B testing lets you compare banner variants to find the configuration that produces the highest opt-in rate.
• Agency-managed consent across client portfolios: Deploy and update Axeptio configurations across multiple client sites from the Axeptio agency dashboard, with programmatic deployment available through the Custom Code API when you want to automate the process.

If you need more control over consent record storage or cross-system consent synchronization, the API integration path covers those cases with full flexibility.