---
title: "Connect Project44 to Claude: Streamline LTL Quotes and Dispatching"
slug: connect-project44-to-claude-streamline-ltl-quotes-and-dispatching
date: 2026-10-13
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Project44 to Claude using Truto's managed MCP server. Automate LTL dispatching, rate quotes, and freight tracking with AI agents."
tldr: "Connect Project44 to Claude via Truto's managed MCP server to automate supply chain tasks. This guide covers LTL quoting, dispatching, and tracking workflows with zero custom integration code."
canonical: https://truto.one/blog/connect-project44-to-claude-streamline-ltl-quotes-and-dispatching/
---
# 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](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), 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/](https://truto.one/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/](https://truto.one/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](https://truto.one/connect-ai-agents-to-netsuite-sap-via-mcp-the-2026-architecture-guide/). 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.
> Want to give your AI agents secure, authenticated access to Project44 and 100+ other B2B APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)
## The Engineering Reality of the Project44 API
A [custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) 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:**
```bash
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:**
```json
{
"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:
```json
{
"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](https://truto.one/integrations/detail/project44).
## 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.
```mermaid
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").
```mermaid
flowchart TD
A["User Prompt: Audit
Memphis Shipments"] --> B["Call: project_44_shipment_search_search"]
B --> C{"Does shipment
have exceptions?"}
C -->|"Yes"| D["Call: get_single_project_44_..._history"]
C -->|"No"| E["Ignore"]
D --> F["Parse telematics
and event codes"]
F --> G["Generate Exception
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.