Most gym owners using Mindbody still handle new member onboarding the same way they did before the software existed — someone checks the dashboard, copies a name into a spreadsheet, sends a welcome email by hand, and hopes the waiver gets chased before the first class. Gym member onboarding automation through a Mindbody and Make.com integration exists to close exactly that gap, but most resources on the topic stop at “connect your apps” without showing what the workflow actually looks like inside a scenario.

Mindbody handles scheduling and payments well. What it does not do natively is push a new client record into your CRM, trigger a personalised welcome sequence, send a waiver link via SMS, or alert your front desk team in Slack — not without a middleware layer sitting between it and those tools. That missing layer is where most studios lose time and where new members quietly form their first impression.

This guide walks through the exact Make.com scenario structure we recommend for fitness studios — from the initial trigger when a new client appears in Mindbody through to automated 30-day follow-up. No coding is required, and every module, field mapping, and logic branch is covered in the order you would build it.

Why Gym Member Onboarding Breaks Down (And Where Mindbody Alone Falls Short)

Most studios running Mindbody are managing at least four post-signup tasks by hand. Someone sends a welcome email from a personal Gmail account. Someone else chases the liability waiver over text or at the front desk. A staff member manually tags the new client in a spreadsheet or CRM. And if the member bought an intro offer, a follow-up sequence either gets sent late or not at all.

Mindbody handles the transaction and the scheduling record cleanly. The problem is containment — that data stays inside Mindbody unless something moves it. The platform does not natively push a new client record into Mailchimp, create a row in Google Sheets, or post a Slack message to your front desk team. Its internal automation tools are limited to reminders and confirmations within its own ecosystem.

The result is a gap between the moment someone signs up and the moment they feel genuinely welcomed. That gap is where first impressions erode and where early drop-off begins.

How the Mindbody + Make.com Integration Actually Works: Triggers, Auth, and API Limits

Make.com connects to Mindbody through the Mindbody Community connector, which is available directly inside the Make module library without any custom API setup. Authentication requires two things: your Mindbody API key, which you generate through the Mindbody Developer Portal, and your site ID, the numeric identifier found in your Mindbody account settings.

Available Triggers

The connector exposes three primary triggers relevant to onboarding:

The Rate Limit Gotcha

Mindbody’s API enforces a rate limit on calls. Beginner scenarios that poll too frequently — or that chain multiple API calls in a single scenario without spacing — will hit this ceiling and cause modules to stall silently. Set your Watch trigger interval to no shorter than 15 minutes and avoid making more than two Mindbody API calls within a single scenario execution to stay within safe limits.

Build the Core Onboarding Scenario: From New Mindbody Client to Welcome Email in 7 Steps

This is the foundation scenario. Build it first before adding any branches.

The Module Chain

  1. Mindbody — Watch New Clients — set polling interval to 15 minutes. This is your trigger.
  2. Filter — add a condition that checks the membership type field. This ensures the scenario only continues for new paying members, not trial drop-ins or staff accounts.
  3. Gmail or Mailchimp — Send Email — map the following fields from the Mindbody trigger output: First Name, Email Address, Membership Type, Sign-Up Date. Use these to personalise the subject line and body.
  4. Google Sheets — Add Row — log the same fields into a member tracking sheet. Include a Waiver Sent column defaulted to “No” at this stage.
  5. Slack — Send a Message — post to your front desk or manager channel with the member’s name, membership type, and sign-up date so staff are aware without checking Mindbody manually.
  6. Error Handler — wrap the email and Slack modules in a Make error handler so a failed send does not silently break the chain.
  7. Save and activate — run the scenario once manually using Make’s test function to confirm field mappings are pulling correctly before setting it live.

The entire scenario takes roughly 45 minutes to build from scratch on a first attempt.

Add a Waiver and Intake Form Branch Using Jotform or Typeform

Once the core scenario is running, extend it with a second branch that handles waiver delivery and confirmation.

Add a Twilio — Send SMS module after the Google Sheets row is created. Map the member’s phone number from the Mindbody trigger output and insert your Jotform or Typeform waiver URL into the message body. Keep the message under 160 characters to avoid carrier splitting.

Watching for Completion

Build a second, separate Make.com scenario for this step:

  1. Jotform — Watch Submissions or Typeform — Watch Responses — triggers when the waiver is completed.
  2. Mindbody — Update Client — use the submitter’s email address to locate the correct client record and apply a custom client tag such as waiver_complete.
  3. Google Sheets — Update Row — find the matching row by email and change the Waiver Sent column to “Yes”.

This two-scenario structure keeps each workflow clean and easier to debug if something breaks.

Automate the First 30 Days: Booking Reminders, Check-In Milestones, and Drop-Off Alerts

The onboarding window does not close after the welcome email. The first 30 days determine whether a new member becomes a retained one.

The Drip Workflow Structure

Use the Google Sheets member log created in the core scenario as the data source for all follow-up timing. A Make.com scheduled scenario runs daily and checks the Sign-Up Date column to identify which members hit each milestone.

Why This Works

The logic is simple: members who book within the first two weeks are significantly more likely to stay past the first month. The day-14 Slack alert turns a passive data point into a staff action before the member quietly disappears.

How Much Time This Saves and What It Costs to Build

Time Savings

For a studio onboarding roughly 100 new members per month, the manual version of this workflow — welcome email, waiver chase, CRM entry, follow-up sequence — takes between 4 and 6 hours per week when spread across staff. The automated version reduces that to occasional scenario monitoring and exception handling, typically under 30 minutes per week.

Cost to Run

Make.com’s Core plan sits at $9 per month and comfortably handles the scenario volume described here. The Mindbody API key is available through the Developer Portal at no additional cost on most Mindbody plans. Twilio SMS costs are negligible at low volume — under $5 per month for a 100-member studio. Total running cost lands below $15 per month.

DIY vs. Hiring an Agency

Building this yourself is achievable if you have 6 to 8 hours to invest in initial setup and are comfortable working through Make’s interface methodically. The scenarios described here require no coding. Where it makes sense to bring in outside help is when the studio has more complex logic — multiple membership tiers, multi-location routing, or a CRM like HubSpot or ActiveCampaign that needs deeper field mapping. That is the point at which the build time and debugging cost outweigh the DIY saving.

Conclusion

The gap between a member signing up and feeling welcomed is a process problem, not a staffing one. Connecting Mindbody to Make.com closes that gap without adding headcount or complexity. The scenarios described here are buildable in an afternoon and cost less per month than a single class drop-in. If your studio is onboarding at scale or managing more complex membership logic, our audit can identify where the current setup is leaking time.