Calendly MCP server for AI agents

Let Claude, ChatGPT or your own agent read and act on Calendly: 11 typed functions through one MCP server. No Calendly API key needed.

Functions
11
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just Calendly

An MCP server for Calendly alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/calendly
Every site

One MCP server for Calendly and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 7
  • findProfilesFinds a person's own Calendly page from their full name and, optionally, their company.

    Arguments

    NameTypeRequired
    namestringYes
    companystringNo

    Returns CalendlyFindProfilesResult

    interface CalendlyProfileCandidate {
      slug: string;
      url: string;
      ownerName: string;       // the name the profile itself shows
      nameMatches: boolean;    // ownerName carries BOTH names asked for, a hint, a namesake passes too
      timezone: string;
      description: string | null;   // the profile's own description, verbatim (often Calendly's stock greeting)
      eventTypes: Array<{ name: string; description: string | null }> | null;  // what the page offers ("Firecrawl-Introduction"); null = could not be read
    }
    
    interface CalendlyFindProfilesResult {
      name: string;
      company: string | null;
      slugsChecked: string[];
      candidates: CalendlyProfileCandidate[];
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/findProfiles

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.findProfiles("Caleb Peffer", "firecrawl");
  • getAvailabilityReturns the real, currently-open time slots for one Calendly event type over the next N days (default 14).

    Arguments

    NameTypeRequired
    profilestringYes
    opts.timezonestringNo
    opts.daysAheadnumberNo

    Returns CalendlyAvailabilityResult

    interface CalendlyEventType {
      slug: string;
      name: string;
      uuid: string;
      url: string;
      description: string | null;
    
      checkout: CalendlyCheckout | null;
    }
    
    interface CalendlyCheckout {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      /** Always https, on the studio's own site. */
      url: string;
      /** ready_to_checkout only: carries_items opens this very slot, product_page opens the studio's schedule. */
      urlKind?: "carries_items" | "signed_in_cart" | "product_page";
      /** unavailable only: out_of_stock (class full, no waitlist) or not_available_for_dates (cancelled). */
      reason?: string;
      detail?: string;
      account: { site: string; hint: string; signedInAs?: string; signInUrl?: string };
      summary: {
        items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[];
        total: string | null;
        currency: string;
        /** ISO start/end of the class or slot, with the studio's UTC offset when the site gives one. */
        dates?: { start: string; end?: string };
      } | null;
      warnings: string[];
    }
    
    interface CalendlySlot {
      startTime: string;
      inviteesRemaining: number;
    }
    
    interface CalendlyDay {
      date: string;
      status: string;  // the site's own labels, read the values off a result, never guess one from prose
      slots: CalendlySlot[];
    }
    
    interface CalendlyAvailabilityResult {
      profileSlug: string;
      eventType: CalendlyEventType;
      timezone: string;
      days: CalendlyDay[];
      otherEventTypes: CalendlyEventType[];
      unavailableReason: string | null;   // non-null = Calendly says this event cannot be booked at all; days is [] BECAUSE of that, not because nothing is open
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/getAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.getAvailability("<profile>");
  • getBookingReads one booking from the link an invitee was sent.

    Arguments

    NameTypeRequired
    linkstringYes

    Returns CalendlyBooking

    interface CalendlyBookingEvent {
      name: string;
      slug: string | null;
      url: string;
      description: string | null;
      durationMinutes: number | null;
    }
    
    interface CalendlyBooking {
      uuid: string;
      eventType: CalendlyBookingEvent;    // the booked event's details
      invitee: {
        name: string;
        email: string;
      };
      startTime: string | null;           // ISO datetime of the booked slot
      durationMinutes: number | null;
      cancellationReason: string | null;  // non-null = the booking has been cancelled and this is why
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/getBooking

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.getBooking("<link>");
  • getBookingFormReads what a Calendly booking page will ask before anyone books.

    Arguments

    NameTypeRequired
    urlstringYes
    opts.eventstring
    Which event on a multi-event profile.
    No

    Returns CalendlyBookingForm

    interface CalendlyEventType {
      slug: string;
      name: string;
      uuid: string;
      url: string;
      description: string | null;
    
      checkout: CalendlyCheckout | null;
    }
    
    interface CalendlyCheckout {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      /** Always https, on the studio's own site. */
      url: string;
      /** ready_to_checkout only: carries_items opens this very slot, product_page opens the studio's schedule. */
      urlKind?: "carries_items" | "signed_in_cart" | "product_page";
      /** unavailable only: out_of_stock (class full, no waitlist) or not_available_for_dates (cancelled). */
      reason?: string;
      detail?: string;
      account: { site: string; hint: string; signedInAs?: string; signInUrl?: string };
      summary: {
        items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[];
        total: string | null;
        currency: string;
        /** ISO start/end of the class or slot, with the studio's UTC offset when the site gives one. */
        dates?: { start: string; end?: string };
      } | null;
      warnings: string[];
    }
    
    interface CalendlyFormQuestion {
      label: string;
      format: string;     // Calendly's own: "string" | "text" | "phone_number" | "select" | "multi_select" | "radios" | "checkboxes"
      required: boolean;
      choices: string[];
    }
    
    interface CalendlyBookingEvent {
      name: string;
      slug: string | null;
      url: string;
      description: string | null;
      durationMinutes: number | null;
    }
    
    interface CalendlyBookingForm {
      url: string;
      profileSlug: string | null;         // null for a calendly.com/d/<hash> share link
      ownerName: string | null;
      eventTypes: CalendlyEventType[];
      event: CalendlyBookingEvent | null; // null when several events exist and none was named
      questions: CalendlyFormQuestion[];  // CUSTOM questions; name + email are always asked on top
      nextAvailability: string | null;    // null + unavailableReason null = fully booked, not unread
      unavailableReason: string | null;   // non-null = Calendly says this cannot be booked
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/getBookingForm

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.getBookingForm("<url>");
  • getEventTypesLists every event type a Calendly profile currently offers.

    Arguments

    NameTypeRequired
    profilestringYes

    Returns CalendlyEventTypesResult

    interface CalendlyEventType {
      slug: string;
      name: string;
      uuid: string;
      url: string;
      description: string | null;
    
      checkout: CalendlyCheckout | null;
    }
    
    interface CalendlyCheckout {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      /** Always https, on the studio's own site. */
      url: string;
      /** ready_to_checkout only: carries_items opens this very slot, product_page opens the studio's schedule. */
      urlKind?: "carries_items" | "signed_in_cart" | "product_page";
      /** unavailable only: out_of_stock (class full, no waitlist) or not_available_for_dates (cancelled). */
      reason?: string;
      detail?: string;
      account: { site: string; hint: string; signedInAs?: string; signInUrl?: string };
      summary: {
        items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[];
        total: string | null;
        currency: string;
        /** ISO start/end of the class or slot, with the studio's UTC offset when the site gives one. */
        dates?: { start: string; end?: string };
      } | null;
      warnings: string[];
    }
    
    interface CalendlyProfile {
      slug: string;
      name: string;
      timezone: string;
    }
    
    interface CalendlyEventTypesResult {
      profile: CalendlyProfile;
      eventTypes: CalendlyEventType[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/getEventTypes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.getEventTypes("<profile>");
  • getRoutingFormReads a Calendly routing form.

    Arguments

    NameTypeRequired
    formstringYes

    Returns CalendlyRoutingForm

    interface CalendlyRoutingFormField {
      id: string | null;
      label: string;
      type: string;
      required: boolean;
      choices: string[];
    }
    
    interface CalendlyRoutingForm {
      uuid: string;
      name: string;
      organization: { uuid: string | null; ownerName: string | null; logoUrl: string | null };
      fields: CalendlyRoutingFormField[];   // [] when the form routes an external (HubSpot/Marketo) form
      submitText: string | null;
      unavailableReason: string | null;     // Calendly's own reason the form cannot be used
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/getRoutingForm

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.getRoutingForm("40d00706-9862-459b-b467-2b8ea40f5563");
  • listPackagesLists the prepaid session packages a Calendly profile sells (several meetings bought together, or a one-off payment link).

    Arguments

    NameTypeRequired
    profilestringYes

    Returns CalendlyPackagesResult

    interface CalendlyPackageSession {
      eventTypeUuid: string;
      eventTypeName: string | null;       // null when the event type is secret
      count: number | null;
      unit: string;                       // "SESSIONS"
    }
    
    interface CalendlyPackage {
      id: string;
      name: string;
      description: string | null;
      offeringType: string;               // "MEETING_PACKAGE" or "PAYMENT_LINK"
      price: { amount: number | null; currency: string | null };  // major unit: dollars, not cents
      sessions: CalendlyPackageSession[];
      url: string;                        // where a person would buy it; never bought here
    }
    
    interface CalendlyPackagesResult {
      profileSlug: string;
      packages: CalendlyPackage[];        // [] when the profile sells none
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/listPackages

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.listPackages("<profile>");
Act 4
  • bookMeetingBooks a slot on a Calendly event the way an invitee does on the booking page.

    Arguments

    NameTypeRequired
    urlstring
    Event url, profile url + event, or /d/ share link.
    Yes
    startTimestring
    A slot's startTime exactly as getAvailability returned it.
    Yes
    namestringYes
    emailstringYes
    timezonestringNo
    guestsstring[]No
    answersRecord<string, string>
    Custom-question answers keyed by the question name.
    No
    eventstringNo

    Returns CalendlyBookMeetingResult

    interface CalendlyBookMeetingResult {
      uuid: string;
      eventName: string;
      startTime: string | null;
      invitee: { name: string; email: string };
      cancelUrl: string | null;
      rescheduleUrl: string | null;
      confirmationUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/bookMeeting

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.bookMeeting({
      url: "<url>",
      startTime: "<startTime>",
      name: "<name>",
      email: "<email>"
    });
  • cancelBookingCancels a booking the caller made, from the cancel link Calendly emailed them (calendly.com/cancellations/<uuid>) or the invitee uuid bookMeeting…

    Arguments

    NameTypeRequired
    linkstring
    The cancel / reschedule / confirmation link, or the bare invitee uuid.
    Yes
    reasonstring
    The reason the host sees.
    No

    Returns CalendlyCancelBookingResult

    interface CalendlyCancelBookingResult {
      uuid: string;
      cancelled: true;
      reason: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/cancelBooking

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.cancelBooking({ link: "<link>" });
  • rescheduleBookingMoves a booking the caller made to another open time, from the reschedule link Calendly emailed them (calendly.com/reschedulings/<uuid>) and a new…

    Arguments

    NameTypeRequired
    linkstring
    The reschedule / cancel / confirmation link, or the bare invitee uuid.
    Yes
    urlstring
    The event url the booking was made on (host page or /d/ share link).
    Yes
    startTimestring
    The new slot, exactly as getAvailability returned it.
    Yes
    timezonestringNo
    guestsstring[]No
    answersRecord<string, string>
    Custom-question answers keyed by the question name.
    No
    eventstringNo

    Returns CalendlyBookMeetingResult

    interface CalendlyBookMeetingResult {
      uuid: string;
      eventName: string;
      startTime: string | null;
      invitee: { name: string; email: string };
      cancelUrl: string | null;
      rescheduleUrl: string | null;
      confirmationUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/rescheduleBooking

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.rescheduleBooking({ link: "<link>", url: "<url>", startTime: "<startTime>" });
  • submitRoutingFormAnswers a Calendly routing form and returns where it sends you.

    Arguments

    NameTypeRequired
    formstring
    The form uuid, or any url carrying it.
    Yes
    answersRecord<string, string>
    Keyed by the field id or the question label from getRoutingForm; a choice question takes one of its choices.
    Yes
    paramsRecord<string, string>
    Url parameters the landing page was opened with (utm_*, …).
    No

    Returns CalendlySubmitRoutingFormResult

    interface CalendlySubmitRoutingFormResult {
      formUuid: string;
      resultType: string; // "event_type_id" | "arbitrary_url" | "thank_you_text"
      url: string | null; // where the form routes you; never followed
      thankYou: { headline: string; body: string | null } | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/calendly/submitRoutingForm

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.calendly.submitRoutingForm({ form: "<form>", answers: "<answers>" });

Use it from code