There is a line item hiding in almost every serious shipper’s FedEx and UPS invoices that the carriers agreed in writing to pay back and almost nobody collects. It works like this: you pay a premium for a guaranteed service, the carrier publishes a commitment time, and if the package misses that commitment — even by sixty seconds — the carrier owes you a refund of the transportation charges. That is not a promotion or a goodwill gesture. It is written into the service guide, and the carrier only pays it if someone asks within a brutally short window.
Almost nobody asks. Refund-recovery vendor 71lbs pegs the unclaimed total at $2 billion a year in the US alone. Even among shippers who run audit software, LateShipment.com’s own 2025 data shows only 71.53% of refund-eligible opportunities they identified ever got submitted — the other 28% expired. The dead weight is the filing process: manual checking, invoice-by-invoice, against rules that changed twice in the last three months.
That gap is a contract-enforcement trade, not a scheme. You are not exploiting anyone; you are making a duopoly honor its own tariff. Below: the exact 2026 rulebook (it is narrower than almost every guide still ranking on Google says), the real numbers on how often guaranteed services miss, and a tested Python desk that audits a shipment manifest against live carrier data and outputs a claims file before the 15-day clocks expire.
The 2026 rulebook: much narrower than the internet thinks
Both carriers gutted their money-back guarantees during the pandemic and have quietly reinstated them for only a slice of their product lines. If you audit against an old blog post, you will file claims for services that no longer carry any guarantee — and every one of those is a free rejection for the carrier.
FedEx suspended the Money-Back Guarantee on December 1, 2025, then reinstated it in two steps: domestic services on January 13, 2026, and international services on February 12, 2026, per the Service Guide effective February 12, 2026. The currently covered list:
| FedEx service | Guarantee status (Feb 2026) |
|---|---|
| First Overnight, Priority Overnight, Standard Overnight | Guaranteed |
| 2Day A.M. | Guaranteed |
| Overnight/2Day A.M. Extra Hours (contract services) | Guaranteed |
| International First, International Priority, International Priority Express | Guaranteed |
| International Priority Freight, International Priority DirectDistribution (+Freight) | Guaranteed |
| Ground, Home Delivery, Express Saver, 2Day, and everything else | Suspended |
UPS never fully restored its Service Guarantee either. Per UPS’s published terms (re-verified against them by ShipKeep in September 2026), the guaranteed list is:
| UPS service | Guarantee status | Catch |
|---|---|---|
| Next Day Air Early | Guaranteed | — |
| Next Day Air | Guaranteed | Residential deliveries committed at 10:30 a.m. are judged against 12:00 p.m. |
| Next Day Air Saver | Guaranteed | Guaranteed time currently extended to end of day (11:59 p.m.) |
| 2nd Day Air A.M. | Guaranteed | Commercial deliveries only — residential is excluded by name in the tariff |
| Worldwide Express family | Guaranteed | — |
| Ground, 2nd Day Air, 3 Day Select, Worldwide Expedited | Suspended | — |
These details are where naive audits die. A residential 2nd Day Air A.M. package delivered at 10:29 a.m. is not claimable — the service is guaranteed, but residential deliveries on it are excluded. A Next Day Air Saver package delivered at 11:58 p.m. is on time until further notice, whatever the marketing brochure says about afternoon commitments.
And the payoff side is generous: the guarantee pays even for 60-second misses, and an approved claim refunds the transportation charges for that shipment — the full freight amount, not a partial credit.
One more trap: most shippers’ gut feeling about “late packages” is built on Ground and 2Day volume, which are exactly the services with no guarantee right now. The desk’s first job is killing false hope before you waste hours filing dead claims.
The numbers: how much actually leaks
Verified figures, not forum folklore:
- Delay rates on guaranteed-adjacent services are high. LateShipment.com’s analysis of millions of tracked US e-commerce packages found FedEx 2Day ran an 8.93% delay rate in the 2025 regular operating period (9.87% in the 2024 holiday period), and FedEx Overnight ran 8.12% (8.67% holiday). Overnight is where the guarantee lives, so a high single-digit miss rate on the refundable slice is the base rate you are working with.
- Audit programs recover 1.5–3% of total parcel spend. That is ShipScience’s 2026 figure for what a well-run FedEx audit recovers in combined refunds and savings, and it includes a second layer beyond late deliveries: billing errors like duplicate charges, address-correction fees, and dim-weight re-rates.
- The unclaimed pool is real but driven by process failure. The 71.53% submission rate above means even software-assisted shippers leave roughly 28% of identified refunds unfiled — the clock is the killer, not the detection.
Worked example, explicitly arithmetic and not a promise: a brand spending $2,500/month on parcel, with 40% of that on guaranteed overnight services, moves about $12,000/year through refundable services. At an 8% miss rate that is roughly $960/year in late-delivery refunds on the guaranteed slice alone, before the billing-error layer that pushes the total toward the 1.5–3% of the full $30,000 spend — call it $450–$900/year self-recovered for a brand that size, $750–$1,100/year for one spending twice that. Small per brand. The trade gets interesting when you stack brands, which is where this goes later.
Why the desk has to be automated: two different 15-day clocks
The filing windows are the whole game:
- FedEx: refund requests must be received within 15 calendar days of the invoice date — or 15 days from the ship date if you paid by credit card or prepaid in cash/check/money order. Not from the delivery date. If you anchor the clock wrong, you file dead claims or let live ones rot.
- UPS: 15 calendar days from the delivery date for late-delivery claims.
Nobody reads invoices weekly. A package delivered late on the 1st is unclaimable by the 16th, and the refund is gone permanently — no appeal, no grace period. That is why manual audits cap out and why the vendors charge a recurring cut: their entire product is a clock plus a rules table. Both fit in a script.
The desk: a manifest in, a claims file out
The architecture is boring on purpose:
- A CSV manifest of shipments — tracking number, carrier, service code, destination type, dates, net charge. You generate this from order confirmations or invoice exports.
- An eligibility engine that encodes the guarantee tables above, including the carrier’s own adjusted commitment rules (residential +90 minutes, Saver-at-midnight, 2AM-residential exclusion).
- The carrier tracking API to pull the actual delivery scan.
- A claims CSV with one verdict per row:
FILE NOW(window closing within 3 days),FILE,OK(on time),SKIP(no guarantee / exception scan / not delivered yet), andLEAK— a late shipment whose window already closed. That last verdict is your ROI receipt: it shows exactly how much money burned while nobody was auditing.
Here is the full script. It is tested end-to-end against a 7-shipment fixture — tested with mocked carrier tracking APIs (the mock returns realistic delivery scans and statuses). The live path is the same code with your real credentials: export UPS_CLIENT_ID, UPS_CLIENT_SECRET, FEDEX_API_KEY, and FEDEX_SECRET_KEY, drop the --mock flag, and it calls the official UPS and FedEx tracking APIs. Without credentials set, every row comes back as ERROR naming the missing variable — it does not crash mid-run.
#!/usr/bin/env python3
"""LateRefundDesk - audit UPS/FedEx shipments for money-back-guarantee refunds.
Reads a CSV manifest of your shipments, checks each one against the CURRENT
guarantee rules (which services still carry a money-back guarantee, and the
carrier's own adjusted commitment rules), pulls the delivery scan from the
carrier tracking API, and emits a claims file you can file with.
Free usage: python3 audit_late_refunds.py manifest.csv --mock
Real usage: export UPS_CLIENT_ID=... UPS_CLIENT_SECRET=... FEDEX_API_KEY=... FEDEX_SECRET_KEY=...
python3 audit_late_refunds.py manifest.csv
"""
import argparse, base64, csv, json, os, sys, time
import urllib.request, urllib.error, urllib.parse
from datetime import date, datetime, timedelta
FEDEX_GUARANTEED = { # FedEx Service Guide eff. 2026-02-12 (MBG reinstated 2026-01-13/02-12)
"PO": ("FedEx Priority Overnight", "10:30"),
"SO": ("FedEx Standard Overnight", "10:30"),
"FO": ("FedEx First Overnight", "08:00"),
"2AM": ("FedEx 2Day A.M.", "10:30"),
"INP": ("FedEx Intl Priority", "10:30"),
}
UPS_GUARANTEED = { # UPS Service Guarantee - still-guaranteed list (everything else suspended)
"NDE": ("UPS Next Day Air Early", "08:30", "any"),
"NDA": ("UPS Next Day Air", "10:30", "res=12:00"), # residential gets +90 min
"SAV": ("UPS Next Day Air Saver", "23:59", "any"), # EOD rule until further notice
"2AM": ("UPS 2nd Day Air A.M.", "10:30", "com_only"), # residential = excluded entirely
}
EXCLUDED_SERVICES = {"FDXG", " FedEx Ground", "FedEx Ground", "FedEx Home Delivery",
"UPSG", "UPS Ground", "UPS 2nd Day Air", "UPS 3 Day Select",
"UPS Worldwide Expedited", "FedEx Express Saver", "2DAY"}
WINDOW_DAYS = 15 # FedEx: invoice date +15d | UPS: delivery date +15d
EXCEPTION_WORDS = ("exception", "weather", "delay - severe", "hurricane", "fire",
"civil", "embargo", "suspension", "returned to sender")
def http_json(url, data=None, headers=None, method=None, tries=3):
body = urllib.parse.urlencode(data).encode() if isinstance(data, dict) else data
for attempt in range(tries):
try:
req = urllib.request.Request(url, data=body, headers=headers or {}, method=method)
with urllib.request.urlopen(req, timeout=25) as r:
return json.loads(r.read().decode())
except urllib.error.HTTPError as e:
if e.code in (429, 500, 502, 503, 504) and attempt < tries - 1:
time.sleep(2 * (attempt + 1)); continue
raise RuntimeError(f"HTTP {e.code}: {e.read()[:200].decode(errors='replace')}")
except (urllib.error.URLError, TimeoutError) as e:
if attempt < tries - 1: time.sleep(2 * (attempt + 1)); continue
raise RuntimeError(f"network: {e}")
def ups_token():
basic = base64.b64encode(f"{os.environ['UPS_CLIENT_ID']}:{os.environ['UPS_CLIENT_SECRET']}".encode()).decode()
tok = http_json("https://onlinetools.ups.com/security/v1/oauth/token",
data={"grant_type": "client_credentials"},
headers={"Authorization": f"Basic {basic}",
"Content-Type": "application/x-www-form-urlencoded"})
return tok["access_token"]
def fedex_token():
basic = base64.b64encode(f"{os.environ['FEDEX_API_KEY']}:{os.environ['FEDEX_SECRET_KEY']}".encode()).decode()
tok = http_json("https://apis.fedex.com/oauth/token", data={"grant_type": "client_credentials"},
headers={"Authorization": f"Basic {basic}",
"Content-Type": "application/x-www-form-urlencoded"})
return tok["access_token"]
def fetch_tracking(carrier, tracking):
"""Return (delivered_datetime|None, last_status_text). Raises RuntimeError on API failure."""
if carrier == "UPS":
tok = ups_token()
d = http_json(f"https://onlinetools.ups.com/track/v1/details/{tracking}?locale=en_US",
headers={"Authorization": f"Bearer {tok}", "Accept": "application/json"})
pkg = d["trackResponse"][0]["package"][0]
delivered, last_txt = None, pkg.get("service", {}).get("description", "?")
for act in pkg.get("activity", []):
st = act.get("status", {})
if st.get("type") == "D": # D = Delivered
delivered = datetime.strptime(act["date"] + act["time"], "%Y%m%d%H%M%S")
txt = " ".join(filter(None, [st.get("description", ""), st.get("code", "")]))
if txt and txt != "?": last_txt = txt
return delivered, last_txt
tok = fedex_token()
d = http_json("https://apis.fedex.com/track/v1/shipments", method="POST",
data=json.dumps({"trackInfo": [{"trackNumberIdentifier": tracking}],
"includeDetailedScans": True}).encode(),
headers={"Authorization": f"Bearer {tok}", "Content-Type": "application/json"})
res = d["output"]["completeTrackResults"][0]["trackResults"][0]
delivered, last_txt = None, res.get("latestStatusDetail", {}).get("description", "?")
ts = res.get("deliveryTimestamp") or res.get("estimatedDeliveryTimestamp")
if res.get("latestStatusDetail", {}).get("code", "") == "DL" and ts:
delivered = datetime.fromisoformat(ts.replace("Z", "+00:00")).replace(tzinfo=None)
return delivered, last_txt
def commitment_for(carrier, code, dest):
if carrier == "FEDEX":
if code not in FEDEX_GUARANTEED: return None, "excluded"
name, t = FEDEX_GUARANTEED[code]
return datetime.strptime(t, "%H:%M").time(), name
if code not in UPS_GUARANTEED: return None, "excluded"
name, t, scope = UPS_GUARANTEED[code]
if scope == "com_only" and dest.lower().startswith("res"):
return None, "excluded: residential not guaranteed on 2AM"
if scope.startswith("res") and dest.lower().startswith("res"):
t = t if code != "NDA" else "12:00" # UPS: NDA residential judged vs 12:00
return datetime.strptime(t, "%H:%M").time(), name
def evaluate(row, delivered, status_text):
low = (status_text or "").lower()
if any(w in low for w in EXCEPTION_WORDS):
return "SKIP", "service exception on scan - check carrier exclusion list first", 0.0
commit_time, name = commitment_for(row["carrier"], row["service_code"], row.get("dest_type", "res"))
if commit_time is None:
return "SKIP", f"{name} - service carries no money-back guarantee right now", 0.0
if delivered is None:
return "SKIP", "no delivery scan yet - not late-checkable", 0.0
commit_dt = datetime.combine(delivered.date(), commit_time)
if delivered <= commit_dt:
return "OK", f"on time ({name}, commit {commit_time})", 0.0
late_by = delivered - commit_dt
anchor = row.get("invoice_date") or "" if row["carrier"] == "FEDEX" else delivered.date().isoformat()
if row["carrier"] == "FEDEX" and not anchor:
anchor = row["ship_date"]; note = " (ship-date fallback - find invoice date!)"
else: note = ""
deadline = date.fromisoformat(anchor) + timedelta(days=WINDOW_DAYS)
refund = float(row.get("net_charge") or 0)
if date.today() > deadline:
return "LEAK", (f"LATE {late_by} but window closed {deadline} - money you already lost" + note), 0.0
due_in = (deadline - date.today()).days
tag = "FILE NOW" if due_in <= 3 else "FILE"
return tag, (f"late by {late_by} on {name}; {row['carrier']} window ends {deadline} ({due_in}d left)" + note), refund
def main():
ap = argparse.ArgumentParser()
ap.add_argument("manifest"); ap.add_argument("--mock", action="store_true")
args = ap.parse_args()
mock = {}
if args.mock:
with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "mock_tracking.json")) as f:
mock = json.load(f)
rows = list(csv.DictReader(open(args.manifest)))
out, tally = [], {}
for row in rows:
try:
if args.mock:
ev = mock[row["tracking"]]
delivered = datetime.fromisoformat(ev["delivered"]) if ev.get("delivered") else None
status = ev["status"]
else:
delivered, status = fetch_tracking(row["carrier"], row["tracking"])
verdict, why, refund = evaluate(row, delivered, status)
except (RuntimeError, KeyError, ValueError) as e:
verdict, why, refund = "ERROR", f"api/parse: {e} - retry tomorrow", 0.0
tally.setdefault(verdict, [0, 0.0]); tally[verdict][0] += 1; tally[verdict][1] += refund
out.append({**row, "verdict": verdict, "detail": why, "est_refund_usd": f"{refund:.2f}"})
fn = os.path.splitext(args.manifest)[0]
with open(f"{fn}_claims.csv", "w", newline="") as f:
w = csv.DictWriter(f, fieldnames=list(out[0].keys())); w.writeheader(); w.writerows(out)
print(f"audited {len(rows)} shipments")
for k in ("FILE NOW", "FILE", "OK", "SKIP", "LEAK", "ERROR"):
tally.setdefault(k, [0, 0.0])
print(f" {k:9s} {tally[k][0]:3d} est refund ${tally[k][1]:,.2f}")
print(f"-> claims file: {fn}_claims.csv")
if __name__ == "__main__":
sys.exit(main())
Run it against the fixture in the article’s repo context and you get:
audited 7 shipments
FILE NOW 1 est refund $24.50
FILE 1 est refund $42.10
OK 2 est refund $0.00
SKIP 3 est refund $0.00
LEAK 0 est refund $0.00
ERROR 0 est refund $0.00
-> claims file: manifest_claims.csv
Three honesty notes about the tables inside the script. First, they are data, not law: they reflect the FedEx Service Guide effective February 12, 2026 and UPS’s published guarantee list as re-verified in September 2026 — both carriers change these “until further notice,” so re-check the current service guide monthly (the script’s SKIP verdicts fail safe: it never files for a service it is unsure about). Second, commitment times vary by lane and contract — the script ships with the standard published commitments; if you have negotiated custom commitments, put your own in. Third, service codes come from your invoices (PO, SO, NDA, SAV, etc. are the standard codes); map your own exports before the first run.
Filing: where the claims go
The desk produces the ammunition; filing is still a human-scale step per claim, but batchable:
- FedEx: file through FedEx Billing Online (dispute by invoice or shipment), the billing section of fedex.com, or the phone invoice-adjustment system at 1-800-463-3339 (say “billing”). You need the tracking number, service, and the late scan times — all of which the claims CSV contains. An approved refund posts as a credit against the invoice the shipment was billed on.
- UPS: use the claim web experience at ups.com. On invoiced accounts, your billing-center profile has to be current or the refund has nowhere to land — UPS reverses approved service-failure refunds to the original payment vehicle. There is a guest-claims path at
ups.com/guestclaims/createfor one-off filings.
The volume math is what makes this a desk instead of a chore: at the verified ~8–9% miss rate on express services, a shipper moving 200 guaranteed-service packages a month generates roughly 16–18 claims a month. As raw CSV rows, that is an afternoon of filing — provided nothing expired first, which is the desk’s actual job.
Turning it into income: your margin first, then the stack
Two layers, in order:
Layer 1 — your own shipping. If you run an e-commerce operation spending five figures a month on parcel, the 1.5–3% recovery band is pure margin restoration: $30,000/month of spend puts $5,400–$10,800/year back on the table by ShipScience’s band. This is the no-distribution-needed core of the trade.
Layer 2 — contingency recovery for brands that will never audit themselves. Small Shopify brands do not read invoices; that is a measurable, data-first pitch, not a “let me automate your boring tasks” pitch. You run their last 90 days of tracking numbers through the desk, then open with: “I found $1,847 in expired refunds you already lost, and $612 still inside the window on live shipments.” The incumbent recovery software takes a percentage cut of every refund it recovers, so there is an established price anchor to undercut at 25–40% contingency. Ten small brands at $50,000/year parcel spend each, audited at 2%, is ~$10,000/year recovered across the book — call it $2,500–$4,000/year to you at a 30% split, stacking on top of Layer 1. It compounds by accounts, not by hours, and the desk does the per-account labor.
One compliance line you cannot skip: get the contingency agreement in writing, only ever file claims for shipments the client actually paid for, and never file a claim you know is false — a late-refund claim on a service that was on time is fraud, full stop. Carriers can and do restrict accounts that file at suspicious rates or exist only to file claims, so run the desk against accounts with genuine shipping volume, which is what this whole setup assumes anyway.
The honest fine print
- Exclusion events kill claims. Severe weather, natural disasters, and other service exceptions void the guarantee — the script detects exception scans and issues
SKIPinstead of a doomedFILE, but carrier-side rejections still happen on ambiguous scans. Expect some rejection noise; it is a percentage game. - The guarantee lists move. FedEx suspended on December 1, 2025 and restored in two steps eight weeks apart. UPS’s list is “until further notice.” The dated tables in the script are the discipline: re-verify monthly, or your
FILEverdicts rot into rejections. - Anchor the FedEx clock to the invoice date, not the ship date, unless the account prepaid — the 15-day window on an invoiced account starts when the invoice is issued.
- Market validation is real: LateShipment.com, 71lbs, ShipScience, and freight-audit shops all monetize this exact mechanism, several on contingency — you are not inventing demand, you are skipping their fee.
- Nothing here is criminal or ToS-gray in the filing itself — the money is contractually owed. The gray-adjacent part is only the contingency client-acquisition angle, which is a standard recovery-audit arrangement that has existed in freight for decades.
The window on any given refund is 15 days from an invoice or delivery date. Every day the desk does not run is a LEAK row slowly accruing. Build it, point it at a manifest, and let the carriers’ own tariff do the selling.
Further reading on the same playbooks: the Amazon FBA reimbursement scanner (same audit-the-giant pattern, different ledger) and the class-action settlement claims stack (unclaimed money, deadline-driven, scriptable the same way).