---
title: "Connect Jrni to ChatGPT: Manage Bookings, Events, and Clients"
slug: connect-jrni-to-chatgpt-manage-bookings-events-and-clients
date: 2026-08-01
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect Jrni to ChatGPT using a managed MCP server. Execute complex enterprise scheduling workflows, manage bookings, and sync client check-ins."
tldr: "Connect Jrni to ChatGPT using Truto's managed MCP server. This guide shows how to handle Jrni's complex location hierarchy, Elasticsearch payloads, and availability logic via natural language AI tools."
canonical: https://truto.one/blog/connect-jrni-to-chatgpt-manage-bookings-events-and-clients/
---

# Connect Jrni to ChatGPT: Manage Bookings, Events, and Clients


You want to connect Jrni to ChatGPT so your AI agents can [manage enterprise appointment scheduling](https://truto.one/blog/connect-jrni-to-ai-agents-automate-check-ins-and-event-logistics/), look up event availability, and sync client check-ins natively. If your team uses Claude, check out our guide on [connecting Jrni to Claude](https://truto.one/blog/connect-jrni-to-claude-sync-schedules-resources-and-services/) or our broader architectural overview on [connecting Jrni to AI Agents](https://truto.one/blog/connect-jrni-to-ai-agents-automate-check-ins-and-event-logistics/). Here is exactly how to do it using a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/).

Giving a Large Language Model (LLM) read and write access to an enterprise scheduling platform like Jrni is an engineering challenge. You either spend weeks [building, hosting, and maintaining a custom MCP server](https://truto.one/blog/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or you use a managed infrastructure layer that handles the boilerplate for you. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Jrni, connect it natively to ChatGPT, and execute complex scheduling workflows using natural language.

## The Engineering Reality of the Jrni API

A [custom MCP server](https://truto.one/blog/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) is a self-hosted integration layer that translates an [LLM's tool calls](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/) into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, [implementing it against the Jrni API](https://truto.one/blog/connect-jrni-to-ai-agents-automate-check-ins-and-event-logistics/) is uniquely painful. 

If you decide to build a custom MCP server for Jrni, you own the entire integration lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Jrni:

### The Strict Location Hierarchy
Every resource in Jrni is scoped to a specific company ID. Because Jrni is built for enterprise retail, banking, and government, it heavily utilizes parent and child companies to represent different branches or store locations. You cannot simply fetch "all bookings" globally across an organization. Your AI agent must first query the parent company, list the child companies, extract the specific `company_id` for the target location, and inject that ID into every subsequent API call. If your MCP server doesn't map this hierarchy properly, the LLM will fail to route bookings to the correct physical location.

### Elasticsearch Query DSL in REST Payloads
Most REST APIs use simple query parameters for searching records. Jrni's advanced administrative search endpoints - such as `/admin/bookings/search` - expect a raw Elasticsearch Query DSL payload in the request body. Teaching an LLM to generate complex, deeply nested Elasticsearch JSON syntax without hallucinating schema errors is brutally difficult. Your custom server must provide extensive schema validation and error correction before passing these payloads upstream.

### The Multi-Step Availability Calculus
Booking an appointment in Jrni is never a single API call. You cannot just pass a date and time to a creation endpoint. First, the agent must fetch the service ID. Second, it must query for available dates within a range. Third, it must query the available times for a specific date. The response from the times endpoint is highly nested, returning `durations`, `prices`, and `listed_durations` arrays under each start time. The LLM has to parse this matrix to understand if a slot is actually bookable for a 60-minute service versus a 30-minute service before it can safely execute a booking creation call.

### Rate Limits and Normalization
Jrni enforces strict API quotas to protect their scheduling engine. When you exceed these limits, the API rejects the request with an HTTP 429 status code. Truto passes these 429 errors directly back to the caller, normalizing the upstream rate limit data into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). Truto does not magically absorb or retry these requests - your MCP client is responsible for implementing the exponential backoff logic based on these standardized headers.

## Creating the Jrni MCP Server

Instead of hand-coding endpoint schemas and OAuth flows, Truto dynamically derives your MCP tools directly from the integration's resource definitions and documentation records. A tool only appears in the MCP server if it has a corresponding documentation entry - this acts as a strict quality gate, ensuring only well-documented, AI-ready endpoints are exposed to ChatGPT.

Each server is fully self-contained, requiring zero client-side configuration beyond the URL.

### Method 1: Via the Truto UI

1. Navigate to the **Integrated Accounts** tab in your Truto dashboard and select your connected Jrni account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server name, allowed methods (e.g., `read`, `write`), and an optional expiration date.
5. Click **Create** and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

You can dynamically provision an MCP server programmatically. This is ideal for multi-tenant applications where you need to spin up temporary AI access for specific clients.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Jrni Booking Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API returns a secure, hashed token URL. The random hex string is hashed via HMAC before storage, meaning the raw token is only visible once in this response.

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes less than a minute. 

### Method A: Via the ChatGPT UI

If you are using ChatGPT Enterprise, Business, Pro, or Plus, you can connect the server natively:

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** on.
3. Under **MCP servers / Custom connectors**, click **Add new server**.
4. Enter a name (e.g., "Jrni Scheduler").
5. Paste the Truto MCP URL into the **Server URL** field and click **Save**.

ChatGPT will immediately perform a handshake with the server, mapping the available Jrni tools into its context window.

### Method B: Via Manual Config File (For Self-Hosted Agents)

If you are running a custom headless agent using LangChain, LangGraph, or the OpenAI SDK, you can consume the Truto MCP endpoint using the official Server-Sent Events (SSE) transport wrapper.

Add the following configuration to your agent's MCP setup file (e.g., `mcp_config.json`):

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

## Hero Tools for Jrni

Truto automatically generates tools for the complete Jrni API surface, but these core endpoints are the highest-leverage operations for AI-driven scheduling.

### 1. Search Admin Bookings
**Tool name:** `jrni_admin_bookings_search`

Searches across all bookings using an Elasticsearch Query DSL payload. This allows the AI to execute complex filtering, such as finding all cancelled appointments for a specific service in the last 30 days.

> "Find all appointments booked by sarah.connor@example.com across all branches for the upcoming week."

### 2. List All Booking Times
**Tool name:** `list_all_jrni_times`

Fetches available booking start times for a particular day, returning durations and prices for each start time. The LLM uses this to check real-time availability before presenting options to a user.

> "Check the schedule for tomorrow at the Downtown clinic and list the available morning slots for a 60-minute consultation."

### 3. Create an Admin Booking
**Tool name:** `create_a_jrni_admin_booking`

Creates a new booking for a service or event appointment. This handles the actual reservation writing logic, linking the client, the service, and the location.

> "Book the 10:00 AM slot tomorrow for a financial planning session. The client ID is 89432."

### 4. Create an Admin Client
**Tool name:** `create_a_jrni_admin_client`

Creates a new client record in the Jrni database. You must typically execute this tool before booking a net-new customer, as bookings require a valid client ID.

> "Add Michael Scott to the system as a new client with the email mscott@dundermifflin.com and the phone number 555-0199."

### 5. Update a Check-in by ID
**Tool name:** `update_a_jrni_check_in_by_id`

Marks a guest as checked in for a specific appointment or event code. Perfect for front-desk kiosk automation or automated SMS check-in workflows.

> "Mark the guest with check-in code 445-X as checked in for the morning seminar."

### 6. Create a Person Block
**Tool name:** `jrni_admin_people_create_block`

Blocks out a time slot for a bookable staff member. This is critical for preventing double-booking when staff have sudden unavailability or internal meetings.

> "Block out Dr. Smith's calendar this Friday from 1:00 PM to 3:00 PM for an administrative meeting."

To view the complete inventory of available endpoints and schema definitions, visit the [Jrni integration page](https://truto.one/integrations/detail/jrni).

## Workflows in Action

Here is how ChatGPT orchestrates these tools to execute complex scheduling logic entirely autonomously.

### Workflow 1: The Client Onboarding and Booking Flow

When a new user wants to book an appointment, the AI agent must handle identity creation, availability lookup, and final booking confirmation without human intervention.

> "I need to book a 30-minute tax consultation with an advisor tomorrow morning. My name is Alex Chen, my email is alex@example.com."

1. **`create_a_jrni_admin_client`**: The agent creates Alex's profile and extracts the new `client_id` from the response.
2. **`list_all_jrni_admin_services`**: The agent finds the specific `service_id` for a "tax consultation".
3. **`list_all_jrni_times`**: The agent queries tomorrow's date with the `service_id` and the default `company_id` to retrieve available slots.
4. **`create_a_jrni_admin_booking`**: The agent books the chosen slot, passing the `client_id` and `service_id`, and returns the confirmation number to the user.

```mermaid
sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant Jrni as Jrni API

    User->>ChatGPT: "Book a tax consultation for tomorrow morning..."
    ChatGPT->>Truto: Call create_a_jrni_admin_client
    Truto->>Jrni: POST /api/v1/admin/123/clients
    Jrni-->>Truto: Return client_id: 8842
    Truto-->>ChatGPT: Return client schema
    ChatGPT->>Truto: Call list_all_jrni_times
    Truto->>Jrni: GET /api/v1/123/times?date=tomorrow
    Jrni-->>Truto: Return nested time slots
    Truto-->>ChatGPT: Return availability array
    ChatGPT->>Truto: Call create_a_jrni_admin_booking
    Truto->>Jrni: POST /api/v1/admin/123/bookings
    Jrni-->>Truto: Return booking confirmation
    Truto-->>ChatGPT: Return booking details
    ChatGPT-->>User: "You are confirmed for 9:00 AM tomorrow."
```

### Workflow 2: The Event Triage and Check-in Flow

Event staff often need to manage attendance on the fly. An AI agent can handle complex lookups and status updates seamlessly.

> "Find the booking for Sarah Jenkins for today's leadership workshop and check her in."

1. **`jrni_admin_bookings_search`**: The agent constructs an Elasticsearch Query DSL payload targeting today's date and the string "Sarah Jenkins", fetching the booking record and extracting the check-in code.
2. **`update_a_jrni_check_in_by_id`**: The agent fires a request to the check-in endpoint using the extracted code.
3. **Formatting**: ChatGPT informs the staff member that the attendee status has been updated to checked-in.

## Security and Access Control

Exposing an enterprise scheduling system to an AI model requires strict governance. Truto MCP servers enforce boundaries at the infrastructure level:

* **Method Filtering**: You can restrict an MCP token to only allow read operations (`methods: ["read"]`). This prevents the LLM from accidentally deleting clients or creating bogus bookings while researching availability.
* **Tag Filtering**: If your Jrni integration uses `config.tool_tags`, you can scope the server to specific domains (e.g., `tags: ["events"]`), hiding standard appointments or staff administration endpoints from the LLM.
* **Time-to-Live (TTL)**: Provision temporary access using the `expires_at` property. The server and its underlying KV storage records are automatically purged when the TTL expires.
* **Enforced Identity Authentication**: Enabling `require_api_token_auth: true` ensures that possessing the MCP URL is not enough. The caller must also pass a valid Truto API token in the `Authorization` header, binding the tool execution to an authenticated user session.

## Moving Fast with Managed Infrastructure

Building an AI agent that can reliably parse Elasticsearch DSL queries, handle highly nested availability matrices, and map branch locations in Jrni is a massive undertaking. Hand-coding these schemas, managing the OAuth lifecycle, and dealing with pagination logic is a distraction from building your core product.

By leveraging Truto's dynamic, documentation-driven MCP generation, you can give ChatGPT deep, governed access to the Jrni API in minutes, rather than months.

> Stop wasting engineering cycles on custom MCP server infrastructure. Let Truto handle the integration layer so you can focus on building autonomous scheduling agents.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)