How to Give Your AI Agent the Ability to Book Real-World Appointments

Most AI agents today can search, summarize, and reason. But when a user asks "book me a session with a therapist for Tuesday," the agent hits a wall. There's no standard way to check a professional's availability, confirm a slot, or create a real booking — programmatically.

Orita fixes that. It's a scheduling API built specifically for AI agent workflows. One API call to check availability. One more to create a confirmed booking. No UI required.

This guide shows how to connect your agent to Orita in under 30 minutes.

Prerequisites

• An Orita API key (free tier: 250 bookings/month) → Get access
• At least one professional registered in your Orita account with availability set up
• Node.js or Python environment

Option 1: Direct API calls (any framework)

The simplest integration — works with LangChain, CrewAI, AutoGen, or plain code.

Step 1: Get available slots

import { Orita } from "orita-sdk";

const orita = new Orita({ apiKey: process.env.ORITA_API_KEY });

// Get the professional's event types first
const eventTypes = await orita.getEventTypes({ providerId: "your-provider-id" });
const sessionType = eventTypes.data[0]; // e.g., "60-min consultation"

// Check availability for a specific date
const slots = await orita.getSlots({
  providerId: "your-provider-id",
  eventTypeId: sessionType.id,
  date: "2026-08-05"
});

console.log(slots);
// → [{ value: "09:00", label: "9:00 AM" }, { value: "10:00", label: "10:00 AM" }, ...]

Step 2: Create a booking

const booking = await orita.book({
  providerId: "your-provider-id",
  eventTypeId: sessionType.id,
  date: "2026-08-05",
  time: slots[0].value,
  customer: {
    name: "James Park",
    email: "james@example.com"
  }
});

console.log(booking);
// → { bookingId: "bk_18382", status: "confirmed", meeting_url: "https://meet.google.com/..." }

That's it. The professional receives a confirmation email. The customer receives a calendar invite. Your agent is done.

Option 2: LangChain Tool

Wrap Orita as a LangChain tool so your agent can call it autonomously:

from langchain.tools import StructuredTool
from orita_sdk import OritaClient

orita = OritaClient(api_key="your_api_key")

def check_availability(provider_id: str, date: str) -> dict:
    """Check available appointment slots for a professional on a given date (YYYY-MM-DD)."""
    slots = orita.get_slots(provider_id=provider_id, date=date)
    return {"available_slots": slots, "date": date}

def book_appointment(provider_id: str, event_type_id: str, date: str, time: str,
                     customer_name: str, customer_email: str) -> dict:
    """Book an appointment with a professional. Returns booking confirmation."""
    result = orita.book(
        provider_id=provider_id,
        event_type_id=event_type_id,
        date=date,
        time=time,
        customer={"name": customer_name, "email": customer_email}
    )
    return result

availability_tool = StructuredTool.from_function(check_availability)
booking_tool = StructuredTool.from_function(book_appointment)

# Add to your agent
from langchain.agents import AgentExecutor, create_openai_tools_agent
agent = create_openai_tools_agent(llm, [availability_tool, booking_tool], prompt)
executor = AgentExecutor(agent=agent, tools=[availability_tool, booking_tool])

# Now your agent can handle:
# "Book me a session with Dr. Garcia for next Tuesday morning"
result = executor.invoke({"input": "Book me a therapy session for August 5th at 9am with provider ID xyz"})

Option 3: MCP Server (Claude Desktop, Cursor)

Orita ships with a native MCP server. Add it to your Claude Desktop config and the model can check availability and book appointments natively — no code required.

{
  "mcpServers": {
    "orita": {
      "url": "https://orita.online/api/mcp",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}

Available tools: list_professionals, get_slots, create_booking, cancel_booking, get_booking.

What happens after the booking

• The professional gets an email notification with the meeting details
• If they've connected Google Calendar, the event is added automatically
• Your application receives a booking.created webhook with the full booking data
• When the appointment is rescheduled or cancelled, a new webhook fires

Use cases this unlocks

• AI health assistant — user asks "I need a therapist" → agent finds availability → books session → sends confirmation
• AI executive assistant — "Schedule a legal consultation for next week" → agent handles the entire flow
• AI sales agent — qualifies leads then books a follow-up call with a human consultant automatically
• AI concierge — hotel guest asks for a personal training session → agent books with the on-site trainer

Getting started

1. Create your free Orita account — 250 bookings/month, no credit card
2. Register a professional (or yourself) and set up availability
3. Install the SDK: npm install orita-sdk or pip install orita-sdk
4. Read the full API docs