Multi-Carrier LTL Freight Rate Quote Tool

Manual freight quotes are death by a thousand clicks. Log into FedEx. Enter the shipping details. Copy the rate. Log into R+L Carriers. Re-enter the same information. Copy that rate. Repeat for Old Dominion, Pitt Ohio, and XPO. Twenty minutes later, you have quotes from five carriers that you can finally compare. Do this dozens of times per day, and the time cost becomes unsustainable—not to mention the data entry errors that creep in when you’re manually transcribing weights, dimensions, and addresses across six different carrier portals.

We built a multi-carrier LTL freight rate quote tool that automated this entire process, reducing quote generation from over 20 minutes to under 60 seconds while eliminating manual data entry entirely.

The Challenge

An electrical supply distributor in the Tyler, Texas area was running into the same freight quoting bottleneck that plagues most B2B distributors. Their sales team needed to provide accurate LTL freight quotes for orders—sometimes multiple pallets with specific delivery requirements like liftgate service, inside delivery, or residential addresses.

The manual process meant logging into each carrier’s website separately, entering shipment details, selecting service options, and recording rates. With five different carriers to check for competitive pricing, a single quote consumed significant time. Multiply that across dozens of quotes per week, and the inefficiency compounds.

Beyond the time drain, manual entry introduced errors. Transposing a weight, missing an accessorial charge, or copying the wrong service level could result in quotes that didn’t match actual shipping costs. The disconnect between quoted rates and actual carrier charges created billing discrepancies and customer service headaches.

They needed a unified system that could pull shipment details from their order management platform, query multiple carriers simultaneously, and display comparative rates with full accessorial breakdowns—all without requiring sales staff to touch five different carrier portals.

Our Approach

The core technical challenge wasn’t just building API integrations—it was orchestrating multiple carrier APIs with completely different protocols, authentication methods, and data structures into a single unified interface.

FedEx used a complex REST API with deeply nested JSON request objects. A single rate request required multiple nested address objects (shipper, recipient, pickup location, potential hold locations), package line item arrays with sub-packaging details, special services objects for dangerous goods handling, customs clearance structures with commodity breakdowns, and variable handling charge specifications. The request object could easily exceed 200 lines of JSON with dozens of required and optional fields that had to be understood and properly structured.

Pitt Ohio used SOAP/XML endpoints, requiring completely different request formatting and parsing logic compared to the REST-based carriers.

R+L Carriers and Old Dominion offered more straightforward REST APIs, but each had their own authentication requirements, request formats, and response structures.

Rather than building five separate, disconnected integration scripts, we designed an abstract class pattern that normalized the differences while preserving the flexibility to handle each carrier’s unique requirements.

The Solution

We built the rate quote tool as an integrated module within their existing Concrete5 content management system, allowing it to share database access with their core order management platform. The system pulled shipment details directly from orders being built, eliminating duplicate data entry.

Abstract API Architecture created a parent BaseFreightAPI class that handled common functionality—database connections, quote result storage, and display formatting. Each carrier extended this parent as a child class (FedExAPI, PittOhioAPI, RLCarriersAPI, OldDominionAPI) with carrier-specific request formatting and response parsing logic.

Every carrier’s processQuote() method returned a standardized QuoteResult object containing:

• Carrier name and service level
• Base freight rate
• Itemized accessorial charges (residential delivery, liftgate, inside delivery, limited access pickup, call before delivery)
• Applied customer discounts
• Total cost

This normalization meant the display layer could present all carrier quotes in a consistent format regardless of how different the underlying API responses were.

cURL Wrapper Class abstracted HTTP request handling, managing authentication, error handling, and response parsing. This kept carrier-specific API classes focused on data transformation rather than HTTP mechanics.

User Workflow Integration embedded directly into the sales order creation process. When building an order in their order management system, sales reps could:

1. Select any required accessorial services (liftgate, residential delivery, inside delivery, call before delivery, limited access pickup)
2. Click “Get Freight Quote”
3. The system pulled shipment details from the order (origin, destination, weights, dimensions, customer information)
4. Simultaneously queried all carrier APIs (or sequentially if certain carriers required multiple calls for different service levels)
5. Displayed all quotes in a side-by-side comparison table, sorted by total cost with the lowest rate highlighted with a green border and carrier logo images for visual clarity

Quote Persistence saved the generated quotes to MySQL under the order ID with carrier type and full rate breakdown. Sales staff could later retrieve quotes directly from the order management portal without regenerating them—particularly useful when customers called back days later asking about shipping options. The saved quotes converted into actual orders at a high rate, as customers typically requested quotes when they were ready to proceed.

Service Level Handling managed carriers that offered multiple shipping speeds. When a carrier’s API supported both two-day and overnight service in a single response, we displayed both. When separate API calls were required, we made both requests to ensure customers saw all available options. Speed mattered—we optimized to minimize total quote generation time while still providing comprehensive carrier coverage.

Technical Complexity

The FedEx integration exemplified the complexity differential between carriers. While most carriers required basic origin/destination addresses, package weights, and dimensions, FedEx’s API supported extensive configuration options:

• Multiple address types (shipper, recipient, pickup location, hold-at-location, broker addresses)
• Package-level special services (dangerous goods declarations with hazmat commodity details, alcohol shipment specifications, dry ice handling, battery material declarations)
• Customs clearance structures with commodity breakdowns, harmonized codes, country of manufacture, and duties payment specifications
• Variable handling charges with rate type, percentage values, fixed values, and charge element basis
• Smart Post details for USPS coordination
• Return shipment configurations

Understanding which fields were required, which were optional, how they nested, and what values were valid took significant API documentation review and testing. The other carriers’ APIs were comparatively straightforward—origin, destination, weight, dimensions, and service options.

Error Handling gracefully managed carrier API outages or timeout issues. If a carrier’s API failed, the system displayed quotes from responsive carriers and showed an error indicator for the unavailable one. This ensured users always got actionable quotes rather than encountering a complete system failure when one carrier was down.

SOAP/XML Processing for Pitt Ohio required different parsing logic than the JSON-based REST carriers, but the abstract class pattern isolated this complexity to the carrier-specific implementation.

Results

The impact was immediate and measurable:

Time Savings: Quote generation dropped from 20+ minutes of manual work across five carrier portals to under 60 seconds of automated processing. Sales staff could provide accurate, competitive freight quotes while customers were still on the phone.

Error Elimination: Removing manual data entry across multiple carrier portals eliminated transcription errors in weights, dimensions, addresses, and accessorial selections. Quoted rates matched actual carrier charges.

Sales Team Adoption: The tool received overwhelmingly positive feedback from the sales team. The time savings and accuracy improvements were significant enough that the company later requested a similar integration for full truckload (FTL) carriers.

Quote-to-Order Conversion: Saved quotes converted to orders at a high rate. The ability to retrieve previous quotes from the order management system meant customers could reference earlier pricing discussions without requiring new quotes.

Why This Works

Multi-carrier API orchestration requires understanding that not all APIs are created equal. Building a unified interface means normalizing vastly different authentication schemes, request formats, response structures, and error handling patterns into a consistent user experience.

The abstract class architecture made this manageable. Each carrier’s unique requirements lived in isolated child classes. Common functionality—database access, display formatting, result storage—stayed in the parent. Adding new carriers meant extending the parent class rather than rebuilding the entire system.

Embedding the tool into their existing order management workflow eliminated duplicate data entry and created a seamless user experience. Sales staff didn’t need to learn a separate system or manually transfer order details—the integration pulled everything directly from the order they were already building.

Ready to Integrate Your Systems?

Disconnected carrier portals force manual work that wastes time and introduces errors. Our API Integration Services can unify your shipping, payment processing, CRM, and business systems—giving you a single interface that works the way your team actually operates.

Have a similar integration challenge? Let’s talk.