Bolt.new AI and Acuity Scheduling integration: Step-by-Step Guide 2025

The direct answer: You integrate Bolt.new with Acuity Scheduling by calling Acuity’s official REST API from the server-side code you run inside a Bolt.new project. You authenticate using Acuity’s Basic Auth (API key + API secret), store those credentials as environment variables, and then write API routes or backend functions that talk to Acuity’s endpoints (like listing appointment types, creating appointments, or reading schedules). There is no native “Bolt-to-Acuity integration”—you just use standard HTTP requests to Acuity’s real API.

Below is the complete breakdown of how to actually make it work safely, correctly, and in a way that junior developers can follow.

 

What Acuity Actually Provides

 

Acuity Scheduling (now under Squarespace) exposes a real REST API. It uses:

• Basic Auth: username = API key, password = API secret.
• JSON responses for appointments, availability, clients, etc.
• HTTPS endpoints like https://acuityscheduling.com/api/v1/appointments.
• Optional webhooks for appointment-created, rescheduled, etc.

This means your only job is to send authenticated HTTP requests from Bolt’s server runtime to Acuity’s API.

 

Where Bolt.new Fits In

 

Bolt.new gives you a sandboxed full‑stack environment. It does not have prebuilt Acuity connectors. You do integration exactly as with any external API:

• Store API key + secret inside Bolt.new as environment variables.
• Write backend code (Node.js or similar) that uses fetch or axios to call Acuity.
• Optionally expose your own API endpoints for your frontend or AI agent to consume.
• Optionally create “webhook receiver” routes to accept Acuity webhook events.

This is the same real-world pattern you’d use outside Bolt, just faster to prototype.

 

Storing Credentials in Bolt.new

 

In your Bolt.new project, put these in environment variables (never hardcode credentials):

• ACUITY_API_KEY
• ACUITY_API_SECRET

Inside code you load them with process.env.ACUITY_API_KEY.

 

Minimal Working Backend Example (Node.js)

 

This code shows how to call Acuity’s GET /appointments endpoint from a Bolt server route. It is a real, working pattern.

// Example: pages/api/acuity-appointments.js
// Bolt.new uses standard Node.js server routes.

export default async function handler(req, res) {
  try {
    const key = process.env.ACUITY_API_KEY;
    const secret = process.env.ACUITY_API_SECRET;

    const authString = Buffer.from(`${key}:${secret}`).toString("base64");

    const response = await fetch(
      "https://acuityscheduling.com/api/v1/appointments",
      {
        method: "GET",
        headers: {
          Authorization: `Basic ${authString}`
        }
      }
    );

    const data = await response.json();
    res.status(200).json(data);
  } catch (err) {
    res.status(500).json({ error: "Acuity request failed", details: err.message });
  }
}

You can now hit /api/acuity-appointments from your frontend, or let your AI agent inside Bolt call it when needed.

 

Creating Appointments (POST)

 

Here is a real example of creating an appointment through Acuity:

const createAcuityAppointment = async (payload) => {
  const key = process.env.ACUITY_API_KEY;
  const secret = process.env.ACUITY_API_SECRET;

  const authString = Buffer.from(`${key}:${secret}`).toString("base64");

  const response = await fetch(
    "https://acuityscheduling.com/api/v1/appointments",
    {
      method: "POST",
      headers: {
        Authorization: `Basic ${authString}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload) // Example: { appointmentTypeID, datetime, firstName, lastName, email }
    }
  );

  return await response.json();
};

Inside Bolt.new, you expose this helper in an API route or call it from server actions.

 

Receiving Webhooks From Acuity

 

Acuity can POST data to your server when events occur (like “appointment created”). In Bolt.new, you create a route like:

// pages/api/acuity-webhook.js

export default async function handler(req, res) {
  // Acuity sends JSON about appointment events
  console.log("Webhook payload:", req.body);

  // You can store it, trigger notifications, etc.
  res.status(200).send("OK");
}

You then paste the route’s public URL into the Acuity dashboard under Webhooks.

Note: During development in Bolt, you may need to expose a public dev URL (Bolt gives this) or temporarily proxy through tools like ngrok if needed in local environments.

 

Integrating With Bolt's AI Agent

 

Once your backend API endpoints are working, you simply “teach” the AI agent in Bolt that it may call them. For example, if you build an endpoint /api/create-appointment, the agent can call it when a user says “Book me a session Tuesday at 2pm”.

The AI agent never touches the Acuity API directly — it calls your safe endpoints. This keeps keys private and makes integration stable.

 

The Real Workflow Summary

 

• Create Acuity API key + secret in Acuity's Admin settings.
• Store them in Bolt.new environment variables.
• Build backend API routes inside Bolt that talk to Acuity via Basic Auth.
• Test routes using Bolt’s live preview.
• Hook frontend or Bolt AI agent to these routes.
• (Optional) Configure Acuity webhooks to hit Bolt.new routes for real-time updates.

This is the cleanest, correct, production-style way to integrate Bolt.new with Acuity Scheduling.