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, look up event availability, and sync client check-ins natively. If your team uses Claude, check out our guide on connecting Jrni to Claude or our broader architectural overview on connecting Jrni to AI Agents. Here is exactly how to do it using a Model Context Protocol (MCP) server.

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, 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 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, implementing it against the Jrni API 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.

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):

{
  "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.

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.

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.