Humanitix

How to integrate Humanitix with Webflow

Event organizers need a way to sell tickets without breaking brand consistency or forcing attendees through multiple checkout flows. The Humanitix integration with Webflow keeps ticket buyers on your custom-branded site while handling registration, payment processing, and attendee management.

Humanitix provides three integration methods: embedded widgets place full checkout experiences directly on Webflow pages for straightforward ticket sales. Automation platforms like Zapier and Make sync event data from Humanitix to Webflow CMS collections without custom code, though updates take 1-15 minutes to propagate. API integration gives developers full control over event data flows between Humanitix and Webflow with custom logic, but Humanitix's public API provides read-only access.

Use embedded widgets

Add Humanitix ticketing directly to Webflow pages using client-side JavaScript widgets that require only copy-paste implementation. This method works for event organizers who need branded checkout experiences without leaving their custom Webflow site. Suitable for conferences, workshops, fundraisers, and recurring event series where visual consistency matters more than CMS-based event catalogs.

Three widget types serve different display patterns. The embedded checkout widget shows full ticketing inline on event pages. Pop-up button widgets open checkout in modal overlays. Collection widgets display multiple events in one embeddable interface.

Implementation steps

• Copy the widget HTML from your Humanitix event dashboard under Advanced > Embedded Widgets
• Drag a Code Embed element from the Add Elements panel onto your event page
• Paste the code into the Code Embed element
• Adjust element dimensions visually in Webflow
• Publish the site to activate the widget

For pop-up button widgets, add the global script once to Site Settings > Custom Code > Head Code before creating button elements. This ensures the popup.js script loads across all site pages.

Widget capabilities

• Collect attendee information with custom checkout questions specific to your event requirements
• Auto-apply promo codes through widget URL parameters
• Capture interest when events sell out with automated waitlist notifications
• Display seat maps and enable attendee seat selection for assigned seating
• Sell event-related products during checkout with merchandise add-ons

All features function identically in embedded widgets as they do on standalone Humanitix event pages. Ticket types and pricing configurations in your Humanitix dashboard flow directly to embedded widgets. Custom branding is supported within Humanitix's design system. Deep visual customization requires working within the constraints of the hosted widget interface.

Only one widget can display per page. Events must be published in Humanitix before widgets become active on Webflow sites. Republish your Webflow site after adding or modifying embed codes to ensure changes take effect.

Connect through automation platforms

Use Zapier, Make, or viaSocket to sync event data from Humanitix to Webflow CMS without writing custom code. These automation platforms handle the technical integration layer while you configure triggers and actions through visual workflow builders. This method works for teams needing automated event listing creation in Webflow.

For example, Zapier's pre-built template automatically creates Webflow CMS items whenever new events are added in Humanitix. Updates are not instantaneous. Automation platforms typically poll for changes every 1-15 minutes rather than providing real-time synchronization, and involve platform-specific rate limits beyond the underlying API constraints.

Zapier's Humanitix-Webflow connection provides pre-built templates for common workflows. The automatic CMS item creation template automatically creates Webflow collection items whenever a new event is published in Humanitix.

Available triggers

• New Event in Humanitix creates corresponding CMS collection items in Webflow with event titles, dates, descriptions, and ticket URLs when you publish events in Humanitix
• New Attendee in Humanitix updates attendee count fields and roster displays in Webflow CMS collection items as registrations occur
• New Order in Humanitix updates "tickets sold," "revenue," and "order count" fields in Webflow CMS event items to track sales metrics
• New Attendee Check-In in Humanitix updates attendance status fields in Webflow CMS to display check-in data on event pages

Common workflows

• Create Webflow CMS collection items automatically when you publish new Humanitix events with titles, dates, descriptions, and ticket URLs
• Update "tickets remaining" fields in Webflow CMS items when new orders come through Humanitix for availability tracking on event pages
• Populate speaker lists or participant directories in Webflow CMS collections when new attendees register in Humanitix
• Forward Webflow form submissions to Humanitix via automation platforms for event promotion and attendee list building

OAuth authentication through an automation platform connects both services. These platforms handle API rate limiting (Humanitix allows 200 requests per minute, Webflow allows 60-120 requests per minute depending on token type), error retry logic, and data transformation between Humanitix and Webflow's different field structures.

Limitations

Integration platforms like Zapier, Make, or viaSocket poll Humanitix for changes at 1-15 minute intervals depending on your automation platform subscription tier. For Webflow and Humanitix specifically, this means event updates in Humanitix take 1-15 minutes to reflect in your Webflow CMS. Humanitix enforces a hard rate limit of 200 requests per minute, while Webflow enforces 60 requests per minute or 120 with OAuth tokens.

The Humanitix public API provides read-only access. Creating or updating events requires their beta API, available by contacting support@humanitix.com. This means that while you can pull Humanitix data into Webflow automatically, pushing changes from Webflow back to Humanitix requires either custom development with the beta API or using integration platforms that may have special API access arrangements.

Build with Webflow and Humanitix APIs

The Humanitix Public API combined with Webflow's CMS API allows custom integrations with full control over data synchronization, error handling, and business logic. However, the Humanitix public API provides read-only access.

Write operations require beta API access by request from support@humanitix.com. This approach works for teams managing 100+ events, requiring frequent update checks, or implementing custom workflows not supported by pre-built automation tools.

Both platforms provide REST APIs with JSON payloads. Humanitix uses API key authentication (header format x-api-key: YOUR_API_KEY) with requests limited to 200 per minute. Webflow uses OAuth 2.0 with rate limits of 60 requests per minute for standard tokens and 120 requests per minute for OAuth tokens. Review Webflow's authentication guide and Humanitix's API terms before implementation.

Fetch and display event listings

Pull event data from Humanitix into Webflow CMS using the public API or automation platforms. This pattern maintains synchronized event catalogs where Humanitix serves as the source of truth for event details, dates, and ticketing information. Zapier offers a pre-built template that automatically creates Webflow collection items whenever new events are published in Humanitix. For custom implementations, schedule API polling to respect rate limits while keeping your event listings current.

Humanitix endpoints

• GET /v1/events from the events API returns titles, dates, descriptions, venue details, and ticket availability
• Authenticate with x-api-key: YOUR_API_KEY header
• Filter by status, date ranges, or tags using query parameters

Webflow endpoints

Map Humanitix event fields to your Webflow collection structure. Common field mappings include event title to collection name, start date to date field, description to rich text, and Humanitix widget URL to link field. For automated synchronization, schedule polling every 10 minutes.

This respects Humanitix's 200 requests per minute hard limit while staying within Webflow's standard rate of 60 requests per minute or 120 for OAuth tokens. This pattern works for Humanitix to Webflow data flow. Webflow to Humanitix sync requires beta API access from Humanitix support.

Track ticket sales and update availability

Monitor ticket purchases through the Humanitix orders API (read-only access) and update event capacity on Webflow pages using one of three approaches. Schedule periodic API polling to check GET /v1/orders and sync metrics to Webflow CMS. Use an integration platform like Zapier to handle order tracking and CMS updates with 1-15 minute intervals.

Request write access to Humanitix's beta API for more complex synchronization. These methods support "tickets remaining" counters and sold-out badges. Frequent updates require a dedicated polling solution within rate limit constraints (Humanitix allows 200 requests per minute).

Implementation pattern

Fetch recent orders using **GET https://api.humanitix.com/v1/orders** from Humanitix. Aggregate ticket quantities by event ID. Update corresponding Webflow collection items with total tickets sold, revenue, and order counts using the *PATCH /v2/collections/{collectionid}/items/{itemid}* endpoint with fieldData containing tickets-sold, total-revenue, and order-count fields.

Store the last successful sync timestamp to fetch only new orders on subsequent runs. This reduces API calls and respects Humanitix's hard limit of 200 requests per minute. Calculate tickets remaining by subtracting sold quantities from total capacity stored in Webflow.

Trigger workflows with webhooks

Configure Webflow webhooks to send real-time notifications when your Webflow CMS changes. Webflow webhook events include collection_item_created, collection_item_changed, collection_item_deleted, and form_submission.

Humanitix does not provide native webhook functionality through their public API. For event notifications (new attendee, new event, new order, new contact, new attendee check-in), use integration platforms like Zapier, Make, or Pipedream as intermediaries. These platforms poll Humanitix at regular intervals and can forward notifications to external services or update Webflow CMS when changes occur.

Set up webhook endpoints via the Webflow API at POST /v2/sites/:site_id/webhooks to configure real-time event monitoring for Webflow changes. Your server receives POST requests with JSON payloads containing the trigger type, site ID, and changed data. Alternatively, access webhook settings in Site Settings > Integrations > Webhooks through the Webflow dashboard.

Rate limiting considerations

Humanitix enforces a hard limit of 200 requests per minute, returning HTTP 429 errors when exceeded. Webflow's rate limits vary by authentication method with 60 requests per minute for standard API tokens and 120 requests per minute for OAuth tokens. For bulk operations, implement exponential backoff and request queuing to stay within these limits.

API limitations

Humanitix's public API provides read-only access for retrieving event data, orders, tickets, and tags. Creating or updating events requires their beta API, available by contacting support@humanitix.com. This means that while you can pull Humanitix data into Webflow automatically, pushing changes from Webflow back to Humanitix requires either custom development with the beta API or using integration platforms that may have special API access arrangements.

Webflow's Forms API allows retrieving form submissions, but Humanitix's public API does not provide write endpoints to create attendees directly. For form-to-Humanitix integration, use integration platforms like Zapier, manually export form data for import via Humanitix admin, or contact Humanitix support at support@humanitix.com to request beta API access for write operations.

What you can build

Integrating Humanitix with Webflow creates event-focused websites that maintain brand consistency from discovery through ticket purchase.

• Professional event landing pages: Build custom event pages in Webflow with your complete brand identity using Humanitix's embedded checkout widgets. According to Humanitix's embedding guide, add the Embedded Checkout Widget via Webflow's Code Embed element to display ticketing directly on your page so attendees can purchase tickets without leaving your site.
• Automated event calendars: Display Humanitix events dynamically in Webflow using embedded collection widgets or automated CMS synchronization. The collection widget displays multiple events with live Humanitix data, while automation platforms like Zapier can automatically create Webflow CMS items when you add new events or update event details in Humanitix.
• Ticket availability displays with embedded widgets: Humanitix embedded widgets display current event information and ticket details directly on Webflow pages. When integrated through embedded checkout widgets or collection widgets, they show live ticket availability because the data comes directly from Humanitix servers on each page load.
• Multi-event showcase sites: Create portfolio sites displaying entire event series using Humanitix collection widgets or Webflow CMS API integrations. Regional tourism boards, festival organizers, and institutions managing 50+ events benefit from unified presentation with distributed management. For CMS-based implementations, be prepared to handle API rate limits and collection size effects on Webflow performance.