Connect Jrni to Claude: Sync Schedules, Resources, and Services

If your team uses ChatGPT, check out our guide on connecting Jrni to ChatGPT or explore our broader architectural overview on connecting Jrni to AI Agents.

Enterprise scheduling is fundamentally a multi-dimensional constraint problem. When a customer tries to book an appointment, the system must simultaneously evaluate staff availability, room or resource capacity, service durations, and operating hours. Jrni handles this complexity at scale for major banks, retailers, and government agencies. Giving a Large Language Model (LLM) like Claude the ability to read and write to this ecosystem unlocks massive operational leverage - turning a conversational interface into a highly capable concierge and dispatch system.

However, building this integration from scratch requires translating Claude's tool-calling outputs into Jrni's complex REST APIs. You have to write massive JSON schemas for Claude to understand, manage OAuth tokens, and deal with complex pagination logic.

This guide breaks down exactly how to use Truto to generate a secure, managed Model Context Protocol (MCP) server for Jrni, connect it natively to Claude, 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. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Jrni's API reveals several unique engineering challenges.

Multi-Dimensional Availability Queries Finding an open slot in Jrni is not as simple as querying a single calendar endpoint. Availability is contingent on the intersection of a company_id, service_id, person_id (staff), and resource_id (room or equipment). Passing these requirements to an LLM requires strict schema definitions, or the model will hallucinate available times. Truto maps these constraints into explicit query schemas, guiding Claude to fetch availability sequentially.

Dynamic Edit and Create Schemas Unlike standard APIs that use a static data model, Jrni frequently uses dynamic schemas based on company-specific configurations. For example, to create or edit a client, you often need to fetch the jrni_admin_clients_get_edit_schema first to understand the required payload structure. This dynamic metadata is incredibly difficult to hardcode into a custom MCP server. Truto exposes these schema-fetching endpoints as distinct MCP tools, allowing Claude to dynamically inspect the data requirements before attempting a write operation.

HAL-Style Embedded Resources Jrni's API makes heavy use of HAL-like _embedded objects to reduce round trips. A single booking response might contain embedded client, service, and person details. If you expose raw API responses to Claude, the model can struggle to parse these deeply nested structures efficiently. Truto's MCP tools provide clean JSON schemas that help Claude map and traverse these embedded relationships accurately.

Strict Rate Limits and Backoff When you build an AI agent that loops through dozens of event schedules, you will inevitably hit rate limits. Jrni enforces these to protect backend stability. Truto does not retry, throttle, or apply backoff on rate limit errors. When the Jrni API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to Claude. Truto normalizes the upstream rate limit information into standard headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your AI agent must read these headers and implement its own retry and backoff logic.

Generating the Jrni MCP Server

Instead of building a proxy layer from scratch, Truto dynamically generates an MCP server directly from your connected Jrni account. You can do this via the Truto UI or the API.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the integrated account page for your Jrni connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (set a name, select allowed methods like read or write, and apply any necessary tags).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For platform engineers building automated provisioning flows, you can generate the MCP server programmatically. Send a POST request to the /integrated-account/:id/mcp endpoint.

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

The Truto API will validate the configuration, generate a cryptographically secure token, and return the server URL.

{
  "id": "mcp-789-xyz",
  "name": "Jrni Concierge Agent",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you must connect it to Claude. The token in the URL handles authentication automatically - Claude does not need separate Jrni credentials.

Via the Claude UI (or ChatGPT)

If you are using Claude's web interface or ChatGPT's developer mode:

1. Open Settings -> Integrations (or Connectors / Apps).
2. Select Add MCP Server or Add custom connector.
3. Name the connector (e.g., "Jrni Booking System").
4. Paste the Truto MCP server URL and save.

Via Claude Desktop Config File

If you are running Claude Desktop locally and want to configure the server via file, you can edit your claude_desktop_config.json. Truto uses the SSE (Server-Sent Events) transport for remote MCP servers.

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

Restart Claude Desktop. The application will handshake with Truto, fetch the Jrni API schemas, and populate Claude's context with the available tools.

Hero Tools for Jrni

Truto automatically generates highly descriptive, snake_case tools from Jrni's API endpoints. Here are the highest-leverage tools available for orchestrating scheduling and event management.

list_all_jrni_times

This is the core availability engine. It lists available booking start times for a particular day, including the durations and prices for each start time. It requires company_id, service_id, and start_date.

"I need to find all available time slots for the 'Initial Consultation' service at the Downtown clinic (Company ID: 4455) for tomorrow. Please fetch the times and let me know the shortest available duration."

create_a_jrni_booking

Creates a single booking for a service or an event appointment. This handles the actual transactional write to reserve the time slot.

"Book a 30-minute slot for tomorrow at 2:00 PM for the Initial Consultation service. Assign it to client ID 99281 at Company 4455. Confirm the booking ID once it is successfully created."

jrni_admin_bookings_search

Allows the model to search through massive booking datasets using an Elasticsearch Query DSL payload. This is critical for finding specific historical appointments or generating reports without paginating through thousands of records.

"Search the admin bookings using the Elasticsearch DSL to find all cancelled appointments from last week for Company 4455. Summarize the cancellation reasons."

list_all_jrni_events

Lists bookable events for a company, with optional filtering by date, event group, resource, or person. Use this for class, workshop, or seminar management.

"List all events scheduled for the 'Yoga Workshop' group next month at Company 4455. Tell me how many spaces are currently booked versus the total capacity for each event."

update_a_jrni_check_in_by_id

Marks a guest as checked in for a specific appointment or event using their check-in code. This is perfect for building kiosk or front-desk AI assistants.

"A guest just arrived with the check-in ID 'CHK-90210'. Please mark them as checked in for their event and confirm their attendance status."

jrni_admin_clients_get_edit_schema

Retrieves the dynamic JSON schema required for editing a specific Jrni client. Because Jrni allows custom fields per company, the AI must fetch this schema to understand the exact shape of the payload required for updates.

"I need to update the contact details for client ID 99281. First, fetch the edit schema for this client to ensure we format the update payload correctly, then update their phone number to 555-0199."

For the complete inventory of available tools, including detailed query and body schemas, visit the Jrni integration page.

Workflows in Action

By chaining these MCP tools together, Claude can execute complex, multi-step business logic autonomously.

Scenario 1: End-to-End Concierge Booking

An internal support agent uses Claude to find an open slot and book a customer into an available service.

"A new customer, Sarah Jenkins (sarah@example.com), wants to book a standard support session next Tuesday at our main branch (Company ID 102). Find an open 30-minute slot in the afternoon, create a client profile for her, and book the appointment."

1. Claude calls list_all_jrni_services with the company ID to find the ID for "standard support session".
2. Claude calls list_all_jrni_times using the service ID and next Tuesday's date to find an afternoon slot.
3. Claude calls create_a_jrni_admin_client to register Sarah Jenkins and retrieves her new client ID.
4. Claude calls create_a_jrni_booking using the client ID, service ID, and datetime to finalize the reservation.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Jrni as Jrni API
    
    User->>Claude: "Book Sarah for next Tuesday..."
    Claude->>Truto: Call list_all_jrni_services
    Truto->>Jrni: GET /api/v1/companies/102/services
    Jrni-->>Truto: Return service list
    Truto-->>Claude: Return service ID
    
    Claude->>Truto: Call list_all_jrni_times
    Truto->>Jrni: GET /api/v1/companies/102/times?date=...
    Jrni-->>Truto: Return available slots
    Truto-->>Claude: Return 2:00 PM slot
    
    Claude->>Truto: Call create_a_jrni_admin_client
    Truto->>Jrni: POST /api/admin/v1/companies/102/clients
    Jrni-->>Truto: Return Client ID
    Truto-->>Claude: Return Client ID
    
    Claude->>Truto: Call create_a_jrni_booking
    Truto->>Jrni: POST /api/admin/v1/companies/102/bookings
    Jrni-->>Truto: Return Booking Confirmation
    Truto-->>Claude: Return Success
    Claude-->>User: "Sarah is booked for 2:00 PM."

Scenario 2: Dynamic VIP Event Check-In

A front-desk assistant needs to handle a VIP arrival and ensure the system reflects their attendance.

"Our keynote speaker, John Doe, just arrived at the venue (Company ID 102). Find today's 'Annual Tech Keynote' event, locate his attendee record, and check him in immediately."

1. Claude calls list_all_jrni_events filtering for today's date to find the 'Annual Tech Keynote' event ID.
2. Claude calls get_single_jrni_event_detail_by_id to inspect the _embedded attendees and locates John Doe's check-in code.
3. Claude calls update_a_jrni_check_in_by_id passing the check-in code to register his attendance in the system.

Scenario 3: Auditing and Modifying Staff Schedules

A manager needs to block out time for a staff member who called in sick.

"Dr. Smith called in sick today for the Downtown Clinic (Company 102). Find his staff profile and block out his schedule from 9 AM to 5 PM today."

1. Claude calls jrni_admin_people_search with the query "Dr. Smith" to retrieve his person_id.
2. Claude calls jrni_admin_people_create_block passing the company_id, person_id, and the start/end times to block his availability, ensuring no new bookings can be made.

Security and Access Control

Giving an LLM access to your enterprise scheduling system requires strict guardrails. Truto MCP servers include built-in access controls mapped directly to the server URL:

• Method Filtering: Restrict an MCP server to read-only operations by passing "methods": ["read"] during creation. This allows Claude to view schedules and availability without the risk of creating or canceling bookings.
• Tag Filtering: Group specific tools using tags. For example, you can limit a server to only expose "events" tags, preventing the LLM from accessing billing or administrative client records.
• Authentication Requirements: Enable require_api_token_auth to force the MCP client to provide a valid Truto API token in the headers. This ensures that even if the MCP URL is leaked, unauthorized users cannot execute tools.
• Time-to-Live (TTL): Set an expires_at timestamp for temporary access. Truto automatically deprovisions the server and revokes access when the expiration time is reached, perfect for temporary audits or automated testing.

Building a reliable integration between an LLM and an enterprise scheduling system like Jrni is an exercise in managing state, schemas, and rate limits. By utilizing a managed MCP layer like Truto, you offload the boilerplate of documentation parsing, tool generation, and OAuth management. This allows your engineering team to focus on designing agentic workflows and prompt engineering, rather than maintaining proxy APIs and monitoring token lifecycles.