Key Data does not have an MCP server, official or community-built, as of July 2026. But it does have two things most STR analytics tools lack: clean multi-format exports on every dashboard, and a documented REST API. That gives you two real ways to connect Key Data to Claude: export a dashboard as Excel or CSV and hand the file to Claude, which works on every account today, or wrap the Key Data API in a small MCP server of your own, which works if Key Data has issued your organization an API key.

Key Data, recently rebranded KeyData at keydata.co, is the direct-source benchmarking platform for professional property managers: verified reservation data from 80+ PMS integrations across 17,000+ property managers, surfaced in its ProData platform. The API documentation is public at developer.keydatadashboard.com; the keys are not self-serve.

Pick your route

Be honest with yourself about which one you are. Most ProData users should start with Route A this afternoon and only think about Route B if their org already pulls Key Data feeds into a warehouse.

What you can ask once Claude has your Key Data

  • "Our June occupancy was 71% against a market benchmark of 64%, but ADR trailed by $18. Walk me through what that combination usually means and what I should check next."
  • "Here is our pacing report and last year's. Where are we behind the market for the next 120 days, and which weeks look like genuine booking gaps rather than calendar shifts?"
  • "Turn this unit-level export into an owner update for the Hendersons: year-over-year trends, plain English, no jargon, two paragraphs."
  • "Which of our units sit in the bottom quartile of their comp set on RevPAR but the top half on occupancy? What does that pattern suggest about pricing?"
  • "Draft the talking points for Friday's revenue meeting from this snapshot export: three things going well, three risks, one decision we need to make."

The pattern: Key Data supplies the verified numbers, Claude supplies the interpretation and the writing. Neither is good at the other's job.

Before you start

  • A Key Data (ProData) account, the login is at app.keydatadashboard.com.
  • Claude: claude.ai in a browser or Claude Desktop for Route A; Claude Desktop or Claude Code for Route B.
  • For Route B only: Node.js 18+ and an API key and base URL issued by Key Data. If you do not already have these, ask your Key Data account contact; API delivery sits under their EnterpriseData product and there is no self-serve key page in the dashboard.
Route A

Exports into Claude

Key Data's own support docs describe exports in four formats: PDF for polished reports, Excel for analysis, CSV for system integrations, and PNG for individual visuals. Excel and CSV are the ones Claude can actually compute against, so prefer those for anything analytical.

1

Filter first, then export

Open the dashboard you want Claude to see, set your date range, comparison period, and property filters, then click Export in the header. Key Data's export captures exactly what is on screen, so the filtering you do here is the "query" Claude will be answering against. For a single chart or table, use the export icon on that report instead.

2

Upload to Claude and set the frame

Attach the Excel or CSV file in Claude and tell it what it is looking at. The one-time cost that makes every future question better: explain your portfolio's context once.

"This is a Key Data ProData snapshot export for our 180-unit portfolio in the Smokies, June 2026, with market benchmark columns. Occupancy here means paid occupancy from verified PMS reservation data, not scraped calendars. Read it and confirm what date range and comparison period you see before we start."
3

Make it repeatable with a Project

If you do this weekly, create a Claude Project called something like Revenue Reviews and put the framing in the project instructions: what your comp set is, how your seasons run, what your owners care about. Then each week is just: export, drop the file in, ask for the delta since last week. The narrative quality compounds because Claude keeps the context.

Honest limitation: this route is a snapshot, not a connection. Claude sees the export you gave it, as of the moment you exported it. For most benchmark-interpretation and owner-reporting work that is genuinely fine; revenue reviews run on a cadence anyway.
Route B

A read-only MCP server on the Key Data API

Key Data documents its REST API publicly at developer.keydatadashboard.com. Every request authenticates with an x-api-key header, and the property-manager endpoints cover exactly what a revenue team wants: properties, reservations, property-level KPIs, portfolio KPIs, and market KPIs. The docs use a {{url}} placeholder for the base URL because Key Data issues it along with your key.

1

Confirm your access

Ask your Key Data contact for your API key and base URL. A quick sanity check once you have them: the GET /api/v1/pm/session endpoint returns your tenant name and the upstream reservation data provider tied to the key, which confirms everything is wired to the right account before Claude ever touches it.

2

Scaffold the project

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

Write the server

Save this as index.js. Five read-only tools, matching the endpoints in Key Data's published docs. Note that most Key Data endpoints are POST requests with a JSON body even for reads, and the KPI endpoints require a timescale of Day, Week, or Month.

index.js
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Key Data issues both of these. The base URL is account-specific,
// which is why the public docs show it as a {{url}} variable.
const BASE_URL = process.env.KEYDATA_BASE_URL;
const API_KEY = process.env.KEYDATA_API_KEY;

if (!BASE_URL || !API_KEY) {
  console.error("Set KEYDATA_BASE_URL and KEYDATA_API_KEY first.");
  process.exit(1);
}

async function kd(method, path, body) {
  const res = await fetch(`${BASE_URL}${path}`, {
    method,
    headers: { "x-api-key": API_KEY, "Content-Type": "application/json" },
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) throw new Error(`Key Data ${res.status}: ${await res.text()}`);
  return res.json();
}

const server = new McpServer({ name: "keydata", version: "1.0.0" });
const text = (data) => ({ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] });

server.tool(
  "get-session",
  "Confirm which Key Data tenant this API key belongs to and its reservation data provider. Run this first.",
  {},
  async () => text(await kd("GET", "/api/v1/pm/session"))
);

server.tool(
  "list-properties",
  "List property records with pagination. Returns property IDs, bedrooms, types, and activity status. Use this to discover property IDs for KPI queries.",
  {
    page: z.number().optional().describe("Page number, default 1"),
    limit: z.number().optional().describe("Records per page"),
    is_active: z.boolean().optional().describe("Filter to active properties"),
  },
  async ({ page = 1, limit = 100, is_active }) =>
    text(await kd("POST", "/api/v1/pm/properties", { page, limit, is_active }))
);

server.tool(
  "portfolio-kpis",
  "Aggregated portfolio-level KPIs (occupancy, ADR, RevPAR, and more) as a time series, with comparison periods. The main tool for portfolio health questions.",
  {
    timescale: z.enum(["Day", "Week", "Month"]).describe("Aggregation granularity"),
    start: z.string().describe("Range start, YYYY-MM-DD"),
    end: z.string().describe("Range end, YYYY-MM-DD"),
  },
  async ({ timescale, start, end }) =>
    text(await kd("POST", "/api/v1/pm/properties/portfolio", {
      timescale,
      primary_range: { start, end },
    }))
);

server.tool(
  "property-kpis",
  "Property-level KPI metrics for comparing units inside the portfolio.",
  {
    timescale: z.enum(["Day", "Week", "Month"]),
    start: z.string().describe("Range start, YYYY-MM-DD"),
    end: z.string().describe("Range end, YYYY-MM-DD"),
  },
  async ({ timescale, start, end }) =>
    text(await kd("POST", "/api/v1/pm/properties/kpis", {
      timescale,
      primary_range: { start, end },
    }))
);

server.tool(
  "market-kpis",
  "Market-level KPI metrics for benchmarking the portfolio against its market, with optional comparison periods.",
  {
    timescale: z.enum(["Day", "Week", "Month"]),
    start: z.string().describe("Range start, YYYY-MM-DD"),
    end: z.string().describe("Range end, YYYY-MM-DD"),
  },
  async ({ timescale, start, end }) =>
    text(await kd("POST", "/api/v1/pm/market/kpis", {
      timescale,
      primary_range: { start, end },
    }))
);

await server.connect(new StdioServerTransport());
Field names may drift. This code follows the request shapes in Key Data's Postman documentation (x-api-key header, POST bodies, timescale values, primary_range date pairs). Your account's docs are the source of truth; if a request 400s, compare the body against the live example for that endpoint at developer.keydatadashboard.com. The docs also cover a reservations endpoint with guest and revenue detail; we left it out deliberately so Claude only sees performance data, not guest PII. Add it if you want it.
4

Connect it to Claude

Claude Desktop: add this to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then fully quit and reopen Claude.

claude_desktop_config.json
{
  "mcpServers": {
    "keydata": {
      "command": "node",
      "args": ["/absolute/path/to/keydata-mcp/index.js"],
      "env": {
        "KEYDATA_BASE_URL": "https://your-issued-base-url",
        "KEYDATA_API_KEY": "your_key_here"
      }
    }
  }
}

Claude Code users: claude mcp add keydata -e KEYDATA_BASE_URL=... -e KEYDATA_API_KEY=... -- node /absolute/path/to/keydata-mcp/index.js

Then try it:

"Run get-session to confirm which Key Data tenant you're connected to, then pull portfolio KPIs by month for this year and last year and tell me where our pacing diverges from the market."

Troubleshooting

I can't find an API key anywhere in my Key Data dashboard

That is expected. Unlike PriceLabs or OwnerRez, Key Data has no self-serve API key page. The documentation is public but keys and base URLs are issued by Key Data, and API delivery is positioned under its EnterpriseData product ("API Access, Flat Files, Cloud Delivery"). Talk to your account contact, or use Route A, which needs no key at all.

401 or 403 from the API

Check the header name is exactly x-api-key and that Content-Type: application/json is set; both appear as required headers on every endpoint in Key Data's docs. Then verify the base URL is the one Key Data issued you, not a guessed hostname.

400 on a KPI endpoint

The KPI endpoints require timescale ("Day", "Week", or "Month", capitalized) and a date range. Per the docs, range objects accept either a start/end pair or a preset commonseasontype like NEXT120DAYS, but not both. Call the /api/v1/pm/lookups endpoint to see the valid KPI types, timescales, and date range presets for your tenant.

Claude doesn't see the keydata tools

Claude Desktop only reads its config at startup: fully quit (Cmd+Q on macOS, quit from the tray on Windows) and reopen. If it still fails, the usual suspects are invalid JSON in the config, a relative path where an absolute one is needed, or node missing from PATH.

My Excel export is too big for one Claude message

Export a single report section instead of the whole dashboard (the per-report export icon), or tighten the date range before exporting. Filtered-first exports are also better analysis: Key Data's export captures exactly what is on screen, so a focused export is a focused question.


Quick FAQ

Does Key Data have an MCP server?

No. As of July 2026 there is no official Key Data MCP server and no community one we could find on GitHub or npm. The two routes above are the realistic options: exports into Claude (every account), or a self-built MCP server on the documented API (accounts with API access).

Does Key Data have an API?

Yes, and it is better documented than most in this industry. The public docs at developer.keydatadashboard.com cover property manager data (properties, reservations, calendars, property/portfolio/market KPIs), OTA listing data, and market benchmarking, all authenticated with an x-api-key header. What is not public is the key itself: access is arranged through Key Data, under the EnterpriseData umbrella of "API Access, Flat Files, Cloud Delivery."

Is Key Data the same thing as Key Data Dashboard? What is ProData?

Same company. Key Data now brands itself KeyData at keydata.co (keydatadashboard.com redirects there), and the property-manager product is called ProData, with named features including Snapshot Reports, Pacing Reports, Enhanced Benchmarking, Unit Reporting, Owner Reporting, Comp Sets, Rental Projections, and DemandIQ. DestinationData serves tourism organizations and EnterpriseData handles custom data and API delivery. You still log in at app.keydatadashboard.com.

Will Claude see guest personal data?

Only if you send it. Exports of benchmarking and KPI dashboards are aggregate performance data. On the API route, this guide's server deliberately excludes the reservations endpoint, which carries guest and revenue details; everything it does expose is portfolio and market metrics.

How is this different from pointing Claude at AirDNA-style market data?

The source. Key Data's core dataset is verified reservation data pulled directly from 80+ PMS integrations, in the company's words "sourced directly from operators, never scraped or modeled," supplemented with Airbnb and Vrbo listing supply data. Scrape-based tools model occupancy from public calendars. When you ask Claude to interpret a benchmark, it matters whether the benchmark is confirmed bookings or an estimate; we wrote up the methodology differences in AirDNA vs Key Data Dashboard.

The other half of the owner report. Key Data tells owners how the property earned; it can't tell them how the property is being cared for. RapidEye runs AI damage detection on the turnover photos your team already takes, so the condition side of your owner story is documented too. It also has an API, if you're the type who read Route B.

Sources

  1. Key Data API documentation (Postman)https://developer.keydatadashboard.com/
  2. KeyData: The most complete lodging dataset for performance analytics and forecastinghttps://www.keydata.co/
  3. ProData: Portfolio Performance & Benchmarkinghttps://www.keydata.co/products/prodata
  4. EnterpriseData: Custom Data & APIs Built for Scalehttps://www.keydata.co/products/enterprisedata
  5. Exporting Your Data (Key Data support)https://support.keydatadashboard.com/en/knowledge/exporting-your-data
  6. Model Context Protocol TypeScript SDKhttps://github.com/modelcontextprotocol/typescript-sdk

RapidEye is not affiliated with Key Data. Product names, endpoint shapes, and access details verified against Key Data's public website, support center, and API documentation in July 2026; confirm specifics against your own account before relying on them.

Other guides in this series

The full index is at Claude Guides for vacation rental operators.