Connect ShipEngine to Claude: Compare Rates and Manage Carriers

If you need to connect ShipEngine to Claude to automate label creation, dynamically compare shipping rates across carriers, or manage end-of-day manifesting, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and ShipEngine's REST 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 connecting ShipEngine to ChatGPT or explore our broader architectural overview on connecting ShipEngine to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling logistics and shipping ecosystem like ShipEngine is an engineering challenge. You have to handle API key lifecycles, map massive JSON schemas to MCP tool definitions, and deal with ShipEngine's strict API quotas and asynchronous batching requirements. Every time ShipEngine updates an endpoint or modifies a carrier requirement, you have to 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 ShipEngine, connect it natively to Claude, and execute complex fulfillment workflows using natural language.

The Engineering Reality of the ShipEngine 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 logistics APIs is painful. ShipEngine abstracts dozens of distinct carriers (FedEx, UPS, USPS, DHL), but that complexity leaks into the API schemas.

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

Carrier-Specific Payload Variability When you attempt to connect a new carrier via the API, the payload schema is entirely dependent on the specific carrier. Calling an endpoint to connect Access Worldwide requires a simple username and password. Connecting FedEx requires a deeply nested JSON object containing account numbers, physical addresses, meter numbers, and specific contact details. An LLM cannot simply guess this payload structure based on a generic "connect carrier" tool. The MCP server must dynamically expose strictly typed schemas that guide the LLM to provide the correct fields based on the chosen carrier.

The Rate-to-Label Orchestration Gap A common shipping workflow is to request shipping rates, pick the cheapest one, and buy a label. In ShipEngine, generating a rate creates a transient rate_id. To purchase the label without resubmitting the entire origin/destination and package dimension payload, you must specifically invoke a separate endpoint that buys the label via that rate_id. If an LLM does not understand this stateful sequence, it will hallucinate API calls or attempt to pass rate objects back into standard shipment endpoints, resulting in 400 Bad Request errors.

Asynchronous Batch Label Processing ShipEngine is designed for scale. You cannot fetch 10,000 labels synchronously. You must create a batch of shipments, wait for the processing engine to digest them, poll the batch status, handle isolated processing errors, and finally request the batch label download. Converting this asynchronous polling mechanism into a synchronous tool call that Claude can understand requires careful orchestration and schema design.

Generating the ShipEngine MCP Server

Truto's dynamic tool generation engine derives MCP tools directly from API documentation and resource schemas. When you connect a ShipEngine account, Truto automatically builds the JSON-RPC 2.0 endpoints required for Claude to discover and call these endpoints.

You can generate the MCP Server URL using either the Truto UI or via the API.

Method 1: Via the Truto UI

This is the fastest method for interactive development and testing.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected ShipEngine account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can apply method filters (e.g., allow only read operations) or tag filters (e.g., expose only tools related to labels).
5. Copy the generated MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For production deployments where you need to programmatically provision AI agents for multiple tenants, you can generate the MCP server via a REST API call.

curl -X POST https://api.truto.one/integrated-account/<shipengine_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ShipEngine Production Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["shipping", "logistics"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API response returns the secure URL required to initialize the server.

{
  "id": "mcp_srv_98765",
  "name": "ShipEngine Production Agent",
  "config": {
    "methods": ["read", "write"],
    "tags": ["shipping", "logistics"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL contains a cryptographic token that securely maps to the specific ShipEngine tenant.

Connecting the MCP Server to Claude

Once you have the server URL, you must register it with Claude so the model can issue tools/list and tools/call requests over JSON-RPC.

Method A: Via the Claude UI (Web / Enterprise)

If you are using Claude's web interface on a supporting plan:

1. Go to Settings - Integrations.
2. Click Add MCP Server or Add custom connector.
3. Paste the Truto MCP URL generated in the previous step.
4. Click Add. Claude will immediately execute an MCP handshake, discover the ShipEngine tools, and make them available in the chat context.

(Note for ChatGPT users: The process is similar. Go to Settings - Apps - Advanced Settings - Enable Developer Mode - Add custom connector).

Method B: Via Configuration File (Claude Desktop)

If you are running Claude Desktop locally or configuring an agentic framework, you must update the claude_desktop_config.json file. Because the Truto MCP server is hosted, you use the Server-Sent Events (SSE) transport adapter.

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

Restart Claude Desktop. The agent will initialize the SSE connection and pull down the full schema of ShipEngine operations.

ShipEngine MCP Hero Tools

Truto automatically generates descriptive, snake_case tool names from the underlying API paths and methods. Here are the highest-leverage tools exposed for ShipEngine.

1. ship_engine_addresses_validate

Before rating or shipping a package, the address must be validated. This tool cross-references physical addresses against global postal databases to verify deliverability. It returns a normalized payload containing the original address, the matched deliverable address, and validation messages.

"I have a customer named Jane Doe at 123 Main St, Apt 4B, Austin TX 78701. Validate this address using ShipEngine and tell me if it requires any corrections before I create a shipping label."

2. create_a_ship_engine_rate

Calculates shipping rates for a specific shipment. You can provide a full JSON object defining the origin, destination, weight, and dimensions, or pass an existing shipment_id. The tool returns an array of competitive rates across your connected carriers.

"Compare shipping rates to send a 5-pound, 10x10x10 inch box from our Austin warehouse to the validated Jane Doe address. Give me the cheapest USPS rate and the fastest FedEx rate."

3. ship_engine_labels_create_from_rate

Once Claude identifies the preferred rate using the tool above, it uses this tool to purchase the label directly from the rate_id. This prevents the LLM from having to reconstruct and submit the complex shipment payload a second time.

"Go ahead and purchase the label for the cheapest USPS rate you just found. Once purchased, give me the tracking number and a link to download the PDF label."

4. ship_engine_labels_track

Retrieves real-time tracking events for a specific label ID. It returns detailed carrier status codes, estimated delivery dates, and a complete event history array.

"Check the tracking status for label ID se-10928374. Let me know exactly where the package is right now and if there are any delivery exceptions."

5. create_a_ship_engine_manifest

Essential for end-of-day operations. This tool generates a carrier manifest (SCAN form) for a specific warehouse and ship date, ensuring the carrier accepts the physical packages.

"It is the end of the day. Generate a USPS manifest for all packages shipped out of the primary warehouse today, and return the manifest download link so I can print it for the driver."

6. list_all_ship_engine_carriers

Queries all carrier accounts currently connected to the ShipEngine instance. It returns carrier IDs, account balances, services offered, and connection statuses, allowing the agent to dynamically route packages based on available carriers.

"List all active carriers connected to our ShipEngine account. Tell me which ones have a prepaid balance and verify that they are in a 'connected' state."

To view the complete inventory of available ShipEngine tools, including endpoints for managing custom package types, webhook configurations, and insurance funds, check out the ShipEngine integration page.

Workflows in Action

Exposing individual endpoints is useful, but the true power of an MCP server lies in the LLM's ability to orchestrate multi-step logical sequences.

Scenario 1: Rate Shopping and Label Generation

Customer service agents often need to process manual orders. Instead of jumping between tabs, they can simply ask Claude to handle the fulfillment logic.

"We need to overnight a replacement part to Bob Smith at 456 Tech Blvd, San Francisco, CA 94107. The package is a 2lb custom box (12x8x4). Please validate his address, find the cheapest overnight rate, buy the label, and output the tracking URL."

Tool Execution Sequence:

1. Claude calls ship_engine_addresses_validate with the raw text to get a standardized, verified California address.
2. Claude calls create_a_ship_engine_rate passing the validated address, package weight (2lbs), dimensions, and a filter for overnight services.
3. The tool returns the rate options. Claude analyzes the array and selects the rate_id with the lowest cost.
4. Claude calls ship_engine_labels_create_from_rate using the selected rate_id.
5. Claude responds to the user with the final tracking_number and the label_download.pdf link.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant ShipEngine as ShipEngine API

    User->>Claude: "Overnight a 2lb box to Bob..."
    Claude->>MCP: Call tool: ship_engine_addresses_validate
    MCP->>ShipEngine: POST /v1/addresses/validate
    ShipEngine-->>MCP: Validated address JSON
    MCP-->>Claude: Tool result
    
    Claude->>MCP: Call tool: create_a_ship_engine_rate
    MCP->>ShipEngine: POST /v1/rates
    ShipEngine-->>MCP: Rate array (USPS, FedEx)
    MCP-->>Claude: Tool result
    
    Claude->>MCP: Call tool: ship_engine_labels_create_from_rate
    MCP->>ShipEngine: POST /v1/labels/rates/{rate_id}
    ShipEngine-->>MCP: Label ID, Tracking URL, PDF link
    MCP-->>Claude: Tool result
    Claude-->>User: "Label purchased. Tracking: 1Z999..."

Scenario 2: Proactive Delivery Exception Management

An IT admin wants an AI agent to act as an automated logistics coordinator, checking high-value shipments for delays.

"Look up the tracking status for all active labels generated in the last 48 hours. If any package has an 'exception' status, alert me with the recipient's information and the exception description."

Tool Execution Sequence:

1. Claude calls list_all_ship_engine_labels with query parameters filtering by label_status and created_at date ranges.
2. For each returned label_id, Claude calls ship_engine_labels_track.
3. Claude inspects the status_code and exception_description in the response payloads.
4. Claude aggregates the data and outputs a formatted markdown list of delayed packages, extracting the recipient details from the original label data.

Security and Access Control

Giving an AI agent raw API access to a logistics platform capable of spending real money requires strict governance. Truto's MCP implementation provides several layers of security to lock down what Claude can do.

• Method Filtering: When creating the server, you can set config.methods: ["read"]. This restricts the AI agent to querying rates, listing carriers, and tracking labels. It prevents the model from invoking POST requests that purchase labels or delete carrier accounts.
• Tag Filtering: ShipEngine resources are tagged logically. You can scope an MCP server by setting config.tags: ["tracking"] to ensure the agent only has access to tracking and visibility endpoints, completely hiding billing and label creation tools.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. For higher security, enabling this flag requires the MCP client to pass a valid Truto API token in the Authorization header. This ensures only authenticated internal services can use the server.
• Automatic Expiration (expires_at): You can generate ephemeral servers that expire on a specific ISO datetime. Once expired, the underlying key-value store automatically purges the token, instantly revoking the AI's access to ShipEngine.
• Rate Limit Transparency: Truto does not retry, throttle, or absorb rate limit errors. If ShipEngine returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream limit info into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The client executing the workflow must read these headers and implement its own retry and backoff logic.

Strategic Wrap-up

Connecting ShipEngine to Claude transforms an LLM from a passive text generator into an active logistics operator. However, managing the raw API orchestration - parsing nested carrier schemas, mapping synchronous intents to asynchronous batch jobs, and handling strict API quotas - is an expensive distraction for your engineering team.

By leveraging Truto's dynamically generated MCP servers, you eliminate the integration middleware. You define the security boundaries, filter the available methods, and instantly provision a secure server URL. The LLM handles the orchestration, ShipEngine handles the logistics, and your engineers get back to building your core product.