Connect Perk to ChatGPT: Automate Travel Billing & Expenses

If you need to connect Perk (TravelPerk) to ChatGPT to automate corporate travel tracking, manage SCIM user provisioning, or orchestrate complex billing reconciliations, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and TravelPerk's REST and SCIM APIs. You can either build, host, and maintain this stateful middleware yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

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

Giving a Large Language Model (LLM) read and write access to an enterprise travel management platform requires strict operational boundaries. You must handle complex identity payloads, enforce strict filtering on financial records, and deal with disparate API paradigms (REST vs. SCIM). Every time Perk updates an endpoint or adds a new parameter, custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the Perk API

Building a custom MCP server is an exercise in managing third-party API debt. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Perk's specific API surface requires handling several deep architectural quirks. If you decide to build a custom MCP server for Perk, you own the entire integration lifecycle.

Here are the specific integration challenges you will encounter:

Dual-Headed API Paradigms: SCIM vs REST

Perk relies on two fundamentally different API paradigms depending on the resource you are targeting. Travel data (trips, invoices, cost centers) operates over standard REST endpoints. However, user management is handled exclusively via SCIM (System for Cross-domain Identity Management). If you want an LLM to update a user's department or active status, it cannot simply PUT a JSON object to a /users endpoint. Your server must translate LLM intent into a strict SCIM PatchOp payload containing specific URN schemas (e.g., urn:ietf:params:scim:schemas:core:2.0:User). If your MCP server does not perfectly map natural language updates into SCIM compliant arrays, user provisioning will fail.

Strict Mutually Exclusive Filtering

When fetching financial data like invoice lines, Perk enforces rigid querying rules. For example, querying list_all_perk_invoices_lines requires the caller to know that network_transaction_id cannot be combined with any other filters. Furthermore, these endpoints will only return invoices issued on or after January 1st, 2019. If you do not build validation logic into your MCP tool schemas, an LLM will frequently hallucinate invalid combinations of query parameters, resulting in HTTP 400 errors.

Conditional Bulk Updates

The logic for updating cost centers in bulk changes depending on the configuration of the target workspace. For the perk_cost_centers_bulk_updates_bulk_update operation, if cost object types are not enabled for the organization, the archive flag is strictly required. If they are enabled, the payload must supply at least one of archive or a non-null type. Expecting an LLM to dynamically intuit the workspace configuration before structuring its payload is a recipe for broken workflows.

Perk to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT calling the Perk API, follow these steps.

Prerequisites:

• A Truto account with API access.
• TravelPerk admin credentials to approve the OAuth connection.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode enabled.

Step 1: Connect Perk to Truto

In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select Perk, and execute the OAuth flow. Truto securely stores the resulting credentials and automatically handles the token refresh lifecycle in the background. ChatGPT will never interact with a stale token.

Step 2: Grab your integrated_account_id

Copy the ID from the account detail page in the UI, or fetch it programmatically via the API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 3: Generate the Perk MCP Server

You can generate the MCP server URL through the UI or the API. Both methods result in a secure, self-contained endpoint scoped entirely to the connected Perk account.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your Perk connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name, allowed methods like read or write, and tag filters).
5. Copy the generated MCP server URL provided on the screen.

Method B: Via the API Make a single POST request to generate the server dynamically. This is ideal for programmatic provisioning.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Perk ChatGPT Integration",
    "config": {
      "methods": ["read", "write"],
      "tags": ["trips", "invoices", "scim"]
    }
  }'

The response contains a url field structured as https://api.truto.one/mcp/<token>. This URL carries the necessary routing and authentication instructions. Treat it as a secret.

Step 4: Connect the MCP Server to ChatGPT

You must now register this URL with your ChatGPT client. You can do this visually or via a local proxy configuration.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on (MCP support requires this).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Set the Name to "TravelPerk Integrator".
5. Paste the Truto MCP URL into the Server URL field and click Save. ChatGPT will immediately connect, discover the tools, and make them available in your chat context.

Method B: Via Manual Config File If you are running a local MCP proxy or testing with custom agent setups, you can define the server using an SSE transport configuration block. This leverages the official MCP server proxy package:

{
  "mcpServers": {
    "perk-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<your_secure_token>"
      ]
    }
  }
}

sequenceDiagram
    participant ChatGPT as ChatGPT Client
    participant TrutoMCP as Truto MCP Router
    participant PerkAPI as TravelPerk Upstream
    
    ChatGPT->>TrutoMCP: JSON-RPC tools/call (list_all_perk_trips)
    Note over TrutoMCP: Validates Cryptographic Token<br>Applies Tag & Method Filters
    TrutoMCP->>PerkAPI: GET /trips with Managed Bearer Auth
    PerkAPI-->>TrutoMCP: 200 OK + Payload
    Note over TrutoMCP: Normalizes Pagination & Headers
    TrutoMCP-->>ChatGPT: JSON-RPC Result

Rate Limits: The Architectural Reality

When connecting LLMs to production systems, rate limiting is a critical concern. LLMs can easily fan out dozens of API requests in seconds if executing a complex orchestration loop.

Factual constraint: Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When the upstream Perk API returns an HTTP 429 Too Many Requests, Truto passes that error directly back 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 (your custom agent or the MCP client implementation) is entirely responsible for detecting these 429s and implementing appropriate retry and exponential backoff logic.

Hero Tools for Perk

The Truto MCP server dynamically generates tools based on the underlying API schemas. Here are the highest-leverage tools available for automating Perk operations via ChatGPT.

1. List All Perk Trips

Retrieves a comprehensive list of all travel itineraries in the workspace, returned in descending order of modification time. Useful for auditing active travel and verifying location data.

"Get a list of all recent trips in TravelPerk. Filter down to the ones that started in the last 7 days and summarize the start and end locations."

2. Create a Perk SCIM User

Provisions a new user in the Perk system using the SCIM protocol. This handles complex nested schemas for name, active status, and specific travel attributes like travelPolicy.

"Create a new TravelPerk user for Jane Doe (jane.doe@example.com). Ensure she is marked as active and assign her the standard engineering travel policy."

3. Update a Perk Cost Center by ID

Modifies the financial routing for a specific cost center. You can rename it, change the approver, alter the delegate, or adjust the company scope.

"Find the 'Q3 Marketing Offsite' cost center and update the approver to John Smith's user ID. Do not alter the existing delegate settings."

4. List All Perk Invoices Lines

Extracts granular line-item details from invoices, including descriptions, quantities, unit prices, and total amounts. Essential for granular expense auditing and ledger reconciliation.

"Pull the invoice lines for invoice INV-01-987654. Break down the expenses by unit price and calculate the total amount spent on hotels versus flights."

5. Perk Cost Center Users Bulk Update

Replaces the entire list of users assigned to a specific cost center in a single operation. Any user not included in the provided array is instantly removed from the cost center.

"Update the 'Executive Travel' cost center to only include these three user IDs. Remove all other currently assigned users from this cost center."

6. Get Single Perk Invoice PDF by ID

Fetches a specific invoice document as binary PDF file content. Useful when you need the actual document for compliance storage or secondary OCR processing.

"Retrieve the PDF file for invoice INV-01-123456 so we can attach it to our monthly ledger reconciliation report."

For the complete inventory of available tools, required parameters, and schema definitions, view the Perk integration page.

Workflows in Action

Connecting an LLM to an API is only valuable if it can execute multi-step operations. Here is how ChatGPT orchestrates real-world travel operations using the MCP server.

Scenario 1: New Hire SCIM Onboarding & Financial Routing

When a new executive joins the company, HR needs them provisioned in the travel system and assigned to the correct cost center immediately.

The Prompt:

"We just hired a new VP of Sales, Sarah Connor (sarah.c@company.com). Provision her account in TravelPerk, then find the 'Enterprise Sales' cost center and add her to it. Verify she was added successfully."

The Execution:

1. ChatGPT calls create_a_perk_scim_user with the provided email and name, extracting the new SCIM id from the response.
2. It calls list_all_perk_cost_centers to search the array for a name matching 'Enterprise Sales', capturing that cost center's id and current users array.
3. It appends Sarah's new SCIM ID to the existing users array, and calls perk_cost_center_users_bulk_update to overwrite the roster.
4. ChatGPT formats a clean confirmation message detailing the successful provisioning and assignment.

Scenario 2: Monthly Ledger Reconciliation

Finance teams spend hours manually cross-referencing invoice lines against trip itineraries to detect out-of-policy spending.

The Prompt:

"Look up all invoice lines for the billing period ending last week. Cross reference these lines against our active trips to see if there are any line items tagged to cancelled trips. Summarize the total discrepancy in USD."

The Execution:

1. ChatGPT calls list_all_perk_invoices_lines using specific date filters to narrow down the dataset.
2. It calls list_all_perk_trips to pull the master list of trips and their current status (active vs. cancelled).
3. The LLM iterates over the invoice lines in its context window, matching the metadata or description back to the trip IDs.
4. It identifies any lines associated with cancelled trips, sums their total_amount, and outputs a formatted markdown table for the finance team.

Security and Access Control

When exposing enterprise financial and identity data to an AI model, security cannot be an afterthought. The Truto MCP architecture provides multiple layers of defense to ensure models only interact with permitted boundaries.

• Method Filtering: At the point of server creation, you can restrict the token to specific operational categories. Setting methods: ["read"] ensures the server will only generate tools for GET and LIST operations, guaranteeing the LLM cannot accidentally delete a user or alter a cost center.
• Tag Filtering: You can isolate the server to specific functional areas by applying tags. For instance, filtering by tags: ["invoices"] generates a server containing only billing-related tools, completely hiding SCIM user endpoints from the model's context.
• Time-to-Live (TTL): MCP servers can be ephemeral. By setting an expires_at timestamp during creation, the server's cryptographic token will automatically self-destruct at the specified time, cutting off all access. This is perfect for granting temporary access to automated auditing agents.
• Enforced API Token Auth: For high-security internal deployments, passing require_api_token_auth: true means possession of the URL is no longer enough. The connecting client must also supply a valid Truto API token as a Bearer header, adding a strict secondary layer of authentication to every JSON-RPC request.

Moving Forward

Building an integration layer that reliably connects AI models to complex, dual-paradigm systems like TravelPerk requires massive engineering investment. You have to handle SCIM patching schemas, binary file streams, and dense financial filtering constraints all while maintaining an airtight security boundary.

By leveraging Truto, you bypass the infrastructure build entirely. You get dynamically generated, fully authenticated MCP servers that map directly to the integration's documentation, ensuring your AI agents have the exact schemas they need to execute flawless workflows.

Stop managing integration debt. Let your agents do the heavy lifting.