---
title: "Connect Chekin to ChatGPT: Manage housings, rooms and police reports"
slug: connect-chekin-to-chatgpt-manage-housings-rooms-and-police-reports
date: 2026-07-16
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect ChatGPT to Chekin using a managed MCP server. Automate guest registration, OCR analysis, and police reports without custom integration code."
tldr: "Connect Chekin to ChatGPT via an MCP server to automate property management, guest identity verification, and police reporting workflows. This guide covers setup, tool definitions, and security."
canonical: https://truto.one/blog/connect-chekin-to-chatgpt-manage-housings-rooms-and-police-reports/
---

# Connect Chekin to ChatGPT: Manage housings, rooms and police reports


If your team uses Claude, check out our guide on [connecting Chekin to Claude](https://truto.one/blog/connect-chekin-to-claude-manage-reservations-and-verify-identities/) and [connecting Chekin to AI Agents](https://truto.one/blog/connect-chekin-to-ai-agents-automate-ocr-and-guest-entry-forms/).

Automating short-term rental compliance and guest registration is not a simple CRUD operation. Managing properties via Chekin means handling strict government reporting deadlines, asynchronous identity verification, and dynamic legal requirements based on a guest's nationality. Giving a Large Language Model (LLM) read and write access to your Chekin instance requires translating these complex constraints into predictable, [callable functions](https://truto.one/blog/what-is-llm-function-calling-for-integrations-2026-guide/).

You either spend weeks building, hosting, and maintaining a custom [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/), or you use a managed integration layer that handles the boilerplate for you. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Chekin, [connect it natively to ChatGPT](https://truto.one/blog/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex property management workflows using natural language.

## The Engineering Reality of the Chekin API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Chekin's API is challenging. Every time you expose these operations to an LLM, your infrastructure must account for domain-specific logic.

### Dynamic Guest Schemas Based on Nationality
You cannot hardcode a guest creation form. Depending on the location of the housing and the nationality of the guest, local police authorities require different data fields. An Italian citizen staying in Spain requires different identity document parameters than a US citizen. If your AI agent assumes a static JSON schema for guest creation, the API will reject the payload. Your MCP implementation must expose the `chekin_guests_get_schema` endpoint so the LLM can dynamically interrogate the required fields *before* attempting to create the guest record.

### Asynchronous OCR and Facial Recognition
Identity verification in Chekin is an asynchronous state machine. When you submit an ID document to Chekin's OCR service, you do not get the parsed data back immediately. Instead, you receive a request ID. Your system (or the LLM) must then poll the API to retrieve the parsed Machine Readable Zone (MRZ) data and validity flags. If your custom server does not handle this asynchronous delay, the LLM will hallucinate the result of the identity scan.

### Strict Police Reporting Endpoints
Sending guest data to local authorities is not a generic webhook. Chekin maintains specific, localized endpoints for police and statistical accounts. Triggering a resend of a police check-in requires calling specialized RPC-style endpoints like `chekin_reservations_resend_police_check_in`. If an LLM tries to update the guest record assuming that triggers a report, you will fall out of compliance.

### Factual Note on Rate Limits and 429 Errors
Chekin enforces rate limits on its API. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Chekin API returns an HTTP 429 (Too Many Requests), Truto passes that 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. The caller (in this case, your AI agent framework or ChatGPT's internal retry logic) is entirely responsible for implementing backoff and retry mechanisms.

## How to Generate a Managed MCP Server for Chekin

Instead of building your own proxy to handle Chekin's dynamic schemas and asynchronous jobs, you can use Truto to generate a secure MCP server URL. This server is derived dynamically from the integration's OpenAPI resources and documentation records.

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

### Method 1: Via the Truto UI

For teams who want to spin up an MCP server instantly without writing code, the Truto dashboard provides a point-and-click interface.

1. Log into Truto and navigate to your connected Chekin **Integrated Account** page.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can filter by methods (e.g., only `read` operations) or apply tags.
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

If you are provisioning AI workspaces programmatically for your own tenants, you can generate MCP servers via a single API call. This creates a secure token stored in KV infrastructure and returns a ready-to-use endpoint.

```typescript
// POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp

const response = await fetch(`https://api.truto.one/integrated-account/ab12-cd34-ef56/mcp`, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Chekin Compliance Agent",
    config: {
      methods: ["read", "write", "custom"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const data = await response.json();
console.log(data.url); 
// Returns: "https://api.truto.one/mcp/a1b2c3d4e5f6..."
```

This URL contains a cryptographically hashed token that securely scopes all incoming requests strictly to this specific Chekin tenant.

## How to Connect the Chekin MCP Server to ChatGPT

Once you have your MCP server URL, you need to register it with your LLM client. ChatGPT supports MCP natively via its Custom Connectors feature.

### Method A: Via the ChatGPT UI

1. Copy the MCP server URL you generated in the previous step.
2. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
3. Ensure **Developer mode** is toggled on.
4. Under **MCP servers / Custom connectors**, click add.
5. Name the connector (e.g., "Chekin Integration").
6. Paste your Truto MCP URL into the Server URL field and click **Save**.

ChatGPT will immediately connect, perform an initialization handshake, and discover all the Chekin tools you authorized.

### Method B: Via Manual Config File (SSE Transport)

If you are running a custom agent framework (like LangGraph or CrewAI) or prefer configuration files, you can connect using the Server-Sent Events (SSE) transport wrapper.

Create an `mcp.json` file in your project root:

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

Your MCP client will execute this command to establish a persistent JSON-RPC 2.0 connection with the Truto infrastructure.

## Chekin Hero Tools

Truto automatically generates precise JSON schemas for Chekin's API endpoints. Here are the highest-leverage operations your AI agent can now execute.

### list_all_chekin_housings
Retrieves the core property records. Housings dictate the physical location, registration flags, and identity verification settings that cascade down to rooms and reservations.

> "Fetch all housings in our Chekin account and tell me which ones currently have identity verification enabled."

### chekin_guests_get_schema
This is a critical custom tool. It fetches the dynamic form field definitions required for a specific reservation and guest nationality, ensuring the LLM knows exactly what data to collect.

> "Check the dynamic guest schema for reservation ID 88392 assuming the guest is from Germany. What exact ID fields does the local police require?"

### create_a_chekin_guest
Creates the actual guest record attached to a reservation. The schema required for this payload depends entirely on the output of the schema tool above.

> "Create a new guest record for reservation 88392. The guest's name is Klaus Müller, born 1985-04-12, nationality is DEU, and his passport number is D938472X."

### chekin_ocr_analyze_image
Submits an identity document image to Chekin's OCR service. This detects the Machine Readable Zone (MRZ) and begins the background job for identity extraction.

> "Submit this passport image file URL to the Chekin OCR analysis tool and give me the tracking ID so we can poll for the MRZ data."

### create_a_chekin_reservation
Creates a booking record that ties guests to housings and rooms. This defines the check-in and check-out dates and establishes the default leader for the group.

> "Create a reservation at housing ID 'H-102' for next weekend. The primary contact is Sarah Connor, arriving Friday and leaving Sunday."

### chekin_reservations_resend_police_check_in
A compliance-critical tool. Forces the API to re-transmit the check-in report to the local authorities if a previous transmission failed or was amended.

> "Force resend the police check-in report for reservation ID 44021. The guest updated their passport details this morning and we need to push the new data to the authorities."

> Explore the full inventory of Chekin MCP tools, including statistical accounts, e-invoicing suppliers, and webhook subscriptions in the Truto integration directory.
>
> [View all Chekin tools](https://truto.one/integrations/detail/chekin)

## Workflows in Action

When you give an AI agent access to these tools, it can chain them together to automate multi-step compliance operations.

### Scenario 1: Automated OCR and Guest Registration

If a property manager receives a guest's passport scan via email, the AI agent can fully automate the data extraction and registration process.

> "I just got a passport scan for the upcoming booking at the Riverside property. Please submit it for OCR, wait for the result, and create the guest record for that reservation."

**Tool Execution Sequence:**
1. **`list_all_chekin_housings`**: The agent searches for "Riverside" to find the correct `housing_id`.
2. **`list_all_chekin_reservations`**: The agent queries upcoming reservations for that `housing_id` to get the target `reservation_id`.
3. **`chekin_ocr_analyze_image`**: Submits the passport scan to the OCR engine and receives a `data_id`.
4. **`chekin_ocr_get_analysis`**: Polls the status using the `data_id` until the extracted MRZ data (name, document number, birth date) is ready.
5. **`create_a_chekin_guest`**: Uses the extracted OCR data to create the official guest record attached to the reservation.

```mermaid
sequenceDiagram
    participant AI as ChatGPT
    participant Truto as Truto MCP
    participant Chekin as Chekin API

    AI->>Truto: Call list_all_chekin_housings
    Truto->>Chekin: GET /housings
    Chekin-->>Truto: Return housing list
    Truto-->>AI: Return housing list
    
    AI->>Truto: Call chekin_ocr_analyze_image
    Truto->>Chekin: POST /ocr/analyze
    Chekin-->>Truto: Return data_id
    Truto-->>AI: Return data_id
    
    AI->>Truto: Call chekin_ocr_get_analysis(data_id)
    Truto->>Chekin: GET /ocr/analysis/{data_id}
    Chekin-->>Truto: Return MRZ parsed data
    Truto-->>AI: Return MRZ parsed data
    
    AI->>Truto: Call create_a_chekin_guest
    Truto->>Chekin: POST /guests
    Chekin-->>Truto: 201 Created
    Truto-->>AI: Guest successfully registered
```

### Scenario 2: Rectifying Police Compliance Failures

If a property manager gets an alert that a local authority rejected a check-in report because of missing data, the agent can resolve the issue conversationally.

> "The police integration for reservation 99382 failed because the guest's residence country was empty. Update the guest record to show they reside in France (FRA), then force resend the police check-in report."

**Tool Execution Sequence:**
1. **`get_single_chekin_reservation_by_id`**: The agent retrieves the reservation to find the associated `guest_id`.
2. **`update_a_chekin_guest_by_id`**: The agent updates the specific guest record, setting `residence_country` to `FRA`.
3. **`chekin_reservations_resend_police_check_in`**: The agent calls the specific compliance endpoint, triggering Chekin to re-transmit the corrected payload to the authorities.

The user receives a confirmation that the data was patched and the compliance payload was successfully pushed out - a process that would normally require clicking through multiple settings panels in the UI.

## Security and Access Control

Handing an LLM the ability to read passports and submit legal police reports requires strict access boundaries. Truto provides several mechanisms to lock down your MCP servers:

*   **Method Filtering:** By defining `config.methods: ["read"]`, you can create a read-only server. The LLM can view housings and reservation statuses, but the `create_a_chekin_guest` and `chekin_reservations_resend_police_check_in` tools will be stripped from the server entirely.
*   **Tag Filtering:** You can restrict the server to specific functional domains. Passing `tags: ["compliance"]` ensures the LLM only has access to police and statistical account tools, ignoring standard CRM functionality.
*   **Dual Authentication (`require_api_token_auth`):** By default, possessing the MCP URL is enough to connect. Enabling this flag forces the client to also pass a valid Truto API token in the Authorization header, preventing unauthorized access if the URL is leaked in a log file.
*   **Time-to-Live (`expires_at`):** You can generate ephemeral MCP servers for temporary agent workflows. Once the ISO timestamp is reached, the underlying infrastructure automatically purges the token and severs access.

## Ship Chekin Workflows Without Custom Code

Connecting ChatGPT to Chekin shouldn't require your engineering team to build custom pagination logic, handle asynchronous OCR loops, or write hundreds of lines of JSON schema mapping for identity endpoints. By leveraging a managed MCP infrastructure, you abstract away the API layer entirely.

Your AI agents get instant, native access to property management and compliance workflows. Your engineering team avoids managing OAuth tokens, and you get to market faster.

> Want to give your AI agents secure access to Chekin and 100+ other SaaS APIs? Book a technical deep dive with our engineering team today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)