How to Integrate ChurchSuite with Your Parish Website

If your parish runs ChurchSuite, you already have a powerful church management system handling your events, rotas, groups, and giving. The question is how much of that data surfaces on your public-facing website — and how seamlessly. This guide covers how Expanse CMS integrates with ChurchSuite out of the box, what the integration looks like in practice, and what more you can layer on top.

Why ChurchSuite and Your Website Should Talk

ChurchSuite is where your office team lives. Events get entered once, sign-ups are managed there, categories and images are maintained there. If your website has its own separate events section maintained by hand, you immediately have two sources of truth — and one of them is always slightly wrong.

The better model is to treat ChurchSuite as the authoritative data source and your website as a presentation layer. When someone adds a new event in ChurchSuite, it appears on the homepage automatically. When an event date changes, the website reflects it within the hour. No double-entry, no stale listings.

Expanse CMS is built to work exactly this way.

The ChurchSuite Embed Calendar API

ChurchSuite exposes a public JSON endpoint that doesn’t require authentication — designed precisely for embedding calendar data on external websites. The base URL follows this pattern:

https://{your-parish}.churchsuite.co.uk/embed/calendar/json

Or, for newer tenants on the .com domain:

https://{your-parish}.churchsuite.com/embed/calendar/json

Useful query parameters

Each event in the JSON response includes:

• id — unique event identifier
• name — event title
• description — full description (HTML-encoded)
• datetime_start / datetime_end — ISO 8601 timestamps
• location.name — venue name
• category.name / category.color — for colour-coded display
• images.md.url — medium-resolution event image
• signup_options.tickets.url — direct booking/sign-up link back into ChurchSuite

This is everything you need to build a rich events section without writing a single line of ChurchSuite-specific admin code.

How Expanse CMS Fetches and Caches Events

The integration lives in each site’s logic.php — the PHP file that runs on every page request for a given theme. Because ChurchSuite’s embed API is public and unauthenticated, the fetch is straightforward. The important detail is that you don’t want to hit the ChurchSuite API on every page load — a caching layer keeps things fast and resilient.

Here’s the pattern used across Expanse CMS parish sites:

1. Define the API endpoints

$weekstime = date('Y-m-d', strtotime("Midnight +6 months"));$api_urls = [    'https://stmarksrc.churchsuite.co.uk/embed/calendar/json?featured=1&num_results=6&date_end=' . $weekstime,    'https://stmarksrc.churchsuite.co.uk/embed/calendar/json?num_results=6&date_end=' . $weekstime];

Two requests are made: one for featured events and one for all upcoming events. The six-month lookahead window prevents very distant future events from filling the grid before near-term ones appear.

2. Check the cache

$cache_dir = __DIR__ . '/../cache';$cache_time = 1600; // roughly 27 minutes$cache_file = $cache_dir . '/combined_calendar.json';if (file_exists($cache_file) && (time() - filemtime($cache_file)) < $cache_time) {    return file_get_contents($cache_file);}

The cache file lives in a _cache/ directory within the theme. If the file is younger than $cache_time seconds, it’s served directly — no outbound HTTP request at all. This keeps page loads fast regardless of ChurchSuite’s response time.

3. Merge featured and fallback events

The clever part is how the two result sets are combined. Featured events always take priority, but if there aren’t enough of them, non-featured events fill the remaining slots:

$existing_ids = array_map(function ($item) {    return $item['id'] ?? md5($item['name'] . $item['datetime_start']);}, $featured_data);foreach ($fallback_data as $event) {    $event_id = $event['id'] ?? md5($event['name'] . $event['datetime_start']);    if (!in_array($event_id, $existing_ids)) {        $featured_data[] = $event;        $existing_ids[] = $event_id;    }    if (count($featured_data) >= 6) {        break;    }}

Deduplication uses the event’s id where available, and falls back to an md5 hash of the name and start time — so events without a ChurchSuite ID (rare, but possible) don’t appear twice.

4. Sort chronologically and write cache

usort($featured_data, function ($a, $b) {    return strtotime($a['datetime_start']) <=> strtotime($b['datetime_start']);});$final = array_slice($featured_data, 0, 6);$json_data = json_encode($final);file_put_contents($cache_file, $json_data);

Events are sorted by start date, capped at six, and written to the cache file as JSON. If the ChurchSuite API is temporarily unavailable on the next request, the stale cache is served rather than showing an error — making the integration gracefully resilient to upstream outages.

Multi-Site ChurchSuite Accounts

Some organisations — particularly religious orders and diocesan bodies — manage multiple parishes or communities under a single ChurchSuite account using ChurchSuite’s Sites feature. Expanse CMS handles this with the site_idsparameter.

For example, Transform Ministries UK uses the Augustinians’ ChurchSuite account but only wants events from site ID 2:

$api_urls = [    'https://theaugustinians.churchsuite.com/embed/calendar/json?site_ids=2&featured=1&num_results=6&date_end=' . $weekstime,    'https://theaugustinians.churchsuite.com/embed/calendar/json?site_ids=2&num_results=6&date_end=' . $weekstime];

Swapping the site_ids value is all that’s needed to scope the feed to the right community. You can also pass multiple IDs comma-separated (site_ids=2,4) if a page should aggregate events across several sites.

Displaying Events in Your Theme

Once the data is fetched and cached, it’s registered as a template loop:

$calendar2 = [];foreach ($obj2 as $v) {    $calendar_item = new stdClass();    $calendar_item->title       = $v->name;    $calendar_item->event_time_date = $ranger->format($v->datetime_start, $v->datetime_end);    $calendar_item->permalink   = $v->signup_options->tickets->url;    $calendar_item->location    = $v->location->name;    $calendar_item->descr       = $v->description ? trim_excerpt(html_entity_decode($v->description)) : '';    $calendar_item->category_color = $v->category->color;    if (isset($v->images->md->url)) {        $calendar_item->image = $v->images->md->url;    }    $calendar2[] = $calendar_item;}add_loop($calendar2, 'featured_events', 'main');

In your ETS template, this loop becomes a responsive event grid:

{loop:featured_events}    <article class="relative flex h-full flex-col rounded-lg border-2 border-white bg-white shadow-lg                    hover:border-sky-500 hover:shadow-2xl duration-500">        <a href="{permalink}" class="absolute inset-0 z-10" target="_blank"></a>        {set:image}            <img src="{image}" alt="{title}" class="aspect-square w-full rounded-lg object-cover mb-2">        {/set}        <h2 class="font-serif font-extrabold text-sky-800 px-2 mb-4">{title}</h2>        <p class="mt-auto px-2 text-gray-400">            <!-- calendar-clock icon -->            {event_time_date}        </p>        {set:location}            <p class="mt-auto px-2 text-gray-400">                <!-- map-marker icon -->                {location}            </p>        {/set}    </article>{/loop}

The {set:image} / {mis:image} conditional tags handle events without an image gracefully — showing a placeholder div rather than a broken img tag.

Navigation Integration

Beyond the events feed, it’s worth linking your navigation directly into the parishioner’s ChurchSuite account — for sign-ups, giving, and their personal dashboard. This is as simple as adding an external link to your menu config:

https://stmarksrc.churchsuite.com/

Parishioners who have signed up to ChurchSuite will land directly in their account. Those who haven’t will see the sign-up or sign-in page, which serves as a low-friction onboarding path.

What You Can Add

The embed calendar API is only one of ChurchSuite’s public-facing endpoints. Here are natural next steps for a deeper integration within Expanse CMS:

Small Groups directory

ChurchSuite exposes a public embed endpoint for small groups (Connect module). A logic.php fetch against:

https://{parish}.churchsuite.co.uk/embed/connect/json

…returns active groups with descriptions, meeting schedules, and sign-up links. This can feed a Groups page on your website without manual maintenance.

Giving / online donations

Rather than embedding a ChurchSuite giving widget directly (which can feel visually inconsistent), a cleaner approach is a styled button or card on the website that deep-links into the parish’s ChurchSuite giving page:

https://{parish}.churchsuite.co.uk/give

Address Book / Contact forms

For enquiry forms that should flow into ChurchSuite’s Address Book, the ChurchSuite API (authenticated, not the public embed) accepts POST requests to create or update contacts. This is a natural extension once you have a contact form in Expanse CMS — rather than sending enquiries only by email, they can land directly in ChurchSuite for follow-up by the parish team.

Rota reminders (via Ozone hooks)

ChurchSuite rotas are managed inside ChurchSuite and emailed automatically. However, you can use Expanse’s Ozone hook system to trigger supplementary communications from the website layer — for example, sending a reminder page or resource link when a server has an upcoming serving commitment, by cross-referencing a logged-in user session with a ChurchSuite contact ID.

Event category colour coding

Each event in the ChurchSuite response includes a category.color hex value set by your ChurchSuite administrator. Expanse CMS captures this in $calendar_item->category_color and makes it available as a template variable. You can use it to add a coloured left-border or badge to each event card, giving visual parity with what the team sees inside ChurchSuite:

<span class="block w-1 rounded-full self-stretch"      style="background-color: #{category_color}"></span>

The Cache Directory

One operational note: the _cache/ directory inside your theme folder must exist and be writable by the web server. Expanse CMS checks for this before attempting to write:

if (is_dir($cache_dir)) {    $json_data = get_combined_cached_data($cache_file, $cache_time, $api_urls);} else {    $json_data = fetch_combined_data($api_urls);}

If the directory is missing, the integration falls back to a direct live fetch on every request — which works, but removes the resilience and performance benefits of caching. A simple mkdir _cache && chmod 755 _cache inside your theme directory sorts this. It’s also worth adding a bare index.php to the _cache/ folder to prevent directory listing on servers where that isn’t disabled at the web server level.

Summary

The ChurchSuite embed calendar integration in Expanse CMS is intentionally lightweight — no API client library, no OAuth, no webhook infrastructure. It’s a JSON fetch with a file cache and a smart merge strategy, and it’s in production across multiple parish sites. The result is a homepage events section that stays accurate with zero ongoing maintenance from the website team.

The pattern is repeatable: point $api_urls at your parish’s ChurchSuite subdomain, adjust the site_ids if needed, ensure the _cache/ directory exists, and the events grid takes care of itself.

For parishes already on Expanse CMS, adding ChurchSuite integration to a new theme takes under an hour. For parishes evaluating Expanse CMS, it’s one of the integrations that makes the platform a natural fit for a ChurchSuite-run community.

Expanse CMS is a custom PHP content management system built for parish and religious organisation websites. Get in touch to discuss a site for your parish.