Overview

Reminders help reduce no-shows by notifying attendees before their appointments. Configure email and SMS reminders with customizable timing and content.

Default Reminders

Set default reminders for all event types:

TypeScript:

await client.calendar.settings.updateReminders({
  defaultReminders: [
    { type: 'EMAIL', beforeMinutes: 24 * 60 }, // 24 hours before
    { type: 'EMAIL', beforeMinutes: 60 },       // 1 hour before
    { type: 'SMS', beforeMinutes: 30 },         // 30 minutes before
  ],
});

Python:

client.calendar.settings.update_reminders(
    default_reminders=[
        {"type": "EMAIL", "beforeMinutes": 24 * 60},
        {"type": "EMAIL", "beforeMinutes": 60},
        {"type": "SMS", "beforeMinutes": 30},
    ]
)

Event Type Reminders

Override reminders for specific event types:

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    enabled: true,
    schedule: [
      { type: 'EMAIL', beforeMinutes: 48 * 60 }, // 2 days before
      { type: 'EMAIL', beforeMinutes: 24 * 60 }, // 1 day before
      { type: 'EMAIL', beforeMinutes: 2 * 60 },  // 2 hours before
      { type: 'SMS', beforeMinutes: 60 },        // 1 hour before
    ],
  },
});

Reminder Types

Type	Description	Requirements
`EMAIL`	Email reminder	Attendee email
`SMS`	SMS text message	Attendee phone, SMS enabled
`PUSH`	Push notification	Mobile app integration

Email Reminders

Configure Email Reminder

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    email: {
      enabled: true,
      schedule: [
        { beforeMinutes: 24 * 60 },
        { beforeMinutes: 60 },
      ],
    },
  },
});

Custom Email Template

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    email: {
      enabled: true,
      schedule: [{ beforeMinutes: 24 * 60 }],
      template: {
        subject: 'Reminder: {{event_title}} tomorrow',
        body: `
Hi {{attendee_name}},
 
This is a reminder about your upcoming appointment:
 
**{{event_title}}**
Date: {{event_date}}
Time: {{event_time}} ({{attendee_timezone}})
Duration: {{event_duration}} minutes
 
{{#if meeting_url}}
Join here: {{meeting_url}}
{{/if}}
 
{{#if location}}
Location: {{location}}
{{/if}}
 
Need to make changes?
- Reschedule: {{reschedule_url}}
- Cancel: {{cancel_url}}
 
See you soon!
{{host_name}}
        `,
      },
    },
  },
});

Template Variables

Variable	Description
`{{event_title}}`	Event type name
`{{event_date}}`	Formatted date
`{{event_time}}`	Formatted time
`{{event_duration}}`	Duration in minutes
`{{attendee_name}}`	Attendee's name
`{{attendee_timezone}}`	Attendee's timezone
`{{host_name}}`	Host's name
`{{meeting_url}}`	Video meeting link
`{{location}}`	Physical location
`{{reschedule_url}}`	Reschedule link
`{{cancel_url}}`	Cancellation link
`{{booking_uid}}`	Booking identifier

SMS Reminders

Enable SMS Reminders

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    sms: {
      enabled: true,
      schedule: [
        { beforeMinutes: 60 },
        { beforeMinutes: 15 },
      ],
    },
  },
});

Custom SMS Template

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    sms: {
      enabled: true,
      schedule: [{ beforeMinutes: 60 }],
      template: 'Reminder: {{event_title}} at {{event_time}}. Join: {{meeting_url}}',
    },
  },
});

SMS Requirements

For SMS reminders to work:

Attendee must provide phone number
Phone number must be verified (if required)
Organization must have SMS enabled

// Require phone for bookings
await client.calendar.eventTypes.update(eventType.id, {
  questions: [
    {
      label: 'Phone number',
      type: 'PHONE',
      required: true,
      useForReminders: true,
    },
  ],
});

Host Reminders

Remind hosts about upcoming meetings:

await client.calendar.eventTypes.update(eventType.id, {
  hostReminders: {
    enabled: true,
    schedule: [
      { beforeMinutes: 15 },
      { beforeMinutes: 5 },
    ],
    channels: ['EMAIL', 'PUSH'],
  },
});

Reminder Workflow

Disable for Specific Booking

const booking = await client.calendar.bookings.create({
  eventTypeId: 'evt_xxx',
  startTime: '...',
  attendee: { ... },
  reminders: {
    enabled: false, // No reminders for this booking
  },
});

Update Booking Reminders

await client.calendar.bookings.update(booking.uid, {
  reminders: {
    enabled: true,
    schedule: [
      { type: 'EMAIL', beforeMinutes: 30 },
    ],
  },
});

Reminder Logs

View Sent Reminders

const reminders = await client.calendar.bookings.getReminders(booking.uid);
 
for (const reminder of reminders) {
  console.log(`${reminder.type}: ${reminder.status}`);
  console.log(`  Scheduled: ${reminder.scheduledAt}`);
  console.log(`  Sent: ${reminder.sentAt}`);
}

Retry Failed Reminder

await client.calendar.bookings.retryReminder(booking.uid, reminderId);

Conditional Reminders

Send different reminders based on conditions:

await client.calendar.eventTypes.update(eventType.id, {
  reminders: {
    email: {
      enabled: true,
      rules: [
        {
          // For first-time bookers
          condition: { isFirstBooking: true },
          schedule: [
            { beforeMinutes: 48 * 60 },
            { beforeMinutes: 24 * 60 },
            { beforeMinutes: 2 * 60 },
          ],
          template: 'first_time_reminder',
        },
        {
          // For returning bookers
          condition: { isFirstBooking: false },
          schedule: [
            { beforeMinutes: 24 * 60 },
          ],
          template: 'returning_reminder',
        },
      ],
    },
  },
});

Follow-up Messages

Send messages after the meeting:

await client.calendar.eventTypes.update(eventType.id, {
  followUps: {
    enabled: true,
    schedule: [
      {
        afterMinutes: 30, // 30 minutes after meeting ends
        type: 'EMAIL',
        template: {
          subject: 'Thank you for meeting with us!',
          body: `
Hi {{attendee_name}},
 
Thank you for meeting with {{host_name}} today.
 
We hope it was helpful! Here are some next steps:
- Review our documentation: https://...
- Schedule a follow-up: {{booking_url}}
 
Best regards,
The Team
          `,
        },
      },
    ],
  },
});

No-Show Follow-up

Handle no-shows:

await client.calendar.eventTypes.update(eventType.id, {
  noShowFollowUp: {
    enabled: true,
    afterMinutes: 15, // After 15 minutes of no-show
    template: {
      subject: "We missed you at today's meeting",
      body: `
Hi {{attendee_name}},
 
We noticed you weren't able to make it to your scheduled {{event_title}}.
 
Would you like to reschedule?
{{reschedule_url}}
 
If something came up, no worries - we understand!
 
Best,
{{host_name}}
      `,
    },
  },
});

Webhook Notifications

Get notified when reminders are sent:

app.post('/webhooks/calendar', (req, res) => {
  const event = req.body;
 
  switch (event.type) {
    case 'reminder.sent':
      console.log('Reminder sent:', event.data);
      break;
 
    case 'reminder.failed':
      console.log('Reminder failed:', event.data.error);
      // Maybe try alternative contact method
      break;
  }
 
  res.status(200).send('OK');
});

Best Practices

1. Timing

First reminder: 24-48 hours before
Second reminder: 1-2 hours before
Final reminder: 15-30 minutes before

2. Channel Selection

Email: Good for detailed information
SMS: Best for last-minute reminders
Both: Highest show rate

3. Content

Keep it concise
Include meeting link prominently
Always include reschedule/cancel options
Timezone-aware formatting

Next Steps

Embedding - Embed booking widgets
Webhooks - Event notifications
API Reference - Complete API docs