Connect Chekin to Claude: Manage reservations and verify identities

If you need to connect Chekin to Claude to automate property management, identity verification, and police reporting workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Chekin's REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Chekin to ChatGPT or explore our broader architectural overview on connecting Chekin to AI Agents.

Giving a Large Language Model (LLM) read and write access to a specialized hospitality and compliance system like Chekin is an engineering challenge. You have to handle property-specific configurations, dynamic schema requirements for international guests, multi-step asynchronous identity verification, and strict rate limits. Every time Chekin updates an endpoint or deprecates a field, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Chekin, connect it natively to Claude, and execute complex workflows using natural language.

The Engineering Reality of the Chekin API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Chekin's API is painful. You are not just integrating a standard CRM - you are integrating a localized compliance engine that deals with international law, physical identity documents, and local police jurisdictions.

If you decide to build a custom MCP server for Chekin, you own the entire API lifecycle. Here are the specific challenges you will face when wrapping Chekin for an LLM:

Dynamic, Nationality-Dependent Schemas Unlike a standard SaaS product where a "User" object is static, Chekin's "Guest" object changes depending on the location of the housing and the nationality of the guest. A property in Spain requires different regulatory fields for a UK citizen than a property in Italy requires for a local citizen. If you expose static creation tools to Claude, the API will reject the payload for missing compliance fields. You must engineer a multi-step tool pattern where Claude first requests the dynamic schema for a specific reservation and nationality, interprets it, and then maps the subsequent creation payload accordingly.

Asynchronous Identity and OCR Workflows Identity verification is not a synchronous CRUD operation. Submitting an ID card for OCR analysis or a selfie for facial biometric comparison requires initiating an analysis job and polling for the result. LLMs are notoriously bad at handling asynchronous polling logic on their own. They tend to hallucinate success states or loop endlessly. Your integration layer must expose discrete tools for initiation and status checking, while explicitly instructing the model to await specific terminal states (READY, FAILED) before proceeding.

Strict API Quotas and Rate Limit Passthrough Chekin enforces strict API rate limits to protect its infrastructure, particularly around computationally expensive operations like OCR and face matching. If your AI agent gets stuck in a loop or attempts to bulk-process hundreds of historical reservations, Chekin will return a 429 Too Many Requests error. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Chekin API returns a 429, Truto passes that exact error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your LLM agent or MCP client is completely responsible for handling this error, reading the reset header, and implementing its own exponential backoff.

Instead of building all this boilerplate from scratch, Truto dynamically derives tools from Chekin's API schema, handles pagination cursors natively, and provides a zero-maintenance edge-routed endpoint that Claude can consume instantly.

sequenceDiagram
    participant Claude as Claude Desktop
    participant TrutoMCP as Truto MCP Server
    participant Chekin as Chekin API
    
    Claude->>TrutoMCP: Call tools/list
    TrutoMCP-->>Claude: Return Chekin schemas (JSON-RPC)
    Claude->>TrutoMCP: Call chekin_ocr_analyze_image(file)
    TrutoMCP->>Chekin: POST /v1/ocr/analyze
    Chekin-->>TrutoMCP: 201 Created (data_id)
    TrutoMCP-->>Claude: Return data_id for polling
    Claude->>TrutoMCP: Call chekin_ocr_get_analysis(data_id)
    TrutoMCP->>Chekin: GET /v1/ocr/analyze/{data_id}
    Chekin-->>TrutoMCP: 200 OK (MRZ Data)
    TrutoMCP-->>Claude: Return extracted traveler fields

How to Generate a Chekin MCP Server with Truto

Truto creates MCP servers that are scoped to a single integrated account (a specific tenant's Chekin instance). The server URL contains a secure cryptographic token that encodes the account routing, the allowed methods, and the optional expiration time. This means the URL itself is the only configuration required on the client side.

You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

This is the fastest method for internal operational teams who want to give their local Claude Desktop access to their Chekin account.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select the connected Chekin account you want to expose.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tool tags).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method 2: Via the Truto API

For platform engineers building multi-tenant AI agents, you can programmatically generate MCP servers for your end-users as soon as they connect their Chekin accounts.

Make an authenticated POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/<chekin_account_id>/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Chekin Agent Access",
    "config": {
      "methods": ["read", "write", "custom"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Truto validates that the integration has available AI tools and returns a secure, ready-to-use JSON-RPC 2.0 URL:

{
  "id": "mcp_srv_987654321",
  "name": "Chekin Agent Access",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0..."
}

How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude is a one-step process. You can configure it through the user interface or by editing Claude's underlying configuration file.

Method A: Via the Claude UI

If you are using Claude Desktop or Claude for Enterprise:

1. Open Claude and navigate to Settings.
2. Click on Integrations (or Connectors depending on your plan tier).
3. Click Add MCP Server or Add custom connector.
4. Paste the Truto MCP URL generated in the previous step.
5. Click Add. Claude will instantly perform a handshake, request the tool definitions, and make them available to your current context.

Method B: Via the Manual Configuration File

If you prefer to configure Claude Desktop manually (common for developers running local agents), you can edit the claude_desktop_config.json file. This file is typically located at:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the Truto MCP server using the standard Server-Sent Events (SSE) transport approach:

{
  "mcpServers": {
    "chekin_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0..."
      ]
    }
  }
}

Restart Claude Desktop. The application will initialize the connection, fetch the JSON Schemas for Chekin's endpoints, and expose them as callable functions to the model.

Hero Tools for Chekin

Truto automatically maps Chekin's API endpoints into flat, descriptive, snake_case tools that Claude can understand. Instead of building generic CRUD wrappers, Truto uses Chekin's OpenAPI definitions to inject context-aware parameter hints. Here are the most powerful tools available for Chekin.

list_all_chekin_reservations

This tool allows the agent to search for reservations by housing ID, check-in date, external ID, booking reference, or guest name. It handles Chekin's pagination cursors natively.

Contextual Usage: This is the entry point for almost all workflows. Agents use this to locate a booking before attempting to modify guests, check entry form statuses, or initiate police reports.

"Find the upcoming reservation for John Doe checking in tomorrow at the downtown apartment. I need the reservation ID and the current general status."

chekin_guests_get_schema

Before creating a guest, the agent must call this tool to fetch the dynamic guest schema template. The response dictates exactly which form fields (like document issue date or specific identity numbers) are strictly required based on the reservation's location and the guest's nationality.

Contextual Usage: Claude must be explicitly prompted to use this tool before creating a guest to avoid HTTP 400 validation errors from Chekin.

"Get the required guest schema for reservation 12345 for a guest with a UK passport. Tell me exactly what fields I must provide."

create_a_chekin_guest

Creates a new guest record attached to a specific reservation. It accepts standard demographic data alongside the required documentation fields discovered in the schema step.

Contextual Usage: Use this to automate data entry from email parsing, webhook payloads from OTAs (Online Travel Agencies), or internal CRM systems.

"Create a guest for reservation 12345. Her name is Sarah Connor, born 1985-05-12, nationality US, document type passport, document number A12345678. The issue date is 2020-01-01."

chekin_ocr_analyze_image

Submits an identity document image to Chekin's OCR service for Machine Readable Zone (MRZ) detection and analysis. It returns an asynchronous request ID (data_id).

Contextual Usage: Because this is an asynchronous job, Claude must pass the image and then follow up with the chekin_ocr_get_analysis tool to read the final extracted fields.

"Submit this passport image URL to the Chekin OCR analysis endpoint. Give me the resulting data ID so we can poll for the MRZ data."

chekin_identity_verification_compare_faces

Compares facial data extracted from an ID document with a guest's live selfie image. It returns a distance score and a boolean is_match flag indicating whether the identities correlate.

Contextual Usage: Critical for remote check-ins. If the match fails, the agent can be instructed to route the case to a human support queue for manual verification.

"Compare the facial data from identification picture ID 888 with the person picture selfie ID 999. Tell me if the match is successful or if human review is needed."

chekin_reservations_resend_police_check_in

Forces Chekin to resend the check-in report to local police authorities for a specific reservation.

Contextual Usage: Often required when a previous automated submission failed due to local government API outages (a common occurrence in regions like Spain and Italy), or when guest data had to be manually corrected post-arrival.

"The guest on reservation 12345 just updated their passport details. Force resend the police check-in report so we are legally compliant."

To view the complete inventory of available Chekin tools, including e-invoicing suppliers, statistical accounts, and webhook management, visit the Chekin integration page.

Workflows in Action

Integrating Chekin to Claude isn't just about exposing an API - it is about orchestrating complex compliance workflows autonomously. Here are two real-world scenarios showing how Claude navigates Chekin's architecture.

Scenario 1: The Remote Check-In Compliance Audit

Property managers who operate self-check-in models must ensure that guests are who they say they are before granting digital key access. An AI agent can act as the compliance auditor.

"Verify the identity for the primary guest on reservation 12345. First, submit their passport image for OCR, then compare their ID face with their uploaded selfie. If the face matches, force a police check-in resend. If it fails, escalate the ticket."

Step-by-step Execution:

1. Claude calls chekin_ocr_analyze_image with the provided document payload, receiving an asynchronous data ID.
2. Claude loops a wait state (if instructed via prompt) and calls chekin_ocr_get_analysis until the MRZ data is marked READY.
3. Claude calls chekin_identity_verification_compare_faces passing the ID picture reference and the selfie reference.
4. Claude evaluates the is_match boolean. Because it returns true, it proceeds to the final step.
5. Claude calls chekin_reservations_resend_police_check_in to submit the verified data to local authorities.

Outcome: The property manager gets an automated note that the guest is verified and legally registered, allowing the smart lock automation to trigger - zero human intervention required.

Scenario 2: Dynamic Guest Intake from OTA Emails

When a booking comes in from a platform that doesn't natively supply all regulatory fields, support teams waste hours chasing guests for details. Claude can automate this by cross-referencing requirements.

"Find the new booking for 'Liam Neeson' arriving next week. Check what specific identity fields are required for a UK citizen at that property. If we are missing data, draft an email asking him for the exact missing fields."

Step-by-step Execution:

1. Claude calls list_all_chekin_reservations using guest_name=Liam Neeson to retrieve the reservation ID and housing context.
2. Claude calls chekin_guests_get_schema passing the reservation ID and specifying the UK nationality.
3. Claude analyzes the returned JSON schema. It notes that document_issue_date and residence_country are strictly required, but are currently missing from the OTA payload.
4. Claude uses an external tool (like a Gmail MCP server) to draft a highly specific email asking Liam Neeson for exactly those two pieces of information.

Outcome: The guest receives a precise request for compliance data, and the agent avoids attempting to call create_a_chekin_guest with a payload that would result in a 400 Bad Request error.

Security and Access Control

Giving an LLM access to sensitive hospitality and compliance data requires strict access boundaries. Truto provides several layers of control when generating your Chekin MCP server:

• Method Filtering: You can restrict the MCP token to only allow read operations. This ensures Claude can search reservations and schemas, but cannot accidentally trigger police reports or create guest records.
• Tag Filtering: Limit the available tools to specific domains. For instance, you can configure the server to only expose tools tagged for identity_verification, blocking access to housing or einvoicing resources entirely.
• Additional Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By enabling this flag, the client must also pass a valid Truto API token in the Authorization header, adding a critical second layer of defense for enterprise deployments.
• Time-to-Live (expires_at): For temporary auditing or contracted workflows, you can set an exact ISO datetime. Truto automatically destroys the token and revokes access at the edge the moment this timestamp is reached.

Moving Faster with Managed Infrastructure

Building a custom integration for Chekin means constantly fighting with asynchronous OCR states, dynamic national schemas, and specialized API error codes. When you introduce an LLM into that mix, the complexity multiplies. Truto removes the infrastructure burden. By generating a managed MCP server, you instantly translate Chekin's compliance engine into clean, natural language tools.

Stop writing custom JSON schemas and OAuth refresh scripts for every new platform. Let Truto handle the integration layer so your engineering team can focus on building intelligent agent workflows.