USPS
Priority Mail Intl
10–15 days$7.40
$1.90 of duties and taxes prepaid, inside the same quoted total
all-in · the quoted total is the wallet debit
The choice is metering versus flat access. ShipEngine bills API usage and grows around connected carrier accounts. GoatLabels' REST API is free to call without limits, signs its webhooks, and buys labels from the same prepaid wallet as the dashboard — four carriers included, no carrier accounts to connect.
USPS, UPS, FedEx, and DHL are quoted on every shipment from our own carrier relationships — no applications, credentials, or carrier invoices on your side.
Card, Apple Pay, Google Pay, ACH, or crypto fund the same prepaid balance behind the API and the dashboard.
ShipEngine prices access the way infrastructure vendors do: usage is the product, so usage is what gets metered. The decode that matters before you integrate is which of your calls the meter can see. A production label integration does far more than buy labels — it quotes at checkout, re-quotes when an address is corrected, validates destinations, polls or receives tracking, and retries everything that times out. Under a metered model, each of those behaviours is a line your plan has an opinion about, and the integration you write starts bending around the meter: you cache rates you would rather re-fetch, batch validations you would rather run inline, and think twice about a health check that costs money.
The second axis is carrier access. ShipEngine grows around carrier accounts you connect — your UPS number, your FedEx credentials — which is a genuine strength at contract-holding scale and a week of paperwork below it. Whether bringing your own carrier accounts beats a shared four-carrier panel is a whole argument of its own, and it is owned by the EasyPost comparison and the carrier-accounts page rather than re-run here.
ShipEngine plan structure — verified against ShipEngine's published pricing and docs on 2026-08-15. As of that date, ShipEngine's published plans meter usage with allowances and paid tiers, and define which operations count against them; the tier names, allowance sizes, and per-unit prices are deliberately not printed here because ShipEngine has repackaged its plans before and will again. Read the current definitions on ShipEngine's own pricing page before you model an integration's cost — including what its meter counts, which is the part that moves most. Re-check cadence: every 6 months, by the named review owner recorded with this page.
The GoatLabels model deletes the meter instead of discounting it. Every API call is free, at any volume, on every plan: create shipments, list rates, validate addresses, read tracking, manage webhooks, and hammer your staging environment without a line item appearing anywhere. The one thing that moves money is a label purchase, and it moves money in the most literal way available — the all-in carrier rate you were quoted is debited from a prepaid wallet, the same wallet the dashboard uses, funded by card, Apple Pay, Google Pay, ACH, or crypto. Your shipping forecast becomes shipments times carrier rate, with no second term for the platform.
That structure changes how you write the integration. Quote-heavy patterns — cart estimates, background re-pricing, a re-quote on every address edit — stop being budget decisions. Retries are safe twice over: free at the request layer, and guarded by real idempotency keys at the purchase layer, so a timed-out buy that runs again returns the original label instead of buying a second one. The wider comparison of metered versus free API surfaces is worked through on the free shipping API page and EasyPost vs a free shipping API; this page's claim is narrower and checkable in an afternoon: nothing you can call at api.goatlabels.io has a price on it except the label.
Webhooks are where label APIs quietly differ most, because they are the part you only evaluate after you have integrated. Every GoatLabels delivery is signed: an X-GoatLabels-Signature header carries a timestamp and an HMAC-SHA256 of the payload computed with your endpoint's secret, so your server verifies the sender instead of trusting it. Every delivery attempt — including each retry — writes its own row to a delivery log you can read back over the API, and any delivery can be replayed against your endpoint, which turns the debugging session every webhook consumer eventually has from guesswork into a diff.
The event most generic comparisons never list is shipment.adjustment.created. When a carrier re-rates a shipment after the fact — a re-weigh, a dimension correction — the adjustment is recorded as its own object, exposed at /v1/adjustments, and pushed to you with the wallet delta attached, so your reconciliation job hears about the correction the moment it exists instead of finding it in a month-end statement. One accuracy note belongs next to that: if an adjustment exceeds the wallet balance, the card on file is charged for the difference. How carriers detect, bill, and let you dispute these corrections is its own page; what this page owns is the fact that your code can subscribe to them.
POST /v1/webhooks
{ "url": "https://example.com/hooks/shipping",
"events": ["shipment.adjustment.created", "shipment.delivered"] }
# each delivery arrives signed:
X-GoatLabels-Signature: t=1755216000,v1=hmac-sha256(secret, "t.body")
# and adjustments are readable as records, not statement lines:
GET /v1/adjustments
{ "object": "list", "data": [ { "shipment_id": "...",
"reason": "carrier_reweigh", "wallet_delta": "-1.42" } ] } Dated sample. Shapes match the OpenAPI 3.1 spec served at /docs, checked 2026-08-15 — the spec is the contract; this block is an illustration of it, not a substitute for it.
The honest concession, in full: ShipEngine's carrier catalogue is far wider than four. If your routing guide includes regional parcel carriers, international postal operators, or LTL freight, GoatLabels cannot quote those lanes — USPS, UPS, FedEx, and DHL are the honest and complete list here. And if your company already holds negotiated contracts that beat any shared panel, an API built to drive your own accounts is the right architecture, and paying its meter is rational. Teams at that scale should stay, and this page will not pretend otherwise.
The team this page is for looks different: the big four cover their lanes, no negotiated contracts exist to bring, and the meter is pure friction — a cost on every quote their integration would prefer to make freely. For that team the evaluation is mechanical rather than rhetorical. Point a copy of your rating step at the API, log both responses for a week, and compare two things: the all-in numbers, and the absence of a usage line on this side of the ledger. The account, the key, and every call in that test are free, so the evaluation costs exactly the labels you choose to buy during it.
A production integration handles the orders that arrive as data. Every shipping operation also has the ones that do not — the support replacement, the DM, the reship a warehouse lead buys from a phone. Both paths end in the same place here: the same shipment objects, the same prepaid wallet, the same signed webhooks. Your code never grows a free-text parser, and your ledger never forks between what the API bought and what a person did.
customer never got #8421 — reship to the same address today
Quoting, re-quoting, validating, and retrying are free at any volume, so the integration can do what the order flow actually needs instead of what a meter makes affordable.
The forecast is shipments times carrier rate, with no second term for the platform. If a carrier re-rates a parcel afterwards, shipment.adjustment.created pushes the correction with the wallet delta attached rather than burying it in a statement.
Shopify, Etsy, WooCommerce, TikTok Shop, Amazon, eBay and the rest sync orders into the same To Ship queue your integration reads, and tracking pushes back to the channel on print — so the marketplace plumbing most teams end up maintaining is not code you own or debug. Paste an Instagram or Facebook DM and Billy produces the same shipment object; that path is not a second API.
Via AItiles: paste a DM or a screenshot — it becomes the same shipment your code already reads.
A metered API teaches you to call it less. An unmetered one lets the code do what the order flow actually needs — quote often, validate everything, retry safely.
Labels bought by your integration and labels bought by a human in the dashboard debit the same prepaid balance, funded by card, Apple Pay, Google Pay, ACH, or crypto. Support reprints and warehouse voids never fork your ledger.
The DM order, the replacement a support agent ships from a phone — Billy drafts those from a pasted message or screenshot, and they land as the same shipment objects your integration reads. Your code never grows a free-text parser.
Shipping cost is shipments times carrier rate — there is no per-call charge, no per-label platform fee, and no tier to outgrow. Pro exists to lower label pricing at volume, which bends the only real cost downward.
Every shipment returns USPS, UPS, FedEx, and DHL as live all-in rates in one response — sort it, pick the winner, buy. No carrier accounts to connect, no credentials to rotate, no separate carrier invoices to reconcile afterwards.
HMAC-signed deliveries, a per-attempt delivery log readable over the API, one-call replay, and the shipment.adjustment.created event pushing post-purchase corrections with the wallet delta attached. Polling is optional; verification is not.


Label bought outside the API
Same wallet · same webhook fires
Every API-driven shipping operation still has humans buying labels — a support agent handling a replacement, a warehouse lead reprinting at the bench, a founder on a Sunday. Those labels debit the same prepaid wallet and become the same shipment records, so nothing in your reconciliation ever has to know which of the two bought them.
Not every question about a parcel deserves a query. Ask where a shipment is and Billy reads the latest scan back in plain English, drafts a replacement from a pasted support thread, and quotes four carriers on it — all against the same records your integration writes and reads. Included on every plan, and none of it billed per call. This is the real product, not a render.

Listening
"What happened to shipment 8421?"
Latest event
Adjustment posted · wallet delta recorded
Speaks plain English · reads shipment records back · drafts labels from a pasted thread · included on every plan, never a pricier tier.
Under a metered model you learn to cache rates you would rather re-fetch. Here every shipment returns USPS, UPS, FedEx, and DHL as live all-in numbers in a single response you can call as often as your checkout wants — sort the array, pick the winner, buy it. The number you sorted on is the number that debits the wallet.
Priority Mail Intl
10–15 days$7.40
$1.90 of duties and taxes prepaid, inside the same quoted total
all-in · the quoted total is the wallet debit
Intl Connect Plus
3–5 days$8.90
$2.20 of duties and taxes prepaid, inside the same quoted total
all-in · the quoted total is the wallet debit
Express Worldwide
1–2 days$9.80
$2.50 of duties and taxes prepaid, inside the same quoted total
all-in · the quoted total is the wallet debit
REST and JSON with one Bearer header. Create the shipment, read four carriers from the rates array, buy the winner from the wallet — and let signed webhooks carry tracking and adjustments back instead of polling for them.
POST /api/v1/shipments
Authorization: Bearer sk_live_…
Idempotency-Key: ord_8421
{
"to": { "name": "Joyce", "city": "Berlin", "country": "DE" },
"parcel": { "weight": 2.6, "weight_unit": "lb" },
"service": "fedex_intl_priority"
}
A metered API turns cost modelling into a guess about which of your calls the meter counts. Here the model has one term: shipments times carrier rate. Free covers 50 shipments a month with unlimited API calls behind it, and Pro is a flat plan that lowers per-label pricing at volume — bending the only real cost downward rather than adding a second one beside it.
Volume pricing
illustrativemore volume → lower per-label rates
$0 / forever
A free key, unlimited calls, and a staging environment nobody has to budget for.
The assistant that drafts a shipment from a pasted support thread runs unlimited in the web app on Free, writing the same objects your code reads. Pro adds Billy on Telegram.
GET /api/v1/shipments
200 OK · plan: free
Unlimited calls on Free — still unlimited on Pro.
Bring your invoice — on Pro we work with you to beat the rates you're getting from
ShippoPirateShipShipStationLabels are quoted live from USPS, UPS, FedEx, and DHL as one all-in number and debited from the prepaid wallet at exactly that amount. ShipEngine's plans are ShipEngine's to set and repackage — the dated block above says only that they meter usage, and their pricing page is the source of truth. Full pricing details
A usage price does not fall evenly across integrations. These are the four shapes where quoting freely is the difference between a correct implementation and a cheap one.
Cart estimates and address edits
Cart estimates, a re-quote on every corrected address, background re-pricing — the calls that make a checkout accurate are exactly the ones a meter teaches you to skip. Unlimited calls means the rating step runs whenever the order changes rather than whenever the budget allows.

Finance, month end, and re-weighs
A re-weigh discovered at month end is a reconciliation problem. The same re-weigh pushed as an event with the wallet delta attached is a row your job already knows how to handle. Adjustments are records here, exposed at /v1/adjustments and delivered as shipment.adjustment.created.
Corrections as first-class objects
Read them over the API, not off a statement
The orders your integration never sees
Where deliveries get debugged
1
signed delivery log per attempt, readable over the API and replayable
ShipEngine is a trademark of its owner and is not affiliated with GoatLabels; its current plans and carrier catalogue live on its own site. More for API teams: GoatLabels vs EasyPost, the Shippo API comparison, and what a free shipping API includes.
A video took off and I had 80 TikTok Shop orders by morning. I printed every label from my phone on the bus to the post office.
Early customer · TikTok
TikTok Shop seller
I run my Etsy shop from the kitchen. The AI reads the order, picks the carrier, the label prints. That's the whole workflow now.
Early customer · Etsy
Etsy maker
The API is what every shipping API pretends to be. Idempotency that actually works.
Sasha R.
Staff engineer, marketplace
A free key, unlimited calls, and four carriers in every rates array. Run it beside ShipEngine for a week and let the two ledgers argue it out.
Sign up in seconds. No card required. Unlimited calls on every plan.