Connect Arketa to Claude: Manage Reservations, Check-ins, and Sales

If your team needs to connect Arketa to Claude to automate studio management, handle class scheduling, or manage customer check-ins, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Arketa's underlying REST APIs. You can either build and maintain this custom 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 Arketa to ChatGPT or explore our broader architectural overview on connecting Arketa to AI Agents.

Giving a Large Language Model (LLM) read and write access to a fitness and wellness management platform like Arketa is a significant engineering challenge. You have to handle API token lifecycles, map complex JSON schemas to MCP tool definitions, and deal with Arketa's specific business logic constraints. Every time Arketa updates an endpoint or changes a data model, you have to update your server code, redeploy, and thoroughly test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Arketa, connect it natively to Claude Desktop, and execute complex studio workflows using natural language.

The Engineering Reality of the Arketa 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 specialized B2B APIs is painful. Arketa is built to manage complex studio operations, recurring memberships, physical class capacities, and financial transactions. Its API reflects that complexity.

If you decide to build a custom Arketa MCP server, here are the specific integration challenges you will face:

Complex Pagination Mechanisms Arketa handles large datasets (like thousands of client profiles or historical purchases) using a specific cursor-based pagination scheme relying on start_after string values. Large Language Models often struggle with state management across conversational turns. If you do not explicitly instruct the LLM how to handle these pagination tokens, it will attempt to mutate the cursor, guess the next page integer, or drop the cursor entirely. A managed MCP server dynamically injects strict prompt instructions into the query schema, forcing the LLM to pass the next_cursor value back completely unchanged.

Bifurcated Booking Logic The endpoint for creating reservations (create_a_arketa_reservation) does not use a single flat payload. It requires branching logic depending on the user state. If you are booking an existing client, the payload requires a clientId and an active purchaseId. If you are booking a brand-new walk-in client, the payload completely changes, requiring a firstName, lastName, and email, while making the purchaseId optional. An LLM must be fed an exact JSON schema that correctly models these union types, otherwise it will hallucinate invalid combinations of fields and fail the API request.

High-Stakes Destructive Actions In Arketa, a cancellation is not just a status update. The update_a_arketa_reservation_by_id endpoint triggers financial and operational side effects. The isLateCancel boolean determines whether the studio deducts a credit from the customer's class pack. The issueRefund boolean interacts with the payment gateway to return real money. Exposing these tools to an LLM without strict method filtering or explicit parameter descriptions risks automated agents accidentally refunding thousands of dollars or penalizing clients incorrectly.

Creating the Arketa MCP Server

Truto abstracts away the complexity of the Arketa API by dynamically generating MCP tools based on integration documentation and schemas. The tool generation is documentation-driven - if an endpoint lacks a descriptive schema, it is omitted, ensuring Claude only sees highly curated, functioning tools.

To connect Claude to your Arketa account, you first need to generate the MCP server URL. You can do this via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are an IT admin or operations manager setting this up manually, the UI is the fastest path:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Arketa account.
3. Click on the MCP Servers tab.
4. Click Create MCP Server.
5. Configure your server by giving it a name, selecting allowed methods (e.g., read-only vs read-write), and setting an optional expiration date.
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For engineering teams embedding AI capabilities into internal tools, you can generate the MCP server programmatically. Make an authenticated POST request to the /integrated-account/:id/mcp endpoint.

curl -X POST https://api.truto.one/integrated-account/<arketa_account_id>/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Arketa Front Desk Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["reservations", "classes"]
    }
  }'

Truto validates that the Arketa integration has AI-ready tools, hashes the generated token securely in a distributed key-value store, and returns the endpoint payload:

{
  "id": "mcp-server-8f7d9a2",
  "name": "Arketa Front Desk Agent",
  "config": {
    "methods": ["read", "write"],
    "tags": ["reservations", "classes"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have the url from the previous step, you must configure Claude to route tool calls to it. The server URL contains a cryptographic token that fully authenticates requests against your specific Arketa instance.

Method A: Via the Claude UI

If you are using Claude for enterprise or team plans with custom connector support:

1. Open Claude and navigate to Settings.
2. Navigate to Integrations or Connectors (depending on your plan tier).
3. Click Add MCP Server or Add custom connector.
4. Paste the Truto MCP server URL and save. Claude will immediately ping the endpoint, execute the JSON-RPC initialization handshake, and load the available Arketa tools.

Method B: Via the Claude Desktop Config File

For developers running Claude Desktop locally, you can map the remote MCP server using Server-Sent Events (SSE) via a JSON configuration file.

Open your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add the following configuration:

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

Restart Claude Desktop. The application will use the server-sse wrapper to seamlessly translate Claude's local MCP protocol requests into HTTP POST requests directed at your Truto MCP endpoint.

Arketa Hero Tools for AI Agents

Truto exposes a comprehensive suite of Arketa resources, but for studio operations, a few high-leverage tools stand out. By flattening Arketa's query and body parameters into an MCP-compliant JSON schema, Claude knows exactly which fields are required.

list_all_arketa_classes

This tool retrieves a paginated list of partner classes on the schedule. It includes class metadata, instructor details, and timing.

"What yoga classes do we have scheduled for tomorrow afternoon, and who is teaching them?"

list_all_arketa_clients

This tool functions as a CRM lookup, allowing the agent to retrieve a paginated list of clients with optional filtering. It is essential for checking client status before booking a reservation.

"Look up the client profile for John Smith. Does he have an active email address on file?"

list_all_arketa_reservations

This tool retrieves the attendee list for a specific class. It requires the class_id and is used to verify rosters, waitlists, and capacity.

"Show me all the reservations for the 5:30 PM Pilates class today."

create_a_arketa_reservation

This tool creates a reservation for a class. It handles both existing clients (requiring clientId and purchaseId) and new walk-ins (requiring PII fields).

"Book Sarah Jenkins into the Morning Bootcamp class tomorrow. She is an existing client, so use her active purchase pack."

create_a_arketa_reservation_check_in

This tool marks an existing reservation as checked in. It requires both the class_id and the reservation_id. It is critical for front-desk automation.

"Check in Marcus Miller for the 6 PM Cycling class."

update_a_arketa_reservation_by_id

This tool cancels an existing reservation. It accepts critical financial flags like isLateCancel and issueRefund. You must instruct the LLM carefully on business logic when exposing this tool.

"Cancel Emily's reservation for tomorrow's HIIT class. Since she is outside the 12-hour window, ensure this is NOT marked as a late cancel, and issue a refund to her account."

To view the complete inventory of available tools, required parameters, and JSON schemas, visit the Arketa integration page.

Workflows in Action

When Claude is equipped with these MCP tools, it can chain multiple API calls together to accomplish complex studio tasks that previously required clicking through multiple screens in the Arketa dashboard.

Scenario 1: The Front Desk Walk-In Check-In

When the studio is busy, the front desk can use natural language to quickly find a client and mark them as present.

"Hey Claude, Sarah Jenkins just walked in for the 5 PM Yoga class. Can you check her in?"

1. Claude calls list_all_arketa_classes: The agent searches for today's classes to find the ID for the 5 PM Yoga session.
2. Claude calls list_all_arketa_reservations: Passing the class_id from step 1, the agent scans the roster to locate Sarah Jenkins and retrieves her specific reservation_id.
3. Claude calls create_a_arketa_reservation_check_in: The agent submits the class_id and reservation_id, successfully marking Sarah's attendance.

Result: Claude confirms the check-in is complete, updating Arketa's backend instantly without the user touching the scheduling interface.

sequenceDiagram
  participant User as User Prompt
  participant Claude as Claude Desktop
  participant Truto as Truto MCP Server
  participant Arketa as Arketa API

  User->>Claude: "Check in Sarah for 5 PM Yoga."
  Claude->>Truto: Call list_all_arketa_classes
  Truto->>Arketa: GET /v1/classes
  Arketa-->>Truto: Return classes (ID: 101)
  Truto-->>Claude: JSON response
  Claude->>Truto: Call list_all_arketa_reservations
  Truto->>Arketa: GET /v1/reservations?class_id=101
  Arketa-->>Truto: Return reservations (Sarah Res ID: 555)
  Truto-->>Claude: JSON response
  Claude->>Truto: Call create_a_arketa_reservation_check_in
  Truto->>Arketa: POST /v1/reservations/check-in
  Arketa-->>Truto: Success status
  Truto-->>Claude: Check-in confirmed
  Claude-->>User: "Sarah Jenkins is checked in."

Scenario 2: Managing a Late Cancellation and Waitlist

Studio managers often deal with last-minute schedule changes. AI can handle the multi-step process of canceling a booking and evaluating the financial impact.

"Claude, Mike Davis called to say he can't make the 7 AM Boxing class tomorrow. Cancel his reservation. It's less than 24 hours out, so mark it as a late cancel and do not issue a refund."

1. Claude calls list_all_arketa_classes: Retrieves the schedule to locate the 7 AM Boxing class ID.
2. Claude calls list_all_arketa_reservations: Scans the roster to find Mike Davis and extracts his reservation_id.
3. Claude calls update_a_arketa_reservation_by_id: Submits the cancellation request with the exact parameters requested: isLateCancel: true and issueRefund: false.

Result: The reservation is removed, the client's class pack is correctly penalized according to the late cancel policy, and Claude reports the action is complete.

Security and Access Control

When exposing B2B SaaS platforms like Arketa to AI agents, security is paramount. Truto's MCP architecture provides strict governance features to limit what an LLM can do.

• Method Filtering (config.methods): You can restrict an MCP server to specific operations. By passing ["read"] during server creation, Claude will only have access to get and list operations. It will be able to read schedules and client lists, but completely unable to book or cancel reservations.
• Tag Filtering (config.tags): You can scope an MCP server to specific functional areas. For example, applying a ["sales"] tag might expose purchase and referral tools, while hiding operational tools like room configurations or location management.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL is enough to execute tools. If you enable this flag, the client must also pass a valid Truto API token via a Bearer header. This ensures that even if the MCP URL is leaked in logs, unauthorized users cannot execute Arketa commands.
• Server Expiration (expires_at): You can create temporary, short-lived MCP servers by setting an ISO datetime. Truto enforces this via a scheduled cleanup job and key-value expiration, automatically destroying the server credentials when the time expires.
• Rate Limiting: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Arketa API returns an HTTP 429, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your agent framework) is entirely responsible for implementing retry and backoff logic.

Architecting for the Future of Studio Operations

Connecting Arketa to Claude fundamentally changes how studio teams operate. Instead of navigating complex software interfaces to manage the daily rush of check-ins, cancellations, and bookings, staff can orchestrate the entire Arketa API using natural language.

Building this integration from scratch requires a heavy lift - managing OAuth lifecycles, adapting complex JSON schemas for LLM ingestion, and maintaining the infrastructure through every Arketa API update. Truto's managed MCP architecture eliminates this overhead, providing a secure, production-ready translation layer that simply works.