Connect Guesty to Claude

mkdir guesty-mcp && cd guesty-mcp
npm init -y
npm pkg set type="module"
npm install @modelcontextprotocol/sdk zod

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { readFileSync, writeFileSync } from "fs";
import { join } from "path";
import { tmpdir } from "os";

const API_BASE = "https://open-api.guesty.com/v1";
const TOKEN_URL = "https://open-api.guesty.com/oauth2/token";
const CLIENT_ID = process.env.GUESTY_CLIENT_ID;
const CLIENT_SECRET = process.env.GUESTY_CLIENT_SECRET;
const CACHE = join(tmpdir(), "guesty-mcp-token.json");

if (!CLIENT_ID || !CLIENT_SECRET) {
  console.error("Set GUESTY_CLIENT_ID and GUESTY_CLIENT_SECRET first.");
  process.exit(1);
}

// Guesty allows only 5 tokens per client per 24h, and each lasts 24h.
// Cache the token to disk so restarts reuse it instead of minting a new one.
let token = null;
let tokenExp = 0;

async function getToken() {
  const now = Date.now();
  if (token && now < tokenExp) return token;
  try {
    const c = JSON.parse(readFileSync(CACHE, "utf8"));
    if (c.access_token && now < c.expires_at) {
      token = c.access_token; tokenExp = c.expires_at; return token;
    }
  } catch {}
  const res = await fetch(TOKEN_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json", Accept: "application/json" },
    body: JSON.stringify({ clientId: CLIENT_ID, clientSecret: CLIENT_SECRET }),
  });
  if (!res.ok) throw new Error(`Token request failed (${res.status})`);
  const data = await res.json();
  token = data.access_token;
  // Refresh ~1 hour before the 24h expiry, per Guesty's guidance.
  tokenExp = now + (data.expires_in - 3600) * 1000;
  try { writeFileSync(CACHE, JSON.stringify({ access_token: token, expires_at: tokenExp })); } catch {}
  return token;
}

async function get(path) {
  const res = await fetch(`${API_BASE}${path}`, {
    headers: { Authorization: `Bearer ${await getToken()}`, Accept: "application/json" },
  });
  if (!res.ok) throw new Error(`Guesty ${res.status}: ${await res.text()}`);
  return res.json();
}

function json(data) {
  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
}

const server = new McpServer({ name: "guesty", version: "1.0.0" });

server.registerTool(
  "list_listings",
  {
    description: "List the listings (properties) in the Guesty account.",
    inputSchema: {
      limit: z.number().optional().describe("Max rows, 1-100, default 100"),
      skip: z.number().optional().describe("Rows to skip, for paging"),
    },
  },
  async ({ limit, skip }) => {
    const q = new URLSearchParams({ limit: String(limit ?? 100) });
    if (skip) q.set("skip", String(skip));
    return json(await get(`/listings?${q}`));
  }
);

server.registerTool(
  "get_listing",
  {
    description: "Get full details for one listing by its id.",
    inputSchema: { id: z.string().describe("Guesty listing id") },
  },
  async ({ id }) => json(await get(`/listings/${id}`))
);

server.registerTool(
  "list_reservations",
  {
    description: "List reservations. Use skip to page through results.",
    inputSchema: {
      limit: z.number().optional().describe("Max rows, 1-100, default 100"),
      skip: z.number().optional().describe("Rows to skip, for paging"),
    },
  },
  async ({ limit, skip }) => {
    const q = new URLSearchParams({ limit: String(limit ?? 100) });
    if (skip) q.set("skip", String(skip));
    return json(await get(`/reservations?${q}`));
  }
);

server.registerTool(
  "get_reservation",
  {
    description: "Get one reservation by its id, including guest, dates, and status.",
    inputSchema: { id: z.string().describe("Guesty reservation id") },
  },
  async ({ id }) => json(await get(`/reservations/${id}`))
);

server.registerTool(
  "get_calendar",
  {
    description: "Get availability and nightly pricing for one or more listings over a date range.",
    inputSchema: {
      listingIds: z.string().describe("One listing id, or several comma-separated"),
      startDate: z.string().describe("First day, YYYY-MM-DD"),
      endDate: z.string().describe("Last day, YYYY-MM-DD"),
    },
  },
  async ({ listingIds, startDate, endDate }) => {
    const q = new URLSearchParams({ listingIds, startDate, endDate });
    return json(await get(`/availability-pricing/api/calendar/listings?${q}`));
  }
);

server.registerTool(
  "get_guest",
  {
    description: "Get one guest by id (find the guestId on a reservation).",
    inputSchema: { guestId: z.string().describe("Guesty guest id") },
  },
  async ({ guestId }) => json(await get(`/guests-crud/${guestId}`))
);

const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Guesty MCP server running on stdio");

{
  "mcpServers": {
    "guesty": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/guesty-mcp/index.js"],
      "env": {
        "GUESTY_CLIENT_ID": "your-client-id",
        "GUESTY_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

claude mcp add \
  --env GUESTY_CLIENT_ID=your-client-id \
  --env GUESTY_CLIENT_SECRET=your-client-secret \
  --transport stdio guesty \
  -- node /ABSOLUTE/PATH/TO/guesty-mcp/index.js

Which reservations check in over the next 7 days? Group them by listing.

How many active listings do we have, and which are inactive?

Get the calendar for this listing id for the next 14 days and flag open nights.