Connect Project44 to Claude: Streamline LTL Quotes and Dispatching

If you need to connect Project44 to Claude to automate LTL dispatching, manage multi-modal freight shipments, or audit capacity provider performance, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool-calling capabilities and Project44's sprawling logistics APIs. You can either build and maintain this 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 /connect-project44-to-chatgpt-track-freight-and-manage-logistics-data/ or explore our broader architectural overview on /connect-project44-to-ai-agents-automate-global-booking-and-assets/.

Giving a Large Language Model (LLM) read and write access to a highly specialized, mission-critical logistics platform like Project44 is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Project44's legacy tracking endpoints existing alongside newer capacity provider schemas. Every time Project44 deprecates an endpoint or introduces a new multi-modal booking model, you must update your server code, redeploy, and test the integration.

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

The Engineering Reality of the Project44 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 supply chain APIs is painful. Project44 is built to handle global visibility across LTL (Less Than Truckload), TL (Truckload), Ocean, Rail, and Parcel. Its API reflects the immense complexity of physical freight movement.

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

Fragmented API Architectures (Legacy vs Modern) Project44 has evolved significantly, resulting in a fragmented API surface. For example, you will find legacy tracking endpoints (e.g., legacy LTL tracking, legacy Truckload tracking) co-existing with newer, unified multi-modal booking and capacity provider endpoints. An LLM has no context on which API version to use for a specific operation. You must build an abstraction layer that presents a cohesive set of operations to Claude, hiding the underlying endpoint fragmentation. If a user asks to "track a shipment," the LLM needs to know exactly which endpoint handles that specific mode of transport.

Complex Payload Structures for Quotes and Dispatching Booking freight programmatically is not a simple CRUD operation. Getting an LTL rate quote or dispatching a load requires deeply nested JSON payloads containing equipment details, accessorials (liftgate, inside delivery), commodity dimensions, freight classes, and exact stop-level address schemas. If an LLM hallucinates a freight class or omits a required equipment identifier, the Project44 API will reject the request. Your MCP server must expose strictly defined JSON Schemas that force the model to construct these complex logistics payloads perfectly.

Push Tracking and Webhook Asynchrony Supply chain visibility relies heavily on asynchronous updates. Carriers push telematics, status updates, and electronic BOLs (Bills of Lading) back to Project44. When an LLM asks "where is this truck," the answer might involve querying an event history endpoint, parsing sensor data, or reading a tenant attribute. Mapping these asynchronous data streams into synchronous tools that Claude can consume requires careful API orchestration.

Rate Limits and Upstream Throttling Project44 enforces strict API quotas based on your contract and capacity tier. It is critical to understand that when the Project44 API returns an HTTP 429 Rate Limit Exceeded error, Truto passes that error directly back to the caller. Truto does not automatically retry, throttle, or absorb these errors. Instead, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your agent framework or calling application is entirely responsible for observing these headers and implementing its own exponential backoff strategy.

How to Generate a Project44 MCP Server

Truto eliminates the need to build and host custom MCP infrastructure. By introspecting the Project44 integration definitions and your connected account credentials, Truto dynamically generates a complete JSON-RPC 2.0 MCP server. Tools are derived directly from Project44 API documentation schemas.

You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

This is the fastest method for internal operational teams who need to connect their own Project44 account to an AI assistant.

1. Log into your Truto dashboard and navigate to your Integrated Accounts.
2. Select your connected Project44 account.
3. Click on the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (name, specific tags, allowed HTTP methods, and expiration date).
6. Click Create and securely copy the generated MCP server URL.

Method 2: Via the Truto API

For developers building AI products who need to provision MCP access for their users dynamically, use the REST API. This creates a secure, hashed token in distributed KV storage.

Request:

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": "Project44 LTL Dispatch Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["ltl", "shipments"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp_b7a8c9d0",
  "name": "Project44 LTL Dispatch Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["ltl", "shipments"]
  },
  "url": "https://api.truto.one/mcp/abc123def456..."
}

The url returned is a fully self-contained, authenticated JSON-RPC 2.0 endpoint that you can plug directly into any MCP client.

Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude requires zero additional code.

Method A: Via the Claude or ChatGPT UI

If you are using a commercial AI interface that supports remote MCP servers:

• For Claude: Navigate to Settings -> Integrations -> Add MCP Server. Paste the Truto MCP URL into the connection field and click Add.
• For ChatGPT: Navigate to Settings -> Connectors -> Add (requires Developer Mode enabled on supported tiers). Paste the Truto MCP URL and save.

The AI client will instantly complete a handshake, fetch the OpenAPI-derived schemas for Project44, and list the available supply chain tools.

Method B: Via Manual Configuration (Claude Desktop)

If you are running Claude Desktop and need to configure the server manually via the claude_desktop_config.json file, you will use the official @modelcontextprotocol/server-sse proxy to connect to Truto's remote endpoint.

Locate your config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the following configuration:

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

Restart Claude Desktop. The agent will now have semantic access to your Project44 freight data.

Security and Access Control

Giving an LLM write access to a logistics platform handling expensive physical freight requires strict governance. Truto provides four mechanisms to lock down your MCP server:

• Method Filtering (config.methods): Restrict the agent's capabilities to specific HTTP methods. Passing ["read"] ensures the agent can query rates and track shipments, but cannot accidentally dispatch a truck or cancel a booking.
• Tag Filtering (config.tags): Scope the server to specific operational domains. For example, tag tools with ltl or ocean to ensure an LTL-focused agent doesn't interact with ocean shipping data.
• Extra Authentication (require_api_token_auth): By default, the MCP URL contains a secure, hashed token. Enabling this flag requires the MCP client to also pass a valid Truto API token in the Authorization header, providing defense-in-depth.
• Time-to-Live (expires_at): Auto-expire the MCP server at a specific datetime. The infrastructure uses durable timers to guarantee the server and its KV credentials are destroyed exactly when specified - perfect for temporary auditing access.

Project44 Hero Tools for Claude

Truto automatically translates Project44's API endpoints into semantically rich tools. Here are six high-leverage tools that unlock powerful agentic workflows.

1. Search LTL Rate Quotes

Tool Name: project_44_ltl_rate_quotes_search

Allows the LLM to query carrier pricing for Less Than Truckload shipments based on origin, destination, freight class, and equipment requirements.

"Get LTL rate quotes for moving two pallets of class 70 freight (1500 lbs) from Dallas, TX (75201) to Chicago, IL (60601) next Tuesday. Show me the carriers with the lowest transit times first."

2. Dispatch an LTL Shipment

Tool Name: create_a_project_44_ltl_dispatch

Executes the booking and dispatching of an LTL shipment based on a selected rate quote. This requires a complex payload defining handling units and pickup schedules.

"Go ahead and dispatch the LTL load to Old Dominion based on the quote we just retrieved. Schedule the pickup window between 14:00 and 17:00 tomorrow at the Dallas warehouse dock 4."

3. Retrieve Shipment Tracking History

Tool Name: get_single_project_44_shipment_tracking_history_by_id

Fetches the complete lifecycle of a tracked shipment, including telematics positions, stop statuses, and exception events. Critical for resolving ETA disputes.

"Pull the complete tracking history for shipment ID 987654321. Tell me exactly what time it arrived at the cross-dock and if there were any weather-related exception codes logged."

4. Search Master Shipments

Tool Name: project_44_shipment_search_search

Executes a complex search across all Project44 shipments matching specific criteria like active vehicle identifiers, status codes, or geographic regions.

"Find all active shipments currently routed to our Atlanta distribution center that are marked as delayed or have missed their original appointment window."

5. Create a Multi-Modal Booking

Tool Name: create_a_project_44_multi_modal_booking

Initiates a multi-modal booking request spanning different transport legs (e.g., drayage to rail to drayage).

"Draft a multi-modal booking for a 40ft container from the Port of Long Beach to our Denver facility via rail. Set the booking source method to EDI and assign it to capacity provider ID 4455."

6. Manage Inventory Items

Tool Name: create_a_project_44_inventory_item

Creates a tracked inventory item record within the Project44 system, allowing supply chain systems to track SKU-level freight alongside macro-level containers.

"Create a new inventory item in the system for SKU 'XYZ-900'. Set the dimensional weight and link it to the inbound purchase order PO-88909."

For a complete list of all supported endpoints, custom methods, and detailed schema mappings, view the full Project44 integration page.

Workflows in Action

By chaining these tools together, Claude transforms from a text generator into a logistics automation engine. Here are two real-world scenarios.

Scenario 1: Autonomous Freight Quoting and Dispatch

Persona: Logistics Operations Manager

"I need to move a 2,000 lb skid of electronics (class 100) from our Seattle hub (98101) to Austin, TX (78701). Pull LTL rate quotes. If there is a carrier offering under $800 with a transit time of 4 days or less, automatically dispatch it for pickup tomorrow afternoon. Otherwise, just list the top 3 options."

How the agent executes this:

1. Search Rates: Claude calls project_44_ltl_rate_quotes_search with the origin, destination, class, and weight constraints.
2. Evaluate Logic: The model parses the JSON response, evaluating costs and transit times against the user's constraints.
3. Dispatch (Conditional): If a carrier meets the criteria, Claude constructs the heavy dispatch payload and calls create_a_project_44_ltl_dispatch.
4. Confirm: The agent formats the final BOL URL, pickup confirmation, and carrier details for the user.

sequenceDiagram
    participant User as "Logistics Manager"
    participant Agent as "Claude Desktop"
    participant Truto as "Truto MCP Server"
    participant P44 as "Project44 API"
    
    User->>Agent: "Find rates and dispatch if under $800..."
    Agent->>Truto: Call project_44_ltl_rate_quotes_search
    Truto->>P44: Execute REST search query
    P44-->>Truto: Return array of quotes
    Truto-->>Agent: JSON quote payload
    
    Note over Agent: Model evaluates rates vs rules
    
    Agent->>Truto: Call create_a_project_44_ltl_dispatch
    Truto->>P44: Execute dispatch payload
    P44-->>Truto: Return Shipment ID & BOL
    Truto-->>Agent: JSON success confirmation
    Agent-->>User: "Shipment dispatched. BOL attached."

Scenario 2: Exception Management and ETA Auditing

Persona: Supply Chain Analyst

"Scan all inbound shipments arriving at the Memphis facility today. Identify any that have tracking exceptions, retrieve their full event history, and write a summary of exactly where they are currently stuck and why."

How the agent executes this:

1. Discover Shipments: Claude calls project_44_shipment_search_search filtering by the Memphis destination ID and today's date range.
2. Filter Exceptions: The agent reviews the returned array, identifying shipment IDs that carry exception flags.
3. Deep Dive History: For each flagged shipment, Claude loops through get_single_project_44_shipment_tracking_history_by_id to extract exact lat/long positions and telematics event codes.
4. Synthesize: Claude generates a human-readable logistics report detailing bottlenecks (e.g., "Shipment 884 is held at weigh station in Arkansas due to equipment failure").

flowchart TD
    A["User Prompt: Audit<br>Memphis Shipments"] --> B["Call: project_44_shipment_search_search"]
    B --> C{"Does shipment<br>have exceptions?"}
    C -->|"Yes"| D["Call: get_single_project_44_..._history"]
    C -->|"No"| E["Ignore"]
    D --> F["Parse telematics<br>and event codes"]
    F --> G["Generate Exception<br>Report for User"]

Moving Forward

Building AI agents that can reliably interact with global supply chain APIs requires solid infrastructure. Dealing with Project44's dense freight schemas, rate limiting policies, and fragmented API versions distracts your engineering team from building actual AI logic. By leveraging Truto's dynamically generated MCP servers, you offload the entire integration lifecycle - from authentication to schema mapping - ensuring your LLMs have safe, structured, and immediate access to your critical logistics data.