Your systems can now react in real time the second someone is checked in at your event. 🎟️ Eventtia will automatically push a check-in event to the endpoint of your choice, so badge printers, CRMs, lead-capture tools, access control systems and internal dashboards stay perfectly in sync without anyone exporting a single spreadsheet.

Why it matters: attendance data that used to arrive hours later — or never — now lands in your stack instantly, which means accurate live headcounts, faster on-site decisions and no more manual reconciliation after the event. ⏱️

• New check-in webhook trigger fires automatically when an attendee is checked in, including workshop and session check-ins
• A dedicated check-in payload delivers clean, structured attendee and checkpoint data to your endpoint
• Every attempt is recorded as a webhook delivery, so you can confirm what was sent, when, and whether it succeeded
• Clear delivery error handling makes failed calls easy to spot and diagnose instead of silently disappearing
• Fully available through the API, so you can create and manage check-in webhooks programmatically

The payment_created webhook is now triggered only when a payment actually transitions to the accepted state — not when a payment record is created in a pending, failed, or intermediate status. 💳✅

Previously, integrations could receive webhook notifications for payments that were never confirmed, leading to duplicate or premature downstream actions such as sending confirmation emails, issuing tickets, or syncing revenue data to external systems. 🙃

Why it matters: your connected systems now receive a single, reliable signal per confirmed payment, which means fewer false positives to reconcile, cleaner financial reporting, and no more manual clean-up of orders that were triggered by payments that never went through. 🎯

• Webhook now fires strictly on the transition to the accepted status
• Eliminates duplicate and premature payment_created notifications
• Keeps external integrations (CRMs, accounting tools, custom endpoints) in sync with real, confirmed revenue
• Covered by additional automated tests to prevent regressions 🧪

Creating an event through the API no longer fails when the attendance mode is sent as physical — it's now automatically understood as an in-person (offline) event. 🎉

Previously, sending attendance_mode=physical to the v3 and v4 event creation endpoints triggered an error and the event was never created, forcing integrators to guess the exact accepted value. That friction is gone: your integrations keep working with the terminology they already use.

• 🔁 The physical value is now mapped automatically to offline when creating events through API v3 and v4.
• 🛡️ Unrecognized attendance mode values are safely ignored instead of breaking the request, so a single bad parameter no longer blocks event creation.
• ✅ Added test coverage for event creation and attendance mode handling to keep this behavior reliable going forward.

Why it matters: fewer failed API calls and less debugging time for teams automating event creation, which means events get published faster and integrations stay stable. 🚀

Webhook signing secrets have been reworked so you can confidently validate that each incoming payload genuinely came from Eventtia and wasn't tampered with in transit. 🔐 Secrets are now managed more securely and consistently across the webhooks screen and the API, and existing webhooks were migrated automatically — no action needed on your side.

Why it matters: signature verification is usually the first thing a security review asks about, so this removes a common blocker when connecting Eventtia to internal or customer-facing systems. ✅

• Redesigned signing secret handling with a safer storage and retrieval flow
• Automatic migration of existing webhook signing secrets, so current integrations keep working
• Consistent experience between the webhooks management screen and the API
• Refreshed webhooks list view with clearer labels in both English and Spanish 🌎

Location and city selectors now support search queries, so you can type a few letters and jump straight to the option you need instead of scrolling through long lists. 🔎

This is especially useful for events with global audiences, where city and location lists can run into hundreds of entries. Faster selection means fewer abandoned registrations and cleaner, more accurate attendee data. ⏱️

• Searchable location loader in forms: type to filter available locations on the fly
• Searchable city loader: quickly narrow down cities without endless scrolling
• Improved query handling on the event data layer so results return accurately and consistently 🚀

The Attendees in Sessions Excel export now processes data in batches 🧱, so events with thousands of attendees and dozens of sessions generate cleanly instead of timing out or producing incomplete files.

This means organizers of large conferences can trust that the file they download is complete and accurate the first time — no re-running exports, no missing rows, no manual stitching of partial spreadsheets. ✅

• ⚙️ Batched processing for faster, more memory-efficient report generation
• 🧮 More consistent row and column handling in the generated spreadsheet
• 🛠️ Multiple accuracy and formatting refinements based on QA testing

Opening an attendee group that no longer exists, belongs to another event, or has no joinable attendees now returns a clean 404 Not Found page instead of an unexpected application error. 🎯

Previously, the edit screen tried to load attendees from a group that couldn't be found, which resulted in a confusing error page and an interrupted workflow. Organizers now get an immediate, understandable response and can continue working without wondering whether something broke on their account. ✅

• Attendee group edit requests for unknown or inaccessible groups now consistently return a 404 response 🚫
• Behavior is aligned with how events and public attendee group pages already handle missing records, so navigation feels predictable across the platform 🔄
• Expanded automated test coverage around missing, cross-event, and empty attendee groups to prevent regressions 🧪

Why it matters: fewer dead ends and error screens means less time spent troubleshooting and more confidence that broken or outdated links simply lead to a clear message rather than a failure. ⏱️

Exhibitor attendee pages now load reliably, even when a stand reservation is missing or no longer linked to the exhibitor's account. 🛠️

Previously, if a reservation ID was absent — or belonged to a different account — the exhibitor attendee edit page would throw a server error (500) instead of handling the situation gracefully. Exhibitors hit a dead end with no explanation and no way forward.

Why it matters: Exhibitors managing their team members during event setup can keep working without unexpected errors blocking them, and your support team stops fielding tickets for a page that simply wouldn't open. ✅

• Missing or invalid stand reservations now return a clear, properly handled access response instead of a crash 🚫
• Reservations belonging to another account are correctly rejected, keeping exhibitor data properly isolated 🔒
• Expanded automated test coverage around reservation edge cases to prevent regressions 🧪

Sponsor websites with long tracking URLs no longer break the form. 🔗 Previously, any sponsor website address longer than 255 characters triggered a server error and the whole sponsor record failed to save.

Why it matters: Marketing and sponsorship teams rely on long UTM and campaign tracking parameters to measure sponsor ROI. Now those links persist exactly as pasted, so you keep your attribution data and avoid re-entering sponsor details after an unexpected error. ✅

• The sponsor website field now supports long-form URLs, including full tracking and campaign parameters
• Submitting a sponsor with an extended URL no longer returns a 500 error
• Existing sponsor records are migrated automatically — nothing to do on your side

Sponsor website addresses are now validated before saving, with helpful, translated error messages shown directly on the form. ✍️

Why it matters: Catching a malformed link at entry time prevents broken sponsor logos and dead click-throughs on your event website — the kind of issue that's usually only discovered after sponsors complain. 🚫🔗

• Added validation on the sponsor website field so invalid entries are flagged immediately
• Inline guidance in the sponsor form clarifies the expected URL format
• Error messages are fully localized in English, Spanish, German and Arabic 🌍

Opening a mass message that wasn't targeted with an audience filter no longer breaks the page. 🎯 Instead of hitting an error, the message details now load normally and display an estimated reach of 0.

Previously, viewing a message with no filter applied triggered a server error, blocking organizers from reviewing their communication before sending it. Now the flow stays uninterrupted, so you can keep reviewing and sending messages with confidence. ✅

• Mass messages without an audience filter now show an estimated reach of 0 instead of returning an error
• The message detail page loads reliably in every scenario, filtered or not

Sending a test email from the Massive Messages tool no longer fails when the sample attendee doesn't have a QR code file available. 📧✅

Previously, the mailer tried to attach the example attendee's QR code without first confirming the file existed. That led to an unexpected server error in two common situations: when the sample attendee was an online attendee (who never gets a QR code generated) or when the temporary QR code folder had already been cleaned up by the scheduled file cleaner. On top of that, the resulting error page itself failed to render, leaving you with a confusing dead end instead of a clear message.

Why it matters: Test emails are the last checkpoint before a campaign goes out to thousands of attendees. Now that check always works, so you can preview and validate your messaging with confidence instead of chasing a mysterious error right before sending. ⏱️

• Missing QR code files are now safely skipped instead of breaking the test email
• Online attendees (who have no QR code) can be used as the example recipient without issues
• No more unexpected error screens after the temporary QR code folder is cleaned up
• Test email delivery remains unaffected for attendees who do have a valid QR code attached 🎟️

Opening the bulk email editor for an event you can no longer access — because it was archived or belongs to another organization — now returns a clean, expected "access denied" response instead of breaking the page. 🛡️

Previously, the email designer tried to load settings for an event that didn't exist, which resulted in a server error and a dead-end screen with no explanation. Now the permission check happens first, so you get clear feedback and can keep working without reloading or contacting support. ⏱️

• Bulk email screens now correctly return a 403 response when the related event is archived, deleted, or outside your organization
• Eliminated the server error (500) previously triggered by the email designer when loading a missing event
• Added automated test coverage to keep this behavior protected in future releases ✅

Registration forms are now validated as you edit them, so misconfigurations are flagged in the event settings screen instead of surfacing later as broken sign-up experiences. 🛡️

Why it matters: A single invalid form change can quietly break registration for every attendee who lands on your event page. Catching it at the moment of editing saves you from emergency fixes, lost registrations, and support tickets after launch.

• ⚠️ New validations run whenever registration form settings are modified, with clear inline messages explaining what needs to be corrected
• 🌍 Validation messages are fully localized in English, Spanish, French, German and Arabic, so every team member sees guidance in their own language
• 🎯 Refined wording and messaging based on QA feedback to make each error easier to understand and act on

Events now validate their end date automatically, so an event can no longer be saved with an end date that comes before its start date. 📅✅

Why it matters: Invalid date ranges are one of the quietest sources of chaos — they break agendas, registration windows and reporting long after the event has been published. Catching them at the moment of entry saves your team from last-minute cleanup and attendee confusion.

• ⛔ Events with an end date earlier than the start date are rejected at save time, with a clear inline error message.
• 🌍 The new validation message is fully translated across all supported languages, including English, Spanish, French, German and Arabic.
• 🧭 Wording was refined after QA review so the message tells organizers exactly what to correct, not just that something is wrong.

Your event's registration end date is now enforced correctly, with no confusing duplicate error messages and no unexpected blocks on draft registrations. 🗓️

Why it matters: Organizers rely on the registration end date to control capacity and planning deadlines. When that date behaves unpredictably, you either lose legitimate sign-ups or spend time chasing attendees who hit errors they shouldn't have seen. This fix removes that uncertainty entirely.

• ✅ Fixed a double validation that caused the same error to appear twice when an attendee registered near the registration closing date
• 📝 Draft attendee records are no longer blocked by the registration end date, so incomplete or in-progress registrations can be saved and completed without friction
• 🧪 Added regression coverage so the registration end date logic stays reliable in future releases

Group registrations now complete smoothly every time — even when there's no confirmed attendee yet to display in the summary. 🎉

Previously, the group registration success page could fail with a server error (500) when the confirmation summary tried to render without a valid attendee record (for example, when every attendee in the group was still in draft status). Registrants were left staring at an error page, unsure whether their registration had actually gone through. 😟

Why it matters: your attendees get a clear, reliable confirmation at the end of the sign-up flow, which means fewer abandoned registrations, fewer "did it work?" support tickets, and more trust in your event's registration experience. ✅

• Fixed a 500 error on the group registration success message when no confirmed attendee was available
• The confirmation summary now renders gracefully, skipping the personalized message instead of breaking the page
• Added automated test coverage so this edge case stays fixed in future releases 🔒

Your attendees sessions report now exports the correct primary registrant for every group registration. 🎯

When attendees register as part of a group, each session row needs to point back to the right primary registrant. A mismatch in that reference meant some exported rows showed incorrect or missing primary registrant information, forcing organizers to cross-check their spreadsheets manually before sharing attendance data.

• ✅ Fixed how the primary registrant is resolved in the attendees sessions Excel export
• 📊 Session attendance rows now consistently reflect the correct group owner
• 🧾 No more manual clean-up before sending reports to sponsors, speakers or internal teams

Why it matters: attendance reports are often the final word on who showed up and who paid for them — getting the primary registrant right means your post-event reporting, invoicing and follow-ups are trustworthy from the first export. ⏱️

Attendees who start a Stripe payment, abandon it, and come back to try again will no longer run into stuck or duplicated checkout sessions. 💳 Payments now resolve correctly even when several Stripe sessions exist for the same registration.

This matters because every failed or stuck payment is a registration you might never recover — and a support ticket for your team. Cleaner session handling means fewer abandoned carts and fewer manual reconciliations at the end of the day. ✅

• Fixed multi-session behavior so a new Stripe checkout attempt no longer conflicts with a previous unfinished one
• Improved how payment status is synced back from Stripe to the attendee's registration
• Hardened the payment flow against edge cases where a session expired or was left open in another tab
• Expanded automated test coverage around Stripe payments to keep these scenarios protected going forward 🧪

Attendees now receive a single, accurate invoice for their registration — no more duplicate invoices showing up for the same person. 🧾✅

Under certain conditions, simultaneous registration or payment events could trigger invoice generation more than once for the same attendee, resulting in duplicate records that had to be reconciled manually. Invoice creation is now serialized per attendee, so only one invoice can ever be generated for a given registration, even when multiple processes run at the same time.

• Duplicate invoices eliminated: invoice generation is now serialized per attendee, preventing race conditions during high-traffic registration moments 🔒
• Faster invoice lookups: a new database index on the invoice UUID speeds up retrieval and validation across the platform ⚡
• Cleaner financial reporting: your invoice totals, exports, and accounting reconciliations now reflect reality without manual cleanup 📊

Why it matters: Duplicate invoices create confusion for attendees and hours of manual reconciliation for your finance team. With this fix, your billing records stay clean and trustworthy from the moment a registration is confirmed.

Payment-related labels and messages are now translated across our supported languages, so attendees see checkout information in the language they selected instead of falling back to English. 🌍

For global events, trust at the payment step is everything — a sudden untranslated message is exactly the kind of friction that makes someone hesitate before entering their card details. Consistent localization keeps the checkout experience polished from start to finish. 🙌

• Added and refreshed payment translations for Arabic, Japanese, Korean, Dutch and more
• Consistent wording across all payment states, so attendees always know what's happening with their transaction

Signing in through SSO now works even when the link contains an unsupported or malformed language code. 🔐🌍

Previously, the SSO flow passed the locale value from the URL straight to the application without validating it. If that value wasn't a language your event actually supports — something that commonly happens with link scanners, email security tools, or manually edited URLs — the request raised an invalid locale error and users hit a 500 error page on /users/sso instead of reaching their event.

Why it matters: attendees and organizers clicking an SSO link can now get in reliably, instead of being blocked at the door by a broken URL parameter that had nothing to do with them. Fewer support tickets, fewer abandoned logins. ✅

• Unsupported or unrecognized locale values are now rejected safely instead of crashing the request 🛡️
• The SSO flow correctly falls back to the user's preferred language when the requested one isn't available 🗣️
• Locale handling is now consistent across the standard and SSO authentication paths 🔄

You can now pull a complete Attendees in Sessions report 📊 that shows which attendees registered for and attended each workshop or session of your program — all in one place, ready to filter and export.

No more cross-referencing registration lists with session rosters by hand: in a couple of clicks you get the attendance picture you need for capacity planning, speaker follow-up, certificates and post-event reporting. ⏱️

• 🔎 New report view under Program Reports listing attendees per session
• 🎚️ Dedicated filters so you can narrow results down to the sessions, dates and audiences you actually care about
• 🧾 Custom field support — attendee custom fields are formatted and included so your export matches the data you collect at registration
• 📥 Excel export of the full report, generated in the background so you can keep working while large files are prepared
• 🌍 Fully localized, including Arabic, Catalan, Italian, Korean and the rest of the supported languages

Once an attendee has checked in at your event, their registration is now locked against rejection and cancellation — so your on-site attendance records always reflect what actually happened. 🔒

Previously, an organizer (or the attendee themselves) could reject or cancel a registration even after the person had already walked through the door, leaving check-in data, badge records and reporting out of sync with registration status. This change closes that gap across every entry point.

What's new:

• 🚫 Rejection and cancellation actions are now blocked for any attendee with a check-in record
• 🖥️ The reject/cancel buttons are automatically disabled in the attendees table and the attendee side panel, so the action is clear before you click
• 👥 The same rule applies to bulk actions on attendee groups — checked-in attendees are skipped instead of silently cancelled
• 🌐 Self-service cancellation from the public registration pages is also prevented for checked-in attendees
• 🔌 The API (v3) enforces the same validation, so integrations and custom workflows stay consistent with the platform

Why it matters: your check-in numbers, attendance reports and post-event analytics stay accurate and auditable, and your team avoids the cleanup work that comes from reconciling cancelled-but-present attendees. ✅

Cancellation and rejection messages have been rewritten to be more precise about what is happening and why an action may not be available — and the new wording is available in all supported languages. 🌍

• ✍️ Updated cancellation and rejection text for attendees and organizers
• 🗣️ Translations refreshed across all locales, including English, Spanish, German, French, Catalan and Arabic
• 💡 Clearer explanation when an action is unavailable because the attendee has already checked in

Why it matters: attendees and organizers immediately understand the status of a registration without contacting support, reducing back-and-forth and confusion during busy on-site moments. 🙌

Reaching the right people just got easier. 🎯 Notification recipient queries now support richer workshop and session criteria, so you can target exactly the attendees you mean to reach — no more casting a wide net and hoping for the best.

Why it matters: fewer irrelevant emails for your attendees and less manual list-building for your team, which means higher engagement rates and more time back in your day. ⏱️

• Expanded the query options available when selecting event notification recipients, making workshop-based segmentation more flexible 🔍
• Enriched the workshop data returned by the API so recipient lists resolve faster and more accurately 🚀
• Improved consistency between workshop information shown in the platform and the audiences used for notifications ✅

Minimum and maximum workshop limits now behave consistently when configuring an event, so the rules you set are the rules that get enforced during registration. 🎟️

Why it matters: When workshop limits misfire, attendees either over-book sessions or get blocked from ones they should be able to join — and your team ends up fixing registrations by hand. This correction keeps capacity planning accurate from setup through check-in.

• 🔧 Fixed validation of the minimum and maximum number of workshops an attendee can select.
• 🌐 Updated the related messages across all supported event languages for clearer, consistent feedback.

German-speaking users get a more accurate and natural experience, with refreshed translations across several key areas of the platform. 🇩🇪

We reviewed and updated the German labels used throughout modules, event pages, security settings, and speaker management to better match how the terms are actually used in practice.

Why it matters: precise terminology means less second-guessing for your team and your attendees, fewer support questions, and a more polished, professional experience for German-language events. ✨

• Updated wording for application modules
• Updated wording for event page modules
• Updated wording in security settings
• Updated wording in speaker management

Notification emails now respect your custom SMTP configuration, so every automated message your attendees receive is delivered through your own mail server and sender identity. 📧

Until now, custom SMTP settings applied only to part of your outbound communications, which meant some notifications still went out under default sending infrastructure. With this release, the notification mailer honors the same SMTP credentials you've already configured for your account.

Why it matters: consistent sender domains improve deliverability, reduce the chance of your messages landing in spam, and keep every touchpoint fully branded — no more mixed sender addresses confusing your attendees. 🚀

• Notification emails now route through your configured custom SMTP server
• Consistent sender identity across all outbound event communications
• Better deliverability and inbox placement thanks to your own domain reputation
• No action required if you've already set up custom SMTP — it just works

When you embed your registration form on an external site, the iframe now reports its own content height and adjusts automatically as the form grows or shrinks. 📐

Why it matters: no more awkward inner scrollbars or cut-off fields on your corporate website — the form simply fits, on desktop and mobile alike, which means fewer abandoned registrations. ✅

• Automatic height reporting via post-message between the embedded form and the host page
• Improved public layout handling for embedded content
• Cache control adjustments so the resize script always loads the latest version

The public event calendar widget now handles empty date pickers gracefully instead of failing to load. 📅

Previously, when a visitor opened the calendar without selecting a start or end date, the browser sent an "Invalid Date" value to the API. That unparseable value raised an error and returned a 500 response, leaving your public calendar blank for anyone browsing your events.

Why it matters: your event calendar is often the first thing prospective attendees see — a blank page means lost registrations. Now the calendar always renders, whether or not a date range is applied. 🎯

• Invalid or empty start_date / end_date parameters are now safely ignored instead of crashing the request
• The calendar simply returns all upcoming events when no valid date bound is provided
• Valid date ranges continue to filter exactly as before — no change to existing behavior
• Added test coverage to prevent this regression from returning

Purchase item names and descriptions now accept the full range of Unicode characters, so Japanese, Chinese, Korean, and 4-byte characters like emoji no longer cause creation to fail. 🌏

Previously, these fields were stored using a legacy latin1 encoding, which silently rejected any character outside the Western alphabet. Organizers selling tickets, add-ons, or merchandise to international audiences would hit an error the moment they tried to save an item name in their local script. ✍️

Why it matters: teams running events in Asian markets can now name their purchase items exactly as attendees expect to see them — no transliteration workarounds, no failed saves, and no confusing checkout experiences. 🧾

• Migrated the purchase_items table to utf8mb4 encoding
• Full support for CJK characters and 4-byte UTF-8 (including emoji 🎉) in item names and descriptions
• Existing purchase item data is preserved through the migration

Attendees now receive an automatic notification whenever their scheduled activities change — no more manual follow-ups or attendees showing up to a session that moved. 📬

Why it matters: agendas shift constantly during event prep, and every unannounced change turns into a support email, a confused attendee, or an empty seat. Automating this keeps everyone aligned with zero extra work for your team. ⏱️

• Automatic activity-change notifications are now sent to attendees when their registered activities are updated
• Notifications are triggered directly from sessions and workshops, so changes made in either place reach attendees immediately
• Covers attendee registrations, workshop assignments, and session updates across the API, ensuring consistent messaging no matter where the change originates
• Reduces manual communication effort for organizers and cuts down on day-of confusion at check-in 🎟️

Requests to the API using a simple ?page=1 parameter no longer fail — pagination now accepts both scalar and JSON:API-style page parameters. 🎉

Previously, our pagination logic assumed every request followed the JSON:API convention of page[number] and page[size]. Any integration sending a plain ?page=2 passed a value the handler couldn't interpret, which resulted in an error instead of a response. That meant developers had to rewrite working code just to match an undocumented expectation.

Why it matters: your integrations keep working the way they were written, so you spend less time debugging opaque API errors and more time building. 🚀

• ✅ ?page=1 and other scalar values are now correctly treated as the page number
• ✅ Existing page[number] / page[size] hash parameters continue to behave exactly as before — no migration needed
• ✅ Added test coverage around pagination parameter handling to prevent regressions

Saving or updating an attendee no longer returns an error when a custom attachment field is empty or was already cleared. 🎉

Previously, the system attempted to delete a file that didn't exist, which resulted in a 500 error and blocked the entire save. Now blank attachment data is safely skipped, so attendee records update cleanly every time.

• ✅ Attendee records with empty custom attachment fields now save without errors
• 🗑️ Clearing an attachment twice no longer breaks the request
• 🛡️ Added test coverage to keep this behavior stable going forward

Why it matters: Organizers and attendees can complete registrations and profile edits without hitting unexpected failures, removing a frustrating blocker in the middle of data entry.

Pending Stripe payments now sync reliably, even when an incomplete payment record sneaks into the queue. 💳✅

Previously, a single payment created without a Stripe checkout session ID could crash the entire background job that verifies pending payments. When that happened, every other payment in the batch was left stuck in a pending state — meaning registrations weren't confirmed, and your team had to chase down payment statuses manually.

What changed:

• ⏭️ Payments missing a Stripe checkout session identifier are now skipped automatically instead of breaking the verification process.
• 🛡️ The status check returns early for orphaned payment records, so one bad row can no longer stop the whole batch.
• 🔁 All other pending payments in the same batch continue to be verified and updated as expected.

Why it matters: your attendees get their payment confirmations on time and your finance and operations teams stop spending time reconciling payments that silently stayed pending. 🎯

You can now use emojis and other special characters 🎉 in module content, speaker profiles, and lead information without running into save errors. Previously, adding a character like 🚀 or certain non-Latin symbols would cause the save to fail with an unexpected error, forcing you to strip your content down to plain text.

Why it matters: Your event content stays on-brand and expressive — no more losing work or rewriting descriptions because a single emoji broke the save. ✨

• Text fields across app modules, speakers, and leads now fully support 4-byte UTF-8 characters (emojis, extended symbols, and a wider range of international scripts) 🌍
• Resolved the StatementInvalid error that appeared when saving content containing these characters ✅
• Existing content is preserved and migrated automatically — no action needed on your side 🔄

Guest pages no longer return a confusing 403 Forbidden error when the related event can't be found. 🎯

Previously, if a guest link pointed to an event that didn't exist (or was no longer available), the guests area tried to read attendee information from a missing event and failed with a misleading permission error. Organizers and guests were left thinking they lacked access, when the real issue was simply a missing event.

Why it matters: fewer false "access denied" reports means less time spent troubleshooting permissions and faster answers for your attendees. 🚀

• Guest requests for missing events now fail gracefully instead of raising an unexpected error
• No more misleading 403 responses that suggest a permissions problem
• Added test coverage to keep this behavior stable going forward ✅

Sending a test email from a bulk notification no longer fails when your campaign targets a very large audience. 📧

Previously, requesting a test email triggered a full load of every filtered recipient just to confirm the list wasn't empty — which could exhaust the database's sort memory and cause the request to error out on big events. Now the system only fetches a single sample recipient, and if that lookup still can't complete, the test email is sent anyway without an example recipient.

Why it matters: organizers running large-scale campaigns can preview their emails before hitting send, instead of being blocked at the exact moment the stakes are highest. ✅

• Test email checks now retrieve a single recipient instead of the entire filtered attendee list
• Graceful fallback keeps the test email flowing even if the sample lookup fails
• Added error handling in the bulk notifications email controller for a cleaner, more informative response instead of an unexpected failure 🛡️

Requesting the list of cities for a region that doesn't exist now returns a clear 404 Not Found response instead of failing with a server error. 🗺️

Previously, calling GET /api/v3/countries/:country_id/regions/:region_id/cities with an invalid or placeholder region_id (such as the example value shown in our API docs) caused the endpoint to return a 500 error, making it hard to tell whether the problem was on your side or ours.

Why it matters: integrations can now handle missing regions gracefully with standard error handling, instead of retrying or alerting on what looked like an outage. Fewer false alarms, faster debugging, and a smoother experience when exploring the API. ✅

Activities now validate multiple sessions correctly at the session level, so misconfigured schedules are caught the moment you save instead of surfacing later as booking errors. 🗓️

Why it matters: Catching session conflicts up front prevents attendees from registering for overlapping or invalid sessions, saving your team from manual clean-up and last-minute schedule fixes on event day. ✅

• Multi-session rules are now enforced consistently at the activity level, including when activities are created or updated through the API 🔌
• Clear, localized validation messages so organizers know exactly what to correct — available in English, Spanish, French, German, Arabic and more 🌍

You can now pull real-time attendance and capacity numbers for your event sessions through a brand-new Sessions Stats endpoint in the API (v4). 📊

Instead of exporting registration lists and counting rows in a spreadsheet, your team (and your integrations) can request session-level statistics directly and see exactly how each workshop or session is performing. That means faster room-capacity decisions on site, fewer manual reports, and dashboards that stay in sync with what's actually happening at your event. ⏱️

• New sessions/stats endpoint available under the API v4 🔌
• Session data exposed through a lightweight serializer, so responses stay fast even for agendas with many sessions ⚡
• Fully documented in the OpenAPI/Swagger specification, making it easy for developers to integrate without guesswork 📘
• Covered by automated tests to keep results accurate and reliable ✅

When a payment can't be processed, attendees now see a readable, translated message explaining what went wrong instead of a generic or silent failure. 🚨

We also tightened up how missing or invalid gateway credentials are reported, so misconfigurations surface immediately during setup rather than at the moment a real attendee tries to pay.

• 💬 User-facing error messages available in English and Spanish.
• 🔑 Explicit errors raised when SIRE credentials are missing or incomplete.

Why it matters: Attendees know whether to retry or contact support, and your team stops fielding "the payment page just stopped" tickets with no context. ⏱️

You can now check in multiple attendees at once through the new batch check-in endpoint in API v4 — one request, one response, no more looping through attendees one by one. 🎟️

For teams running high-traffic entrances, this removes the biggest bottleneck at the door: instead of firing a separate request for every badge scan, your access-control app, kiosk, or integration can push a full batch and get a consolidated result back. Fewer round trips means faster lines, less load on your integration, and far less custom retry logic to maintain. 🚀

• New batch check-in endpoint available in API v4 for attendees
• Per-attendee results so you can tell exactly which check-ins succeeded and which need attention
• Localized validation messages shipped across all supported languages, so errors are readable for every team no matter where they operate 🌍
• Built on a dedicated batch check-in service designed to handle large volumes reliably during peak arrival windows

Invoice numbers are now generated one at a time, so every invoice issued for your event gets its own unique, sequential number — even when dozens of attendees are registering and paying at the exact same moment. 🧾

Previously, when two purchases landed at the same instant, the invoice counter could hand out the same number twice, resulting in rejected invoices or duplicated records that had to be reconciled by hand. That's now resolved.

Why it matters: Clean, gap-free invoice sequences are a hard requirement for accounting and tax compliance in most countries. This fix removes an entire class of manual cleanup work for your finance team after high-traffic registration pushes. 💰

• Invoice sequence increments are now fully serialized, so two concurrent purchases can never claim the same number
• If a collision is detected at the database level, invoice creation automatically retries and lands on the next available number
• Applies transparently to all event invoices — no configuration or action required on your side ✅

Attendee check-in processing is now noticeably leaner, thanks to optimized database access and smarter caching behind the scenes. ⚡

We eliminated redundant queries when loading attendee data and improved how attendee types are cached during check-in operations. In practice, that means quicker responses when registration desks are at their busiest — the exact moment when every second of delay turns into a longer queue at the entrance. 🏃‍♀️

Registration forms now quietly ignore invalid or unrecognized attendee_type values in the URL instead of failing, so attendees always reach a working form. 🎟️

Previously, if a registration link carried a malformed, out-of-range, or copy-pasted attendee type parameter that didn't belong to the event, saving a draft registration could return a server error (500) and stop the sign-up in its tracks. Now the attendee type is only applied once it has been verified as belonging to that specific event — otherwise the system falls back to the default behavior and registration continues normally.

• ✅ Invalid or junk attendee_type query parameters are ignored instead of triggering an error
• 🔒 Attendee types are validated against the event before being assigned, preventing cross-event mismatches
• 💾 Draft registrations save reliably, even from broken or edited links
• 🧪 Added regression coverage on the public registration flow to keep this from returning

Why it matters: Broken registration links are one of the fastest ways to lose an attendee. This fix means a mistyped or truncated URL shared over email, chat, or social media still leads to a usable form, protecting your conversion rate and saving your team from chasing avoidable support tickets. 🚀

Downloading an Excel export that hasn't finished generating now returns a clean 404 page instead of an unexpected application error. 📄

Previously, if an organizer clicked the download link before the export file was actually stored, the system tried to serve a file that didn't exist yet and crashed with a TypeError. That meant a confusing error screen and no clear indication of what went wrong or what to do next. 😬

Why it matters: organizers get a predictable, understandable response instead of a broken page — so they know the export simply isn't ready yet and can retry in a moment, without filing a support ticket or worrying that their data was lost. ✅

• Requests for exports with no stored file now render the standard 404 page
• Eliminates the TypeError raised when attempting to send a nil file
• Added regression test coverage to keep this behavior locked in 🔒

Every endpoint in the v4 API now ships with richer, more precise descriptions — making the reference easier to read for humans and far more usable for AI assistants and MCP-based tooling. 🤖📚

We went through the v4 specification and rewrote vague or incomplete definitions so each resource and parameter explains what it is, what it returns, and when to use it:

• Improved descriptions for attendees, attendee types, and attendee type custom fields
• Clearer definitions for checkpoints and events endpoints
• Language optimized so MCP clients and AI agents can correctly interpret and call our API
• Consistent phrasing across the entire v4 surface for easier scanning

Why it matters: Better documentation means faster integrations and fewer support tickets — your team (and your AI coding assistant) can understand the Eventtia API without reverse-engineering responses. ⏱️✨

We polished several areas around workshop registration and attendee display so the experience feels more consistent for both organizers and participants. ✨

Small inconsistencies in how workshop form fields and public attendee cards render can create confusion at exactly the wrong moment — when someone is trying to register or find a colleague. These refinements remove that friction and keep your public pages looking exactly as intended. 🎯

• 🧩 Improved handling of workshop form field definitions
• 🪪 Refined rendering of the public attendee card
• ⚙️ Updated event parameters view for clearer configuration