Luma

How to integrate Luma with Webflow

Event-driven websites like Luma need frequent content updates as schedules change, speakers confirm, and registrations open. Manual content entry creates delays between event creation in Luma and website updates, while keeping registration data synchronized across platforms requires ongoing maintenance work.

Integrate Luma with Webflow through embed codes for displaying registration buttons and event calendars, Zapier automation for synchronizing event data with Webflow CMS collections, or API integration for custom workflows that require backend development.

Registration button embeds, event page embeds, and calendar widgets

Display event information and enable registration through Luma's embed codes without backend development or API configuration. Luma provides three embed types that work directly in Webflow's Code Embed element by pasting HTML code from your Luma event settings.

Add a Luma registration button or event page by dragging a Code Embed element onto your Webflow page, then paste the embed code from your Luma event's registration button documentation. The embed handles responsive design automatically and updates when you modify event details in Luma.

Embed options include registration button overlays that open popup registration forms, embedded event pages that display full event details inline within your Webflow layout, and calendar widgets that show your complete event schedule with automatic updates from the Luma calendar.

Create event-specific embeds across multiple pages using Collection fields in custom code embeds. Store Luma event IDs in Webflow CMS collections, then reference those fields in your embed code to generate registration buttons for each event template. This approach works for basic use cases but has limited support for complex dynamic personalization since Luma embed code uses static HTML.

Best for embedded event pages, registration button overlays, and calendar widgets that update automatically when event details change in Luma.

Connect through Zapier automation

Synchronize data between Luma and Webflow through dropdown menus and form fields without developer resources or custom code maintenance. Zapier provides workflows that connect Luma event triggers to Webflow CMS actions.

Set up automation by selecting a Luma trigger event (New Event Created, Event Updated, Calendar Event Added, Guest Registered, or Ticket Registered), authorizing both platforms, and mapping Luma fields to your Webflow CMS collection structure.

Zapier connects Luma triggers to Webflow actions through workflows called Zaps. Create automatic event listings by triggering on "New Event Created" in Luma and posting to Webflow CMS collections via the "Create CMS Item" action. Map Luma's event.name to your Event Title field, event.start_at to your Date field, and event.description to your Description field. Add a second action to publish the site and make new events visible immediately.

Track registrations by triggering on "Guest Registered" in Luma and creating items in your Webflow Attendees collection. Map guest.email to your Email field, guest.name to your Name field, and event.name to your Event Name field. This creates unified attendee records in Webflow CMS for reporting and email automation.

Update existing events by triggering on "Event Updated" in Luma, finding the corresponding Webflow CMS item by stored Luma event ID, then updating via the "Update CMS Item" action. This maintains synchronized event information across both platforms.

Note that Zapier represents a third-party automation solution since no native Luma app exists on the Webflow Marketplace. This integration requires a Zapier account with appropriate plan limits for your workflow volume.

Best for ongoing data synchronization across multiple events, automatic attendee tracking through workflows, and teams without development resources seeking automation without code.

Build with Webflow and Luma APIs

Custom workflows that require business logic, data transformations, or advanced features beyond what embeds and automation tools provide need direct API integration. This approach requires server-side development to handle authentication, transform data between platform formats, and respond to changes in either system.

Important prerequisite: Luma API access requires an active Luma Plus subscription on the calendar you want to access. Without Luma Plus, you cannot make API calls to retrieve or create events programmatically.

The Luma API uses API key authentication via the x-luma-api-key header, while Webflow requires OAuth 2.0. Your integration layer must manage both credential types. Client-side API calls from Webflow-hosted sites face CORS restrictions, requiring a server-side proxy (middleware that routes requests between your Webflow site and external APIs) that handles authentication securely and enables proper cross-origin requests.

Webflow provides webhooks for event-driven architecture, but Luma does not provide direct webhook endpoints. The webhook events (Guest Registered, Ticket Registered, Event Created, Event Updated, Calendar Event Added) are available only through third-party services like Zapier, not as direct Luma API endpoints. For custom implementations without Zapier, you must use polling-based detection by periodically querying Luma's API for changes instead of receiving automatic notifications.

Display event listings from Luma on Webflow

Pull event data from Luma and publish it to Webflow CMS collections for automatic rendering through your site templates. This pattern updates your website with new events, cancellations, and detail changes without manual content entry.

Implement periodic polling of Luma's event list endpoint to retrieve your event catalog, transform the JSON response to match your Webflow collection schema, then use Webflow's API to create collection items. Store Luma event IDs in a reference field to enable updates instead of duplicate creation on subsequent syncs.

Webflow CMS items are created in "staged" state and require the publish endpoint to appear on your live site. Schedule publishing as a separate workflow step or implement automatic publishing after each batch of updates. Note that as of July 2025, Webflow updated its CMS publishing behavior with new distinctions between staged and live items, plus breaking changes for unpublishing items that now require dedicated endpoints.

Implementation steps include authenticating with Luma using your API key in the x-luma-api-key header, polling Luma's event list endpoint every 5-15 minutes, transforming event data to match your Webflow CMS schema (converting ISO 8601 dates and mapping fields), authenticating with Webflow using OAuth 2.0 Bearer tokens, posting to Webflow's collection items endpoint with transformed data, and publishing changes to make them visible on your live site.

Best for marketing sites with frequent event updates, conference or workshop series, and community event calendars.

Sync event registrations to Webflow

Capture Luma registration data in Webflow CMS collections for unified reporting, email automation, or custom attendee experiences.

Critical limitation: Luma does not provide direct webhook endpoints for custom implementations. Webhook events like "Guest Registered" and "Ticket Registered" exist only through third-party platforms like Zapier. For custom API integrations, you must implement polling-based detection by periodically calling Luma's API to check for new registrations instead of receiving automatic notifications.

If using Zapier, configure the "Guest Registered" or "Ticket Registered" trigger to send registration data to your webhook receiver endpoint. For custom implementations without Zapier, build a polling mechanism that queries Luma's API at regular intervals to detect new registrations, extract registrant information, then create CMS items in your attendee collection. Store unique registration IDs to prevent duplicate records across polling cycles.

Best for event data synchronization to Webflow CMS, webhook-based attendance tracking via Zapier, and automated event listing updates.

Create Luma events from Webflow forms

Content teams can create events through Webflow forms using either Zapier automation or custom API implementation. The custom approach requires server-side integration to transform form data and maintain proper ISO 8601 date formatting, while Zapier provides no-code automation that connects Webflow form submissions to Luma event creation without middleware development.

Configure a form submission webhook in Webflow that delivers form data to your middleware. Transform the form fields to match Luma's requirements (converting date inputs to ISO 8601 format), then call Luma's event creation endpoint to generate the event. Required fields include name, start_at (ISO 8601 format), and calendar_api_id.

Return the generated Luma event URL and ID to the form submitter or store them in a Webflow CMS collection for reference. This maintains the source of truth in both systems while providing linking back to Luma for event management.

Best for internal event creation workflows, client event submission portals, and rapid event deployment systems.

Manage attendee segments with person tags

Use Luma's person tag API to create audience segments based on Webflow CMS user attributes. This requires custom API integration using Webflow's endpoint to retrieve user data and Luma's endpoint to assign tags, enabling programmatic audience segmentation and access management based on stored user attributes.

Query Webflow CMS collections for user records using the List Items endpoint, apply segmentation logic based on membership tiers, purchase history, or custom attributes, then call Luma's person tag endpoint to assign tags. These tags control event visibility and invitation targeting in Luma's calendar permissions system.

Synchronize Luma user tags to Webflow CMS records through polling-based workflows to maintain accurate audience segments as your community evolves. Note that true bidirectional sync requires server-side infrastructure since Luma lacks documented webhook support for tag changes.

Best for membership communities with tiered access, enterprise event programs with complex permissions, and targeted event marketing campaigns.

What you can build

Integrating Luma with Webflow lets you create event-driven websites that combine Webflow's design capabilities with Luma's event management infrastructure.

• Automated event marketing sites: Display current speaker schedules using Luma's calendar embed and registration buttons that open Luma's registration form within your Webflow design. Zapier automation or embedded calendar widgets sync new events from Luma to Webflow CMS collections within minutes of creation for ongoing event series without manual content entry.
• Member portals with exclusive events: Combine Webflow's conditional visibility with Luma's person tagging system to control event access by membership tier. Store membership levels in Webflow CMS collections, then use conditional visibility rules to show or hide Luma event embeds based on the logged-in user's tier.
• Event content integration: Create event archive pages that display completed workshops with speaker bios, recorded sessions, and attendee counts pulled from Luma's API. Zapier workflows move events between "Upcoming Events" and "Past Events" CMS collections when dates pass.
• Branded registration experiences: Integrate Luma's registration embeds directly into custom-designed Webflow landing pages using Code Embed elements while maintaining brand consistency through customizable styling. The embedded forms handle event registration while Luma's infrastructure manages payment processing, capacity tracking, and attendee communication with all payment data processed and stored exclusively within Luma's systems for PCI compliance.