How to Integrate Replit with Acuity Scheduling

1import os
2import requests
3from datetime import date, timedelta
4
5USER_ID = os.environ["ACUITY_USER_ID"]
6API_KEY = os.environ["ACUITY_API_KEY"]
7BASE_URL = "https://acuityscheduling.com/api/v1"
8
9# Basic Auth: User ID as username, API key as password
10AUTH = (USER_ID, API_KEY)
11
12def get_appointment_types() -> list:
13    """Fetch all active appointment types from the Acuity account."""
14    response = requests.get(f"{BASE_URL}/appointment-types", auth=AUTH)
15    response.raise_for_status()
16    return response.json()
17
18def get_available_dates(appointment_type_id: int, months: int = 1) -> list:
19    """Get dates with available slots for the next N months."""
20    today = date.today()
21    end_date = today + timedelta(days=30 * months)
22    params = {
23        "appointmentTypeID": appointment_type_id,
24        "month": today.strftime("%Y-%m")
25    }
26    response = requests.get(f"{BASE_URL}/availability/dates", params=params, auth=AUTH)
27    response.raise_for_status()
28    return response.json()
29
30def get_available_times(appointment_type_id: int, date_str: str) -> list:
31    """Get available time slots for a specific date. date_str format: YYYY-MM-DD"""
32    params = {
33        "appointmentTypeID": appointment_type_id,
34        "date": date_str
35    }
36    response = requests.get(f"{BASE_URL}/availability/times", params=params, auth=AUTH)
37    response.raise_for_status()
38    return response.json()
39
40def create_appointment(
41    appointment_type_id: int,
42    datetime_str: str,
43    first_name: str,
44    last_name: str,
45    email: str,
46    phone: str = ""
47) -> dict:
48    """
49    Book an appointment.
50    datetime_str format: '2026-04-15T14:00:00-0500'
51    """
52    data = {
53        "appointmentTypeID": appointment_type_id,
54        "datetime": datetime_str,
55        "firstName": first_name,
56        "lastName": last_name,
57        "email": email,
58        "phone": phone
59    }
60    response = requests.post(f"{BASE_URL}/appointments", json=data, auth=AUTH)
61    response.raise_for_status()
62    return response.json()
63
64def get_upcoming_appointments(max_results: int = 20) -> list:
65    """Fetch upcoming appointments sorted by start time."""
66    params = {"max": max_results, "direction": "ASC"}
67    response = requests.get(f"{BASE_URL}/appointments", params=params, auth=AUTH)
68    response.raise_for_status()
69    return response.json()
70
71def cancel_appointment(appointment_id: int) -> bool:
72    """Cancel an appointment by ID."""
73    response = requests.delete(f"{BASE_URL}/appointments/{appointment_id}", auth=AUTH)
74    return response.status_code == 200
75
76# Example usage
77if __name__ == "__main__":
78    # List appointment types
79    types = get_appointment_types()
80    print("Appointment types:")
81    for t in types:
82        print(f"  [{t['id']}] {t['name']} — {t['duration']} min")
83
84    if types:
85        type_id = types[0]["id"]
86        # Get available dates this month
87        dates = get_available_dates(type_id)
88        print(f"\nAvailable dates: {[d['date'] for d in dates[:5]]}")
89
90        if dates:
91            # Get times on the first available date
92            times = get_available_times(type_id, dates[0]["date"])
93            print(f"Available times on {dates[0]['date']}: {[t['time'] for t in times[:3]]}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const ACUITY_USER_ID = process.env.ACUITY_USER_ID;
8const ACUITY_API_KEY = process.env.ACUITY_API_KEY;
9const BASE_URL = 'https://acuityscheduling.com/api/v1';
10
11// Axios instance with Basic Auth pre-configured
12const acuity = axios.create({
13  baseURL: BASE_URL,
14  auth: {
15    username: ACUITY_USER_ID,
16    password: ACUITY_API_KEY
17  }
18});
19
20// List all appointment types
21app.get('/appointment-types', async (req, res) => {
22  try {
23    const response = await acuity.get('/appointment-types');
24    res.json(response.data);
25  } catch (err) {
26    console.error('Acuity error:', err.response?.data);
27    res.status(err.response?.status || 500).json({ error: err.message });
28  }
29});
30
31// Check available times for an appointment type on a date
32// Query params: appointmentTypeID, date (YYYY-MM-DD)
33app.get('/availability', async (req, res) => {
34  const { appointmentTypeID, date } = req.query;
35  if (!appointmentTypeID || !date) {
36    return res.status(400).json({ error: 'appointmentTypeID and date are required' });
37  }
38  try {
39    const response = await acuity.get('/availability/times', {
40      params: { appointmentTypeID, date }
41    });
42    res.json(response.data);
43  } catch (err) {
44    res.status(err.response?.status || 500).json({ error: err.message });
45  }
46});
47
48// Book an appointment
49app.post('/appointments', async (req, res) => {
50  const { appointmentTypeID, datetime, firstName, lastName, email, phone } = req.body;
51  if (!appointmentTypeID || !datetime || !firstName || !email) {
52    return res.status(400).json({ error: 'appointmentTypeID, datetime, firstName, and email are required' });
53  }
54  try {
55    const response = await acuity.post('/appointments', {
56      appointmentTypeID,
57      datetime,
58      firstName,
59      lastName: lastName || '',
60      email,
61      phone: phone || ''
62    });
63    res.status(201).json(response.data);
64  } catch (err) {
65    console.error('Booking error:', err.response?.data);
66    res.status(err.response?.status || 500).json({
67      error: err.response?.data?.message || err.message
68    });
69  }
70});
71
72// Cancel an appointment
73app.delete('/appointments/:id', async (req, res) => {
74  try {
75    await acuity.delete(`/appointments/${req.params.id}`);
76    res.json({ success: true, message: 'Appointment cancelled' });
77  } catch (err) {
78    res.status(err.response?.status || 500).json({ error: err.message });
79  }
80});
81
82// Get upcoming appointments
83app.get('/appointments', async (req, res) => {
84  try {
85    const response = await acuity.get('/appointments', {
86      params: { max: req.query.max || 20, direction: 'ASC' }
87    });
88    res.json(response.data);
89  } catch (err) {
90    res.status(err.response?.status || 500).json({ error: err.message });
91  }
92});
93
94app.listen(3000, '0.0.0.0', () => {
95  console.log('Acuity Scheduling proxy server running on port 3000');
96});

1from flask import Flask, request, jsonify
2import os
3import hmac
4import hashlib
5
6app = Flask(__name__)
7
8# Acuity webhook secret (set in Acuity Integrations > API > Webhooks)
9WEBHOOK_SECRET = os.environ.get("ACUITY_WEBHOOK_SECRET", "")
10
11@app.route('/acuity/webhook', methods=['POST'])
12def acuity_webhook():
13    # Verify webhook signature if secret is configured
14    if WEBHOOK_SECRET:
15        signature = request.headers.get('X-Acuity-Signature', '')
16        expected = hmac.new(
17            WEBHOOK_SECRET.encode(),
18            request.data,
19            hashlib.sha256
20        ).hexdigest()
21        if not hmac.compare_digest(signature, expected):
22            return jsonify({'error': 'Invalid signature'}), 401
23
24    payload = request.json
25    if not payload:
26        return jsonify({'error': 'No payload'}), 400
27
28    action = payload.get('action')  # 'scheduled', 'rescheduled', 'cancelled', 'changed'
29    appointment = payload.get('appointment', {})
30
31    appt_id = appointment.get('id')
32    client_email = appointment.get('email')
33    appt_type = appointment.get('type')
34    appt_time = appointment.get('datetime')
35
36    print(f"Acuity webhook: action={action}, id={appt_id}, client={client_email}")
37
38    if action == 'scheduled':
39        # New appointment booked — sync to database, send custom confirmation, etc.
40        print(f"New booking: {appt_type} at {appt_time} for {client_email}")
41    elif action == 'cancelled':
42        # Appointment cancelled — update database, trigger refund workflow, etc.
43        print(f"Cancelled: appointment {appt_id} for {client_email}")
44    elif action == 'rescheduled':
45        print(f"Rescheduled: appointment {appt_id} to {appt_time}")
46
47    return jsonify({'received': True}), 200
48
49if __name__ == '__main__':
50    app.run(host='0.0.0.0', port=3000)