Every freight broker already takes money somehow. Shippers pay invoices by ACH, wire, check, or a card on a portal. Those rails work. They moved trillions of dollars of goods long before anyone talked about AI agents. So when Nettrux says it is the first 3PL on x402, a fair question from a shipping manager or a CFO is: why add another payment rail at all?
The short answer is that the buyer is changing. Card and ACH flows assume a person is somewhere in the loop at the moment of payment: typing a number into a form, clicking a 3-D Secure prompt, uploading a remittance file, or approving a batch in a bank portal. An AI agent that is shopping freight for a shipper doesn't have hands, a browser session it should be trusted with, or a seat in the accounts payable team. It has HTTP. x402 puts the payment conversation in the place the agent already lives.
This piece compares the three rails from the point of view of a software buyer, not a human one, and explains what Nettrux's published agent flow actually does today.
What each rail assumes about the buyer
Card payments assume a cardholder. The whole stack (checkout pages, fraud scoring, step-up authentication, chargebacks) is designed around a human who can prove they're the cardholder and dispute a charge later. Handing a card number to an agent means giving it a reusable credential with a broad spending limit, then hoping nothing goes wrong. The basic shape is still a checkout built for people.
ACH assumes an accounting process. Payments are batched, settle on a delay measured in business days, and get matched to invoices by remittance data that often arrives separately. That suits net-30 freight billing. It doesn't suit an agent that needs to know, inside a single request, whether a booking went through.
x402 assumes a client program. A server answers a request with HTTP 402 Payment Required and a machine-readable description of what it will accept: asset, network, amount, and where to pay. The client builds a signed payment, retries the same request with an X-PAYMENT header, and the server verifies and settles before it delivers the resource. No form, no redirect, no batch file. The terms of the sale travel inside the HTTP response.
None of this makes cards or ACH obsolete for freight. It means they answer a different question. They're good at "how does a company pay its broker?" x402 is aimed at "how does a piece of software commit to one specific purchase, at one specific price, right now?"
Why freight makes the difference sharper
For a fixed-price digital good, the gap between rails is mostly convenience. For freight it's structural, because the price moves and the purchase is a commitment of physical capacity.
Consider what an agent needs to get right when it books one pallet from Fremont to Reno:
- The price it pays must match the price it was quoted. A rate that was good an hour ago may not be good now.
- One payment must equal one shipment. If the agent times out and retries, it must not book twice.
- The result must be readable by software. The agent has to know whether it has a booking, not wait for an email.
A card checkout handles the first point only if a human compares numbers on a screen. ACH handles none of them in real time. x402 can handle all three when the seller designs the route carefully, because the challenge, the payment, and the booking are the same HTTP exchange.
How Nettrux wires it up
The Nettrux agent guide and the OpenAPI it links describe the sequence. In outline:
-
Shop.
POST /v1/rates/shopreturns ranked options, cheapest first. It doesn't reserve anything. -
Lock.
POST /v1/quoteswithquoteNumber,validUntilandrateInputreturns a quote id and a locked total. The lock is idempotent on the quote number, so a retry doesn't create a second quote. -
Commit.
POST /v1/immediate-bookings/commitwith a body of exactly{ quote_id }and no payment header. The OpenAPI documents this call as an x402 v1 HTTP 402 challenge. The guide notes that the published response schema is HTTP 200, so a client should handle both. -
Pay and book. The client retries the same request with an
X-PAYMENTheader built from the challenge. The documented sequence is verify, then settle, then book. -
Read the receipt.
GET /v1/immediate-bookings/{booking_id}returns the booking and its settlement projection, includingmoney_mode.
Compare that with a card flow. There's no step where the agent holds a card number, no hosted page to scrape, and no human prompt in the middle of the request. The amount comes from the locked quote, the payment is built from the challenge the server issued, and the single-field commit body leaves no room to slip a different price or a second shipment into the request.
Where humans still sit
"Agent pays" doesn't mean "nobody is watching." Agent payments go wrong when the software can spend without limits, and that's a problem on every rail.
On the Nettrux side, the commit route needs a bearer token the agent already holds. The site doesn't issue tokens or describe a signup for them, so access starts with a business relationship, not an anonymous wallet. Nettrux's factoring rail is separate from the x402 path and still requires a named human before a mint. On the shipper side, an agent's wallet can be funded with a set budget and given spending rules, which is a tighter control than a corporate card that works anywhere.
That's the practical case for x402 in freight. It doesn't remove people from the process. It moves their decisions to the places where they matter: who gets a token, how much the agent can spend, and which lanes it may book. It takes them out of the parts that are just retyping numbers.
Where things stand today
Being precise matters here, because payment claims are easy to overstate.
- Nettrux is the first 3PL on x402: its freight API documents an x402 v1 commit route for booking a price-locked quote.
- Nettrux has settled a real x402 USDC payment on Base in testing.
- The agent guide publishes its deploy gates openly. Real-money settlement over x402 is not switched on, guest checkout is not enabled, and the freight API host's own x402 discovery document is not published yet. The site's
/.well-known/x402is a pointer to the API host. - Live modes on the network are LTL, FTL and air. Ocean is in build.
So an agent developer can read the full contract today and build against it. A shipper can talk to Nettrux about how agent-booked freight would fit their approval rules. Nobody should treat this as a public pay-and-book endpoint yet, and Nettrux doesn't describe it as one.
A quick comparison
| Card | ACH | x402 | |
|---|---|---|---|
| Designed for | A person at checkout | An AP team with batches | A client program over HTTP |
| Price in the request | Shown on a page | On an invoice | In the 402 challenge |
| Retry safety | Depends on the merchant | Manual matching | Idempotent quote lock plus single-field commit (Nettrux) |
| Result an agent can read | Usually a redirect or email | Days later | The HTTP response |
| Credential exposure | Reusable card number | Bank details | A signed payment for one request |
FAQ
Does Nettrux take card payments from agents?
No. The agent flow described here is x402 only.
Is x402 replacing invoices for existing customers?
No. Shippers who pay by invoice today keep doing so. x402 is a path built for software buyers.
Can I call the commit route right now?
Only with a bearer token Nettrux has issued, and real-money settlement is not live. Start with the agent guide and the OpenAPI.
Who do I talk to?
Dispatch answers at 1-888-617-3530, and the site is nettrux.ai.
Alex Carney, Nettrux
Top comments (0)