Connect Streamline to Claude

Export the reports you already run

From Streamline, pull the reports that match the questions you want answered: a reservation report for pacing and occupancy questions, housekeeping and work order reports for operations questions, owner statements for owner-call prep. File formats like CSV or Excel are ideal because Claude can compute on them directly rather than reading a PDF.

Give the files to Claude

Two options, in increasing order of convenience:

• Attach in a chat. On claude.ai or in Claude Desktop, attach the export files to a conversation and ask your question. Works instantly, zero setup.
• A watched exports folder. In Claude Desktop, use the filesystem MCP server (one of Anthropic's reference servers) pointed at a ~/streamline-exports folder. Drop each week's exports in; Claude can then read, join, and compare files across weeks without you re-attaching anything.

Ask portfolio-level questions

Start with one report and one question ("which properties are pacing behind last year?"), then combine files ("join the work order export to the reservation export and tell me which high-revenue units are generating the most maintenance"). Claude handles the joining; your job is knowing which questions matter.

The limitation to keep in mind: exports are snapshots. Anything time-sensitive, like today's turnover status, is only as fresh as your last export. For live data you need path B.

Get partner API access and tokens

Streamline's API is available to approved third-party partners. If you're an operator, the fastest route is often through a vendor already integrated with Streamline; if you're building something new, apply through Streamline's partner application. Approved partners work inside the Partner X portal, where, per Streamline, you can find the API documentation and renew tokens within the API documentation tab.

You'll end up with a token_key and token_secret pair scoped to the property management company you're integrating with.

Understand the wire format

Streamline's API is not REST in the path-per-resource sense. Community integration code (the jhample/streamline PHP sample on GitHub) shows the shape: every call is a JSON POST to a single endpoint, https://web.streamlinevrs.com/api/json, with a methodName and a params object that carries your token_key and token_secret plus the method's arguments. Method names in that sample include GetReservationInfo, GetAllReservationsByEmail, and GetReservationFlags:

POST https://web.streamlinevrs.com/api/json
Content-Type: application/json

{
  "methodName": "GetReservationInfo",
  "params": {
    "token_key": "YOUR_TOKEN_KEY",
    "token_secret": "YOUR_TOKEN_SECRET",
    "confirmation_id": "269028"
  }
}

The full method catalog lives in the partner-only documentation, so treat the names above as verified examples, not the complete surface. Your Partner X docs are the source of truth for which methods your token can call.

Wrap it in an MCP server

Because everything is one endpoint plus a method name, the MCP wrapper is unusually small. Set up a Node project (npm init -y, then npm install @modelcontextprotocol/sdk zod, with "type": "module" in package.json) and adapt this skeleton, swapping in the methods your partner docs give you:

#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const TOKEN_KEY = process.env.STREAMLINE_TOKEN_KEY;
const TOKEN_SECRET = process.env.STREAMLINE_TOKEN_SECRET;
const API_URL = "https://web.streamlinevrs.com/api/json";

if (!TOKEN_KEY || !TOKEN_SECRET) {
  console.error("Missing STREAMLINE_TOKEN_KEY or STREAMLINE_TOKEN_SECRET");
  process.exit(1);
}

// Every Streamline call: one endpoint, methodName + params.
async function streamlineCall(methodName, params = {}) {
  const response = await fetch(API_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      methodName,
      params: {
        token_key: TOKEN_KEY,
        token_secret: TOKEN_SECRET,
        ...params,
      },
    }),
  });
  if (!response.ok) {
    throw new Error(`Streamline API ${response.status}: ${await response.text()}`);
  }
  return response.json();
}

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

// Example tool: look up a reservation by confirmation number.
// GetReservationInfo appears in community integration code; confirm
// it and add the rest of your methods from the Partner X API docs.
server.tool(
  "get-reservation",
  "Fetch a Streamline reservation by confirmation number. Returns guest, dates, and pricing details.",
  {
    confirmation_id: z.string().describe("Streamline reservation confirmation number"),
  },
  async ({ confirmation_id }) => {
    const data = await streamlineCall("GetReservationInfo", { confirmation_id });
    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
  }
);

// Example tool: all reservations for a guest email.
server.tool(
  "get-reservations-by-email",
  "List all Streamline reservations associated with a guest email address.",
  {
    email: z.string().describe("Guest email address"),
  },
  async ({ email }) => {
    const data = await streamlineCall("GetAllReservationsByEmail", { email });
    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Keep it read-only. Streamline is a system of record for trust accounting and owner money; a query-only server means Claude can look at everything and change nothing. If you later add write methods, run them in a separate server so exploration and mutation never share a connection.

Register it with Claude Desktop

Add the server to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\):

{
  "mcpServers": {
    "streamline": {
      "command": "node",
      "args": ["/absolute/path/to/streamline-mcp/index.js"],
      "env": {
        "STREAMLINE_TOKEN_KEY": "your_token_key",
        "STREAMLINE_TOKEN_SECRET": "your_token_secret"
      }
    }
  }
}

Then fully quit and reopen Claude Desktop (Cmd+Q on macOS; closing the window is not enough) and ask it to fetch a reservation you know the confirmation number for.