boilerloop

Build with BoilerLoop

Keep your club website and use BoilerLoop as its event backend.

BoilerLoop, official embed
Cover image for Nightshift

Nightshift

Tue, Oct 20, HIVE, 2 going

View event & RSVP ↗

Canonical event evt-h84ees

Start with an integration prompt

Copy the prompt and paste it into the coding assistant running inside your existing club website repository. It preserves your website’s event creation and editing screens, preview and draft controls while connecting supported actions to BoilerLoop. It also covers public events, RSVP forms, calendars and verified check-in, and keeps unsupported website behavior on its existing path. Follow its instructions for the one-time server key and configuration setup.

Connect your existing website: copy the task to connect your event creation, editing, RSVP and calendar screens.
Read the prompt
Implement a complete BoilerLoop integration in this website repository in one pass. Use BoilerLoop (https://boilerloop.com) as the event backend for our club's own website. Club slug: {slug}. Inspect the code, make the changes, test them, and leave a working integration. Do not stop at a plan, API examples, an isolated widget or an unconnected adapter. BoilerLoop is the source of truth for events, registrations and attendance.

IMPLEMENTATION TASK:
- Inspect repository instructions, framework, routes, event components, auth, analytics and existing event/email/calendar code before editing. Reuse the site's design, components, URLs and accessibility patterns. Choose sensible defaults and complete the work without asking me to design each screen.
- Preserve the website's existing staff event creation and editing flow. Keep its admin URLs, form layout, date/time behavior, flyer picker/cropper, tag selector, question editors, live preview, Save Draft, Publish confirmation and published-event editing. Replace the persistence/API calls behind those controls with BoilerLoop server-to-server calls. Existing staff should continue creating events on their own website, without being redirected to a different admin interface.
- Connect every existing event entry point: homepage upcoming events, the event list and its search/tag/calendar views, event detail pages, and other active event landing pages. Create an Events page and event details if absent. Use one shared typed adapter and presentation mapping so these surfaces agree.
- Use the same source-aware read functions for staff pages and existing authenticated JSON list/detail routes. Keep draft/search filters and response contracts. After creating a BoilerLoop draft, read it through the website's existing staff APIs and UI; updating pages while leaving their APIs on legacy-only data is incomplete.
- Use concise invitation and action copy in the website's style. Keep backend setup and implementation explanations in developer/staff documentation. Avoid em dashes and dot separators in newly written user-facing copy.
- List upcoming and past events, support pagination, and render title, description, image, local date/time, location, tags, capacity and availability. Exclude drafts from public pages; make cancellation unmistakable and disable RSVP for canceled or ended events. Preserve working event URLs with an explicit old-to-BoilerLoop ID mapping when needed.
- Implement an RSVP form in the site's own design with name, email and the event's current registration questions. Send it to our own server, then show the actual confirmed or waitlisted result. Preserve answers on failure, prevent repeated clicks and make retry clear. Do not display a confirmed RSVP before the API succeeds.
- Support short_text, long_text, single_select, multi_select and checkbox questions. Use question IDs as answer keys; selections use the supplied option strings, multi_select uses string arrays, and a checked confirmation checkbox sends the string "true". Respect required fields and show error.details.errors beside the relevant question. Associate each input, textarea and select with its question using a label or aria-labelledby; a fieldset legend alone does not label a text control. Verify accessible names in the rendered form and complete every question type in browser tests.
- After RSVP, show the resulting status and a clear link to the canonical BoilerLoop event page for verified account access and RSVP management. If our site already has verified login, preserve its own-RSVP status, cancellation and answer-edit/backfill controls and routes for BoilerLoop events using authorized server code. The canonical link is an additional option; do not replace those existing controls with a redirect, leave their routes querying only the legacy database, or return an unsupported-operation error for an API capability that exists. A site without verified identity should use the canonical page rather than invent identity verification.
- For co-hosted events where this club is not the primary host, link to the canonical event RSVP page; our club key cannot write registrations for another primary host. A management key also does not enforce participant eligibility: our server must validate the current viewer for restricted RSVP, or use the canonical BoilerLoop flow.
- Add Add to calendar and Subscribe to club calendar controls using the returned calendar links and the club feed. Explain any confirmed-registration invitation only when delivery is known to be configured; public event data does not report delivery configuration, and registration success does not prove an email was sent. A waitlisted person has not been promised a spot. BoilerLoop owns invitation sending, updates and cancellations.
- Keep staff tools on the existing website and enforce its current staff permissions. For each event offer https://boilerloop.com/checkin/{eventId}/display for the printable QR presentation. Only if this website has no staff event tools, use https://boilerloop.com/workspace/{slug} as the default management entry. Do not replace an existing create/edit/publish flow with workspace links or silently remove controls to make the integration appear complete.
- Preserve existing page-view and campaign analytics. Fire RSVP success analytics only after a successful response, distinguish waitlist from confirmed, and avoid duplicates on retries. Forward bl_promotion from a generated link as promotionLinkId on successful RSVP; the backend validates its club and event. Do not treat attribution as consent.
- Cover loading, genuinely empty results, unavailable service, not found, full/waitlisted, canceled and invalid-answer states on desktop and phone. An API outage must offer retry rather than look like no upcoming events. Use the event timezone for visible dates and resolve returned relative URLs against the BoilerLoop origin.

SERVER SETUP AND EXISTING DATA:
- Add documented configuration BOILERLOOP_ORIGIN=https://boilerloop.com, BOILERLOOP_ORG={slug} and server-only BOILERLOOP_API_KEY. Add example environment entries without secrets. Do not use a public-prefixed variable for the key. A static-only site uses canonical RSVP links until it has a server endpoint; do not pretend a browser can hold the key.
- A localhost or 127.0.0.1 origin works only in the matching local development environment. For deployment, configure the publicly reachable BoilerLoop HTTPS origin; do not copy a local origin into the hosted website's production configuration.
- Build server-side code with explicit timeouts, safe error parsing, validation, rate limiting and origin/CSRF protections appropriate to this site's forms. Reuse the repository's trusted origin/proxy configuration; test same-origin forms at the documented development URL as well as rejection of cross-origin writes. Do not assume a framework request.url always matches the browser origin or weaken CSRF checks to pass a test. Respect Retry-After for 429. Do not blindly retry writes; preserve a user's draft and return actionable errors. Keep private reads uncached across users and keys out of logs.
- The key authorizes the club, not whoever calls our website. Before using it, authorize staff actions, restricted event access and cancellation on our server. A typed email, client-supplied registration ID, or a duplicate RSVP response is not proof that someone owns that registration. Do not turn our server adapter into a public management proxy.
- Preserve existing login, member tools and unrelated data. Skip explicitly retired features rather than rebuilding them. Inventory unsupported access rules, hidden locations, question types, recurring rules and custom landing content. Tags are labels, not membership permissions. Keep unsupported behavior safely on its existing path and document the gap instead of dropping it or exposing restricted data.
- Inspect the actual database schema, environment bindings and existing data-access helpers before choosing an availability check. Never guess a conventional environment variable name. BoilerLoop configuration does not mean existing data was migrated. Preserve unmapped source events on every existing list, detail, landing page and staff editor, with source-aware routing; only mapped events switch to BoilerLoop. A source database outage must be visible, not silently converted to an empty legacy list. Test preservation using the repository's own configured variable names and representative unmapped records.
- Preserve the current editor with the lifecycle endpoints below. Event creation always makes a draft. Publish explicitly after preview; unpublish explicitly to retain RSVPs and withdraw invitations. Support flyers, event types, online/registration/slides links, unlisted direct-link events, hidden locations and conditional questions. Preserve unsupported individual co-host or cohort/staff rules on their existing path. Never silently broaden access or create duplicate events to simulate publishing.
- Club API keys read authorized application data through the documented endpoints, not arbitrary SQL or the entire underlying database. events:read covers this club's hosted/co-hosted events; attendees:read covers its authorized event registrations/check-ins, and sensitive answers require attendees:sensitive. contacts:read and members:read separately grant this club's email contacts and member directory. Marketing subscription status is not membership. Global profiles, other clubs' records, private event answers and account credentials are not included in those directory permissions.
- Do not automatically import records, overwrite event IDs, delete historical RSVPs, change database schemas, deploy, or send real messages. If existing events need migration, prepare an explicit mapping and a dry-run migration/cutover plan for approval. Never run both old and BoilerLoop registration or calendar senders for the same integrated event. Until every required staff action is supported, keep affected events entirely on their existing backend; do not split an event's reads and writes across two sources. Keep caches/read models disposable rather than a second writable event source.
- If the key is unavailable, finish the implementation with mocked tests and visible setup errors, and identify the exact key scopes and environment values needed. Never fabricate a key, fake live RSVP success or leave TODOs for the core integration.

READ (public, no credentials):
- GET https://boilerloop.com/api/v1/events/evt-h84ees: event details, timing, location, capacity, availability, status, visibility, registration questions, url and calendar links. JSON responses wrap the result in data.
- GET https://boilerloop.com/api/v1/events/evt-h84ees/calendar[?series=true]: ICS.
- GET https://boilerloop.com/api/v1/organizations/{slug}/events?scope=upcoming&page=1&limit=10: the club's public events.
- The event list accepts scope upcoming, past or all; page starts at 1, limit is 1-50. JSON is {data:[...],pagination:{page,limit,total,hasMore}}. Follow hasMore when loading further pages or building a complete calendar/filter dataset.
- GET https://boilerloop.com/api/v1/organizations/{slug}/calendar: subscribe to the club's public calendar feed.
- These return public events only; restricted events are 404 regardless of cookies. ETag / If-None-Match and read-only browser CORS are supported.
- Render image.url against https://boilerloop.com, using its width/height and a placeholder if loading fails.

MANAGE (server-to-server only):
- Create a club key in Workspace → Integration → API keys: Authorization: Bearer be_live_… . Available scopes: events:read, events:write, registrations:write, attendees:read, attendees:sensitive, contacts:read, contacts:write, members:read, marketing:read, marketing:write, marketing:send, imports:write. Marketing management does not authorize sending; only request marketing:send when deliberately scheduling or enabling messages. Request only needed scopes: registrations:write for on-site RSVP, events:read for authorized restricted reads, events:write for existing staff editing, attendees:read for private attendee tools, contacts:read for email contacts, and members:read for the member directory. attendees:sensitive is optional and must not be requested by default.
- Call management routes only from our own server-side code using a server environment variable. Authorize staff actions and validate/rate-limit forms on our server. No management CORS.
- GET https://boilerloop.com/api/v1/manage/events lists our club's events, including restricted events (events:read). GET /api/v1/manage/events/evt-h84ees reads one.
- POST https://boilerloop.com/api/v1/manage/events creates an event (events:write): {title,description,startsAt,endsAt,location,capacity,visibility,tags,status}. Use ISO dates, 0-5 tags and visibility public/purdue/invite/members. Capacity is a required integer from 1 to 5000, not null, blank or unlimited. Give the existing editor a visible valid default and inline validation. Test saving a brand-new draft using the form defaults and test clearing or exceeding capacity; do not only test a hand-written API payload. The API always creates a draft, even when scheduled is supplied. Supply externalId for the source website event ID, and resolve it with GET /api/v1/manage/events?externalId={sourceId} on retry.
- PATCH https://boilerloop.com/api/v1/manage/events/evt-h84ees edits fields or cancels with {status:"canceled"}; it cannot publish a draft or unpublish a live event. Writes require our club to be the primary host.
- POST https://boilerloop.com/api/v1/manage/events/evt-h84ees/registrations with {email,name?,firstName?,lastName?,answers,externalId?,participantExternalId?,promotionLinkId?} (registrations:write). Prefer explicit firstName/lastName from the website form; both are required when using structured names. The legacy name field remains supported; never guess name components by splitting it. Return the actual going/waitlist status and registration id. Duplicate active email+event submissions return the existing registration; capacity, waitlist and question rules are enforced.
- DELETE https://boilerloop.com/api/v1/manage/events/evt-h84ees/registrations/{registrationId} cancels a registration (registrations:write).
- GET https://boilerloop.com/api/v1/manage/events/evt-h84ees/publish-preview, then POST /publish on that event path (events:write for preview and publish). GET /unpublish-preview, then POST /unpublish returns a scheduled event to draft without deleting RSVPs (both require events:write). POST /change-preview with proposed editable fields estimates messages before PATCH. Preview mode is publish for publication and update for edits or unpublishing; do not infer mode values from endpoint names. Previews are estimates, never delivery promises. Render a concise human-readable summary of changes and affected recipients in the existing confirmation UI; do not display raw JSON or backend field names as the primary preview. Review existing editor and confirmation copy for provider-specific promises: do not say Google/Outlook invitations or emails will be delivered unless that delivery is actually known to be configured for this event. Preserve separate legacy behavior where it still applies.
- POST https://boilerloop.com/api/v1/manage/events/evt-h84ees/duplicate with {startsAt,endsAt} creates a new draft. DELETE the event path removes it. GET/POST/DELETE /image reads, uploads or removes a flyer (read/write respectively); POST is multipart FormData with image or flyer, raster JPEG/PNG/WebP, maximum 5 MB. Do not infer private storage locations.
- Additional editable event fields: eventTypeId, checkinQuestionsOverride, meetingUrl, registrationUrl, slidesUrl, hideLocationUntilRsvp, listed, checkinEnabled and websiteUrl. URLs must be absolute HTTPS without embedded credentials; websiteUrl must share the club website origin. Unlisted events stay available by direct link with normal eligibility, while listed=false hides them from listings. Hidden locations and meeting links are visible only after confirmed RSVP or to authorized staff; redact management data before public rendering.
- GET/POST /api/v1/manage/event-types and PATCH /api/v1/manage/event-types/{typeId} (events:read/write). Types belong to this club, can be renamed/archived/restored and have reusable check-in question defaults. checkinQuestionsOverride=false inherits the type; true uses the event's own questions. Actual previous check-ins in that type determine visits, not RSVPs. Untyped events retain club-wide attendance history.
- Questions additionally support hidden:boolean, dependsOn:{questionId,value} referencing an earlier choice question, visitNumber:1-5 on check-in only (5 means fifth and later), audience:everyone/first_visit/returning and presentation:radio/dropdown for single_select. Supply purpose and sensitive; sensitive questions stay optional. Preserve question IDs, purpose, sensitivity and original answer snapshots. Do not overwrite existing sensitivity with false when an editor lacks that control. Render only reachable, visible conditional questions and clear stale dependent answers when a parent changes.
- GET https://boilerloop.com/api/v1/manage/events/evt-h84ees/registrations?email={verifiedEmail} and GET /registrations/{registrationId} require attendees:read. PATCH /registrations/{registrationId} edits name/answers (registrations:write). Writes alone do not grant answer reads. Sensitive data additionally requires attendees:sensitive. Authorize ownership using the website's verified account or provider-confirmed email proof, never a browser verified:true flag.
- Registration and attendee reads include externalId, participantRef and visitNumber for club-specific source mapping and actual attendance history. Store the source-event/source-RSVP mapping server-side. participantExternalId links a website person only within this club and does not prove ownership or verify aliases.
- GET https://boilerloop.com/api/v1/manage/events/evt-h84ees/checkin (events:read) returns url, qrSvg and displayUrl for the same stable signed check-in code. Render the returned qrSvg, or encode the returned signed url as a QR image, directly in the website's existing staff presenter. displayUrl requires a separate verified BoilerLoop staff session: it is an optional shortcut, not an iframe or replacement for the website presenter. The club key and website login do not authenticate a browser on BoilerLoop. Keep the local presenter behind the website's own staff authorization; no attendance write endpoint.
- GET https://boilerloop.com/api/v1/manage/events/evt-h84ees/attendees returns registrations and check-ins (attendees:read; attendees:sensitive for sensitive answers). Reads require primary hosting or an explicit co-host grant.
- GET https://boilerloop.com/api/v1/manage/contacts?page=1&limit=50 reads this club's email contacts (contacts:read); search, tag and status filters are supported. Respect subscribed/pending/unsubscribed/suppressed status; reading a record does not grant permission to email it.
- GET https://boilerloop.com/api/v1/manage/members?page=1&limit=50 reads this club's member directory (members:read); search is supported. Keep these results server-side or in an authenticated club staff interface. A subscriber is not automatically a member, and a member is not automatically subscribed.
- Directory lists return {data:[...],page,limit,total,organization}; fetch further pages while page * limit < total. page is 1-1000, limit is 1-100 (default 50), search is at most 100 characters, and contact tag is at most 24 characters. Invalid values return 400. Contact fields are id,email,name,tags,status,consentSource,consentAt,unsubscribedAt,createdAt,updatedAt. Member fields are a club-specific id,name,emails,rosterEmails,teamRole,registered. Other verified aliases, global person IDs, private staff notes and confirmation tokens are excluded.
- RESPONSE CONTRACTS: event CRUD, publication and registration JSON results use {data:...}. The publish-preview, change-preview and unpublish-preview endpoints instead return the top-level object {mode,changes,emails,calendar,community,warnings}, with no data wrapper. Check-in GET also returns top-level {url,qrSvg,displayUrl}. Image GET and calendar GET return binary/text, not JSON. Marketing responses are endpoint-specific; do not apply a universal data unwrap. Use separate typed parsers that validate each endpoint contract. Errors are {error:{code,message,details?}}; question validation uses error.details.errors keyed by question ID.
- Public event hosts contain slug, name and role; management event hosts contain orgId and role, with display information in hostOrgs. Resolve the primary host using the correct projection. Never return the full management event or attendee list to a public browser; project only the fields the current viewer may see.
- Draft and restricted flyers are private. A public image URL does not authenticate website staff on BoilerLoop. For editor previews, add a website staff-authorized image endpoint that reads GET /api/v1/manage/events/{id}/image with the server key and returns the bytes privately; use that URL in the editor. Published public pages can use the public image URL. Test upload, preview after reload and removal with only the website login, plus anonymous denial of the draft image proxy. Never attach keys to image URLs or expose private bytes publicly.
- Never put a management key in browser JavaScript, HTML, a client bundle, a query string or a repository. Never invent a key value. If missing, ask me to create one.

MARKETING AND MIGRATION (server-only):
- GET /api/v1/manage/marketing/contacts requires contacts:read; POST/PATCH/DELETE and tags writes require contacts:write. contacts/import previews CSV mapping before committing. A new address without attested consent may queue confirmation and additionally requires marketing:send; import never treats an RSVP as marketing consent. Preserve unsubscribe and suppression status.
- GET/POST /api/v1/manage/marketing/campaign-groups, GET/PATCH/DELETE /campaign-groups/{id}, POST /campaign-groups/{id}/emails and GET/POST /campaigns create/edit draft campaigns with multiple independently editable emails. Read requires marketing:read, mutations marketing:write. Use /campaigns/{id}/preview and /count before explicit /schedule; scheduling or retry also requires marketing:send. Creating drafts never sends. For draft/group/email creation, supply a stable Idempotency-Key across identical retries; changed payloads need a new key.
- GET /api/v1/manage/marketing/automations and POST /automations/preview show defaults and event overrides. POST /automations/preview renders a catalog message with {kind,eventId?,subject?,body?,useDefault?}; useDefault:true previews an unsaved reset to built-in wording. PUT updates configuration with marketing:write plus marketing:send because enabling a rule can activate sending. Inspect the exact schema before adapting an existing drip system; unsupported advanced per-person rules must remain explicitly deferred and must not run in parallel.
- GET /api/v1/manage/marketing/promotion provides links, posts, reusable plans and analytics (marketing:read). POST with {action:"create_link",eventId,channel,label,groupId?} generates an event-specific link (marketing:write); supported channels are instagram,discord,slack,poster,email,linkedin,other. Supply an Idempotency-Key header and reuse it only for identical retries. GET /api/v1/manage/marketing/promotion/links/{id}/qr returns downloadable SVG (marketing:read). Other promotion actions support posts and reusable plans; inspect their exact payloads in the docs. Arbitrary external destinations are not supported.
- Promotion links redirect to a same-origin configured event websiteUrl with bl_promotion attribution; otherwise they go to BoilerLoop. Analytics exclude detected bots and report low-sample timing warnings. Do not claim Instagram account metrics or native provider insights are integrated.
- For historical migration, prepare a read-only export and explicit source event, registration and participant mappings. Use /api/v1/manage/imports only when the source export matches a documented supported importer; it is not a universal importer. Otherwise document the required adapter and keep existing records on their original backend. Never invent an accepted source name or silently omit records to make a preview pass. Imports require imports:write and explicit approval before committing or activating sending. Preserve timestamps, historical check-ins, question snapshots, opt-outs and dated consent; source emails do not verify accounts. Existing calendar provider bindings require an organizer/UID handoff plan. A preview is not a completed cutover or verified live delivery.

REGISTRATION, CHECK-IN AND ATTENDANCE:
- Our browser form calls our server, which submits the registration to BoilerLoop. Submitting an email does not verify it; matching verified accounts share the registration history. A site without server code should link to https://boilerloop.com/events/nightshift for RSVP.
- Preserve normal event invitation defaults: calendarInvitations is an optional boolean and defaults to true when omitted on creation. Forward an explicit user choice when provided; do not hard-code false in production creation. Keep calendarInvitations:false limited to disposable test fixtures or explicit user choices. Test both default creation and an explicit off override with delivery mocked, without enabling real sending.
- Calendar invitations, updates and cancellations follow the event's invitation setting and configured delivery. Do not create a second independent event/calendar record on our site.
- Keep first-party printable-QR check-in at https://boilerloop.com/checkin/evt-h84ees/display for staff; scanning the displayed code opens the signed attendee check-in flow. Linking to /checkin/evt-h84ees alone does not provide a valid scan code.
- Optional embed instead of custom UI: <script src="https://boilerloop.com/embed.js" defer></script> and <boiler-event event-id="evt-h84ees" mode="card"></boiler-event>. It reads public events and links out.
- Never send a management key or registration write directly from browser code. Never write attendance from the club site: check-in requires the signed QR flow and verified participant session.
- There are no webhooks or attendance-write API. Do not invent one. Poll the authorized read API for changes.
- Handle attendee emails and answers only as needed to submit registrations; do not publish them on our site.

VERIFY AND FINISH:
- Implement the browser UI and our server-side API adapter, wire them into the actual pages, and escape rendered text. Test list/detail/question mapping, pagination, confirmed/waitlisted/duplicate RSVP, failed submission with retained answers, cancellation authorization, canceled events, restricted-data redaction and missing configuration. Prove the key never appears in client output. Use mocks or isolated data; no live messages.
- When an isolated local/test key and reachable BoilerLoop origin are supplied, run real HTTP contract checks against that origin, not only mocked responses. Create a disposable public draft with calendarInvitations:false, verify it is absent publicly, read publish-preview, publish explicitly, submit required answers, confirm duplicate and waitlist behavior, preview and apply an edit, read unpublish-preview and unpublish. Verify statuses and public visibility after each transition. Also complete the actual website editor in the browser: create with defaults, save draft, upload and reload its flyer, preview and confirm publication, edit and confirm, then unpublish and confirm. A direct API lifecycle alone does not prove the editor works. Using the real verified website account, also read its existing RSVP status route, edit answers through its existing backfill/answer-edit route, read the updated answers, and cancel through the visible website control. Anonymous callers and forged emails/registration IDs must not alter another person’s RSVP; use the verified session to resolve ownership server-side. Test flyer upload/removal, the existing staff listing APIs and the visible signed QR presenter with only the website staff login. A QR endpoint returning a URL is not proof that staff can see or print a QR. When isolated staff credentials are supplied, use the existing verified login and real staff routes for these tests, rather than bypassing authorization. Never print test credentials. Use only synthetic recipients and isolated test data; never publish to a live club or enable real sending. If the supplied environment cannot safely support a check, report that check as unverified rather than pretending mocks prove it.
- Open the site on desktop and phone and complete an RSVP using the isolated backend when available, otherwise mocks. Check that list/detail/calendar agree, secondary event entry points work, and existing routes/auth/analytics still behave correctly. Include an unmapped existing event in source-preservation tests, using the actual source configuration. Run the project's appropriate lint, type and build checks and fix failures caused by the integration.
- Finish with changed pages/files, tests actually run, required environment setup, and any explicit unsupported features or approval-dependent data cutover. Do not describe mocked checks as a live integration test. Finish supported features in this pass; if a required backend operation is unavailable, report the exact remaining extension and keep the affected existing flow working rather than claiming it is ready for cutover.
- Full documentation: https://boilerloop.com/developers.

Public read API

GET https://boilerloop.com/api/v1/events/evt-h84ees
GET https://boilerloop.com/api/v1/events/evt-h84ees/calendar?series=true
GET https://boilerloop.com/api/v1/organizations/acm/events?scope=upcoming&page=1&limit=10
GET https://boilerloop.com/api/v1/organizations/acm/calendar
Returns
Canonical id, slug, hosts (primary/co-host), timing, timezone, series and override, location, tags, capacity, going count, availability, visibility, walk-in policy, public registration questions, calendar links, and image (url, width, height) when the club uploaded a cover. Resolve the URL against the origin; it is null otherwise.
Listing and location
Events with listed: false are omitted from public lists. Eligible visitors can still use their direct links. When hideLocationUntilRsvp: true, the public API omits the location; the registered attendee can access it through their authorized flow.
Never returns
Restricted events (Purdue-only, invite-only, members-only are 404 here regardless of cookies), attendee identities, answers, invite lists, rosters, credentials, storage locations of uploaded images.
Caching
ETag / If-None-Match → 304. max-age 60, stale-while-revalidate 300. Wildcard read-only CORS.
Errors
{"error":{"code":"NOT_FOUND","message":"Public event not found."}}, 400 INVALID_QUERY, 405 for writes.
Versioning
v1 changes are additive. Anonymous rate limiting is applied at the deployment edge, not by this app.

Management API

Authorization: Bearer be_live_…   # created by a club owner in Workspace → Integration → API keys

GET    https://boilerloop.com/api/v1/manage/events                    scope events:read   (includes restricted events)
POST   https://boilerloop.com/api/v1/manage/events                    scope events:write
GET    https://boilerloop.com/api/v1/manage/events/{id}               scope events:read
PATCH  https://boilerloop.com/api/v1/manage/events/{id}               scope events:write
POST   https://boilerloop.com/api/v1/manage/events/{id}/registrations scope registrations:write (email, name, answers)
DELETE https://boilerloop.com/api/v1/manage/events/{id}/registrations/{registrationId} scope registrations:write
GET    https://boilerloop.com/api/v1/manage/events/{id}/attendees     scope attendees:read (+ attendees:sensitive for sensitive answers)
GET    https://boilerloop.com/api/v1/manage/contacts?page=1&limit=50  scope contacts:read
GET    https://boilerloop.com/api/v1/manage/members?page=1&limit=50   scope members:read
Scope
A key belongs to one organization. Event and registration writes work on events the club primarily hosts; attendee reads require primary hosting or an explicit co-host grant. Registration writes are idempotent by event and normalized email, and use the same capacity, waitlist, and question validation as first-party registration.
Contacts and members
Choose Read contacts or Read members when creating a key. Each permission is independent and limited to that key’s club. Contacts are the email list; members are the club roster and team. Subscription status is separate from membership. These reads do not include other clubs, global account profiles, private event answers or credentials. Keep the results on your server or in an authorized staff interface.
Directory queries
Both lists accept page (1–1000), limit (1–100, default 50) and search (up to 100 characters). Contacts also accept tag (up to 24 characters) and status: pending, subscribed, unsubscribed or suppressed. Invalid values return 400. Responses are {data:[...],page,limit,total,organization}; continue while page * limit < total.
Directory fields
Contacts return id, email, name, tags, status, consentSource, consentAt, unsubscribedAt, createdAt and updatedAt. Members return a club-specific id, name, club-associated emails, rosterEmails, teamRole and registered. Confirmation tokens, private staff notes, global person IDs and unrelated email aliases stay private.
Existing event editor
Keep your website’s staff screens and use server-to-server calls behind them. Event creation always saves a draft, including requests with a published status. Use the publish preview and publish endpoints to publish a saved draft. Preview edits before PATCH, and preview unpublishing before applying it. Unpublishing preserves registrations and cancels queued work and calendar invitations. Duplicate and image endpoints support the existing website editor. Preserve unsupported co-host controls on their existing path.
Limits
120 requests/minute per key with X-RateLimit-Limit/Remaining/Reset; 429 includes Retry-After. Every call is written to the club audit log with key id, method, path and status.
Not available
Normal registration endpoints do not create attendance. Historical migration is a separate import permission and never verifies current presence. A club key with registrations:write can submit or cancel registrations for its own events. A submitted email is matched to a verified BoilerLoop person now or after verification; the submission does not verify that email. Attendance only comes from the first-party check-in flow below. Keys are hashed at rest, shown once, revocable, and must stay on a server. These routes do not allow CORS.

Event editor endpoints

All paths below start at /api/v1/manage. Event, image, type and check-in reads require events:read. Publish, change and unpublish previews, as well as all event changes, require events:write.

GET  /events/{id}/publish-preview
POST /events/{id}/publish
POST /events/{id}/change-preview
GET  /events/{id}/unpublish-preview
POST /events/{id}/unpublish
POST /events/{id}/duplicate
GET, POST, DELETE /events/{id}/image
GET, POST /event-types
PATCH /event-types/{id}
GET /events/{id}/checkin

Event reads, writes, publish and unpublish responses use {data: ...}. Capacity must be an integer from 1 to 5000. Use a visible valid form default and validate blanks rather than claiming unlimited capacity. Calendar invitations default to on when omitted; an explicit calendarInvitations: false disables them for that event. Keep test-only delivery flags out of normal event creation. Present previews as readable changes and recipient estimates, without promising provider delivery or showing raw response JSON. Preview mode is publish for publication and update for edits and unpublishing. Lifecycle previews return {mode, changes, emails, calendar, community, warnings} directly, without a data wrapper. Check-in GET returns {url, qrSvg, displayUrl} directly. Image and calendar reads return bytes or ICS text. Marketing responses have their own shapes. Parse each endpoint’s documented response rather than unwrapping every result the same way.

// GET /events/{id}/publish-preview (also change/unpublish previews)
{ "mode": "publish", "changes": [], "emails": { ... },
  "calendar": { ... }, "community": { ... }, "warnings": [] }
// POST /events/{id}/publish or /unpublish
{ "data": { "id": "...", "status": "scheduled", ... } }

Public event hosts include slug, name and role. Management event hosts use orgId and role, with display details in hostOrgs. Keep private management fields on your server.

Adding BoilerLoop configuration does not migrate your existing events. Inspect your website’s actual database configuration and data helpers, preserve unmapped records and routes, and use an explicit source mapping to decide which backend handles an event. Show a retry state for an unavailable backend. For websites with verified login, connect existing personal RSVP status, answer-edit/backfill and cancellation controls to authorized registration reads and writes. Keep those capabilities on the website; a canonical link is an additional option. Preserve question purpose and sensitivity when editing. Use the same source-aware reads in staff pages and their authenticated JSON APIs, preserving draft filters. Test the lifecycle and visible QR presenter with your website’s own staff login against an isolated backend before cutover.

Image POST uses multipart form data with an image or flyer file, up to 5 MB. Image GET returns the original image bytes. Draft and restricted public image URLs still enforce BoilerLoop visibility. Serve editor previews through your own staff-authorized image endpoint using the management image read; return the bytes privately and deny anonymous access. Verify the image still renders after reloading the draft with only your website login. The check-in GET returns url, qrSvg and displayUrl for the stable signed code. Render qrSvg or a QR image of the signed url in your website’s own staff presenter. The displayUrl page requires a separate BoilerLoop staff session; a club key does not sign your browser in, so an iframe will show sign-in to website staff.

Use externalId to retain your website’s event identity. Event fields include optional HTTPS meetingUrl, registrationUrl and slidesUrl, plus listed, hideLocationUntilRsvp, checkinEnabled and eventTypeId. URLs cannot contain credentials. Set checkinQuestionsOverride: false to inherit the event type’s questions; explicit custom questions use an override.

Event types have stable IDs, a name, check-in questions and an archived flag. Archive a type without changing existing event references. Questions support visitNumber 1–5 (5 means visit five and later), everyone or returning visitors, hidden, and dependsOn: {questionId, value} for an earlier single or multi-choice answer. Single-choice presentation can be radio or dropdown. Visit counts use earlier actual attendance for that club and event type, not RSVPs.

Participant records

GET /api/v1/manage/events/{id}/registrations?email=person@example.org
GET, PATCH, DELETE /api/v1/manage/events/{id}/registrations/{registrationId}

GET requires attendees:read. POST, PATCH and DELETE require registrations:write; granting write does not grant access to private participant details or answers. Full read responses require attendees:read, with attendees:sensitive additionally required for sensitive answers.

Retain externalId for a source registration and participantExternalId for a source participant. Read responses provide a club-scoped participantRef and visitNumber. Preserve these references instead of treating an email address as a permanent identity. Submitting an email never verifies it.

Contacts and marketing

These permissions are optional and off by default. contacts:write manages contacts and consent records. marketing:read reads campaigns and settings; marketing:write manages drafts and promotion. Scheduling, retrying sends and changing sending automations also require marketing:send. Creating a draft or reading a contact does not authorize email delivery.

GET, POST /api/v1/manage/marketing/contacts
PATCH, DELETE /api/v1/manage/marketing/contacts/{contactId}
POST /api/v1/manage/marketing/contacts/import
GET, POST /api/v1/manage/marketing/campaigns
GET, PATCH /api/v1/manage/marketing/campaigns/{campaignId}
POST /api/v1/manage/marketing/campaigns/{campaignId}/preview
GET /api/v1/manage/marketing/campaigns/{campaignId}/count
POST /api/v1/manage/marketing/campaigns/{campaignId}/schedule
POST /api/v1/manage/marketing/campaigns/{campaignId}/cancel
POST /api/v1/manage/marketing/campaigns/{campaignId}/retry
GET, POST /api/v1/manage/marketing/campaign-groups
GET, PATCH, DELETE /api/v1/manage/marketing/campaign-groups/{groupId}
POST /api/v1/manage/marketing/campaign-groups/{groupId}/emails
GET, PUT /api/v1/manage/marketing/automations
POST /api/v1/manage/marketing/automations/preview
GET, POST /api/v1/manage/marketing/promotion

Promotion POST requires an Idempotency-Key header. Use the same key and identical body when retrying a request. Preserve subscribed, pending, unsubscribed and suppressed states during contact imports. Sending still obeys consent, recipient rules and paused delivery settings.

Source-specific history importer

This adapter supports the BuildPurdue export format; it is not a universal website importer. Other schemas need an explicit mapping and supported adapter before cutover. POST /api/v1/manage/imports accepts a raw BuildPurdue export with schemaVersion: 1, source: "buildpurdue", events and optional contacts. Preview is the default and requires imports:write. Inspect its blockers and warnings before committing.

{ "schemaVersion": 1, "source": "buildpurdue", "events": [...], "contacts": [...], "commit": false }

Commit uses commit: true and an Idempotency-Key, with events:write and contacts:write when contacts are included. Keep original event, registration and participant IDs, timestamps, question snapshots and historical check-in records. This migration sends no email or calendar invitations.

Future events already bound to a calendar provider block migration until their provider event, organizer and UID have a handoff plan. A flyer URL requires the original raster bytes in base64 flyerData; the importer does not fetch remote images. Preserve unsupported source permissions and warnings instead of broadening access.

Imported events stay on a sending hold, including later edits and replanning. For an explicit server cutover, POST /api/v1/manage/imports/activate with {eventIds, calendarInvitations?, commit?}. Preview requires imports:write. Commit requires imports:write, events:write, marketing:write, marketing:send and an Idempotency-Key. Activation schedules the existing defaults and optional calendar invitations; it does not send an announcement blast. Inspect the preview before committing.

First-party check-in

Every published event with check-in enabled has a stable check-in code that clubs can display or print. Staff open /checkin/{eventId}/display; attendees scan it, land on /checkin/{eventId}?token=…, verify their email, answer required check-in questions, and the browser posts to POST /api/events/{eventId}/checkin with a signed scan ticket.

The server validates the signed code or ticket, the check-in window, attendee eligibility, registration or walk-in policy, and required answers. Tickets last ten minutes; the printed code stays the same until staff replaces it. Replacing the code invalidates old prints and tickets. Repeated check-ins return the original record. Codes can be shared, so a scan alone does not prove physical presence or record attendance.

Optional event embed

<script src="https://boilerloop.com/embed.js" defer></script>
<boiler-event event-id="evt-h84ees" mode="card"
  style="--be-accent:#c79a6b;--be-radius:16px">
</boiler-event>

Modes: card, detail, rsvp, calendar, list (organization="acm"). Theme tokens: --be-accent, --be-radius, --be-font. The embed renders public API data in a Shadow DOM and links RSVP/check-in to the canonical event page. To collect registrations on your own site, send them from your server with a scoped club key. The embed emits a browser-local boilerloop:lifecycle DOM event for your own analytics; nothing an embed does counts as RSVP or attendance.

Fetch in your own design

const res = await fetch('https://boilerloop.com/api/v1/events/evt-h84ees');
if (!res.ok) throw new Error('Event unavailable');
const { data } = await res.json();
// Render text safely; resolve relative links against the origin.
// Link to data.url for RSVP, or submit a custom form through your server.

Keep API keys on your server

Browser clients cannot hold a club key. Club server integrations can submit registrations for the primary host, while participant actions on BoilerLoop require the participant’s verified session. Check-in still requires a valid signed code or scan ticket and a verified attendee session. Management keys can never fabricate presence. Attendee data is organization-scoped; co-hosts need an explicit grant; sensitive answers need the sensitive scope or an owner session.