Overview

Event types define what can be booked. Each event type has its own duration, location, availability, and booking rules.

Creating Event Types

Basic Event Type

TypeScript:

const eventType = await client.calendar.eventTypes.create({
  title: 'Quick Call',
  slug: 'quick-call',
  duration: 15,
  description: 'A quick 15-minute call',
});

Python:

event_type = client.calendar.event_types.create(
    title="Quick Call",
    slug="quick-call",
    duration=15,
    description="A quick 15-minute call",
)

With All Options

const eventType = await client.calendar.eventTypes.create({
  // Basic info
  title: 'Strategy Session',
  slug: 'strategy',
  duration: 60,
  description: 'Deep-dive strategy session',
 
  // Location
  location: {
    type: 'GOOGLE_MEET',
  },
 
  // Scheduling rules
  scheduleId: 'schedule_xxx',
  bufferBefore: 10,
  bufferAfter: 15,
  minimumNotice: 24 * 60, // 24 hours in minutes
  maximumAdvance: 30, // days
 
  // Slot settings
  slotInterval: 30,
  slotsPerDay: 4,
 
  // Booking settings
  requiresConfirmation: false,
  allowCancellation: true,
  cancellationDeadline: 12 * 60, // 12 hours
 
  // Questions
  questions: [
    {
      label: 'What would you like to discuss?',
      type: 'TEXTAREA',
      required: true,
    },
    {
      label: 'Company size',
      type: 'SELECT',
      options: ['1-10', '11-50', '51-200', '200+'],
      required: true,
    },
  ],
 
  // Metadata
  metadata: {
    category: 'sales',
    priority: 'high',
  },
});

Event Type Properties

Core Properties

Property	Type	Description
`title`	string	Display name
`slug`	string	URL-friendly identifier
`duration`	number	Length in minutes
`description`	string	Description shown to bookers
`scheduleId`	string	Linked availability schedule

Location Types

// Video conferencing
location: { type: 'GOOGLE_MEET' }
location: { type: 'ZOOM' }
location: { type: 'TEAMS' }
 
// Phone
location: { type: 'PHONE', phone: '+1234567890' }
location: { type: 'PHONE_INBOUND' } // Attendee provides number
 
// In-person
location: {
  type: 'IN_PERSON',
  address: '123 Main St, Suite 100',
}
 
// Custom link
location: {
  type: 'LINK',
  link: 'https://meet.example.com/room',
}

Buffer Times

Add breaks between meetings:

await client.calendar.eventTypes.update(eventType.id, {
  bufferBefore: 10,  // 10 minutes before
  bufferAfter: 15,   // 15 minutes after
});

Booking Limits

Control when and how often events can be booked:

await client.calendar.eventTypes.update(eventType.id, {
  minimumNotice: 60,      // Minimum 1 hour notice
  maximumAdvance: 60,     // Can book up to 60 days ahead
  slotInterval: 15,       // Slots start every 15 minutes
  slotsPerDay: 8,         // Max 8 bookings per day
  slotsPerWeek: 20,       // Max 20 bookings per week
});

Duration Options

Fixed Duration

const eventType = await client.calendar.eventTypes.create({
  title: 'Consultation',
  duration: 30,
});

Multiple Durations

Let bookers choose duration:

const eventType = await client.calendar.eventTypes.create({
  title: 'Consultation',
  durationOptions: [15, 30, 60],
  defaultDuration: 30,
});

Custom Questions

Collect information from bookers:

Question Types

const eventType = await client.calendar.eventTypes.create({
  title: 'Discovery Call',
  slug: 'discovery',
  duration: 30,
  questions: [
    // Text input
    {
      label: 'Company name',
      type: 'TEXT',
      required: true,
    },
 
    // Long text
    {
      label: 'What challenges are you facing?',
      type: 'TEXTAREA',
      required: true,
    },
 
    // Dropdown
    {
      label: 'How did you hear about us?',
      type: 'SELECT',
      options: ['Search', 'Referral', 'Social Media', 'Other'],
      required: false,
    },
 
    // Radio buttons
    {
      label: 'Preferred contact method',
      type: 'RADIO',
      options: ['Email', 'Phone', 'SMS'],
      required: true,
    },
 
    // Checkboxes
    {
      label: 'Topics to discuss',
      type: 'CHECKBOX',
      options: ['Pricing', 'Features', 'Implementation', 'Support'],
      required: true,
    },
 
    // Phone number
    {
      label: 'Phone number',
      type: 'PHONE',
      required: false,
    },
  ],
});

Conditional Questions

Show questions based on previous answers:

questions: [
  {
    id: 'company_size',
    label: 'Company size',
    type: 'SELECT',
    options: ['1-10', '11-50', '50+'],
    required: true,
  },
  {
    id: 'enterprise_needs',
    label: 'What enterprise features do you need?',
    type: 'TEXTAREA',
    required: true,
    showWhen: {
      questionId: 'company_size',
      equals: '50+',
    },
  },
]

Managing Event Types

List Event Types

const eventTypes = await client.calendar.eventTypes.list();
 
for (const et of eventTypes) {
  console.log(`${et.title}: ${et.bookingUrl}`);
}

Update Event Type

await client.calendar.eventTypes.update(eventType.id, {
  title: 'Updated Title',
  duration: 45,
  description: 'New description',
});

Enable/Disable

// Disable (hide from booking page)
await client.calendar.eventTypes.update(eventType.id, {
  isActive: false,
});
 
// Re-enable
await client.calendar.eventTypes.update(eventType.id, {
  isActive: true,
});

Delete Event Type

await client.calendar.eventTypes.delete(eventType.id);

Confirmation Workflows

Auto-confirm

Bookings are automatically confirmed:

await client.calendar.eventTypes.create({
  title: 'Open Office Hours',
  requiresConfirmation: false,
});

Manual Confirmation

Require host to approve:

await client.calendar.eventTypes.create({
  title: 'VIP Consultation',
  requiresConfirmation: true,
  confirmationDeadline: 24 * 60, // 24 hours to confirm
});

Confirm/Reject Bookings

// Confirm pending booking
await client.calendar.bookings.confirm(booking.uid);
 
// Reject with reason
await client.calendar.bookings.reject(booking.uid, {
  reason: 'Schedule conflict',
});

Cancellation Policies

await client.calendar.eventTypes.create({
  title: 'Paid Consultation',
  allowCancellation: true,
  allowRescheduling: true,
  cancellationDeadline: 24 * 60, // 24 hours before
  reschedulingDeadline: 12 * 60, // 12 hours before
});

Recurring Events

Allow recurring bookings:

await client.calendar.eventTypes.create({
  title: 'Weekly Coaching',
  duration: 60,
  allowRecurring: true,
  recurringOptions: {
    frequencies: ['WEEKLY', 'BIWEEKLY'],
    maxOccurrences: 12,
  },
});

Group Events

Allow multiple attendees per slot:

await client.calendar.eventTypes.create({
  title: 'Group Workshop',
  duration: 120,
  isGroup: true,
  maxAttendees: 10,
  minAttendees: 3, // Minimum to run
});

Payment Integration

Require payment for bookings:

await client.calendar.eventTypes.create({
  title: 'Consulting Hour',
  duration: 60,
  payment: {
    required: true,
    amount: 150,
    currency: 'USD',
    provider: 'STRIPE',
  },
});

Event Type Templates

Use templates for common configurations:

// List available templates
const templates = await client.calendar.eventTypes.listTemplates();
 
// Create from template
const eventType = await client.calendar.eventTypes.createFromTemplate({
  templateId: 'sales-demo',
  title: 'Product Demo',
  slug: 'demo',
});

Next Steps

Availability - Configure schedules
Bookings - Manage reservations
Team Scheduling - Multi-host events