Every week, Amazon’s fulfillment network quietly misplaces, crushes, and loses third-party inventory. Most of those units trigger an automatic reimbursement. Some don’t. And since Amazon tightened its claim windows to as little as 60 days, every unclaimed discrepancy is money that evaporates on a deadline you can’t see in the Seller Central dashboard.

Third-party recovery services exist for exactly this reason — GETIDA, the most visible one, charges a 25% commission on every successful recovery, per its own published pricing. That’s the market telling you something: the underlying claim is yours, the data is yours, and the work is mostly a reconciliation problem. A script can do the reconciliation. You file the claims. You keep 100%.

This article walks through a working Python scanner that cross-references your FBA inventory adjustments against reimbursement payouts, nets out units Amazon already found again or paid for, and prints a ranked backlog of open claims with live countdowns to each deadline.

Why there’s money on the table

FBA moves billions of units through dozens of fulfillment centers. At that scale, discrepancy events are routine: a pallet gets miscounted on inbound receiving, a unit is marked damaged during warehouse handling, a customer return never actually arrives back, a removal order leaves the FC and vanishes in transit. Amazon’s policy is to reimburse eligible losses — but the eligibility rules changed in ways that make silent losses far more common:

The March 2025 valuation change. Amazon shifted reimbursement for lost and damaged FBA inventory from an estimated sale price model to a manufacturing-cost basis. If you never told Amazon your sourcing cost, it reimburses at its own (often low) estimate — or you dispute it with invoices. Either way, the onus of proving value moved onto you.

The shortened claim windows. This is the part that turns small losses into dead money. Amazon’s Seller Central policy and forum announcements lay out the clocks: inventory misplaced at a fulfillment center must be claimed within 60 calendar days of the unit being marked “Lost” in the Inventory Adjustment report; items lost in transit on inbound shipments carry a 75-day window from shipment creation; carrier-damaged customer returns give you 45 days. Miss the window and the claim is simply dead — no appeal path for lateness.

Auto-found netting. Sometimes Amazon finds a “lost” unit a week later and quietly re-adds it to sellable inventory. A naive scanner that flags every LOST row will file claims for units that were found again — which is exactly the kind of noise that gets sellers’ cases rejected and their account flagged for abusive claiming. Your reconciliation has to net LOST against FOUND per SKU before anything else.

Put together: Amazon has the data, you have the deadline, and the intersection is a spreadsheet problem most sellers never do because it’s tedious and time-boxed. That’s precisely the shape of problem worth scripting.

The math that justifies the effort

Say your scanner surfaces $2,000 of legitimate open claims across a year — modest for any account doing five figures monthly in FBA volume. Route it through a 25%-commission service and you pocket $1,500. Run the reconciliation yourself and the delta is a few hours of setup plus maybe ten minutes a week of reviewing the output. Once the script exists, the marginal cost of every future claim is a copy-paste into Seller Central’s reimbursement case flow.

The scanner below is deliberately boring technology: three CSVs in, one ranked backlog out. No API keys, no paid dependencies, nothing to break. You export the reports on a schedule, run the script, act on the output.

The data: three reports you already have access to

Everything comes from standard Seller Central flat-file reports:

  1. Inventory Adjustment / ledger events — every LOST, DAMAGED, and FOUND event per FNSKU with dates and quantities.
  2. Reimbursements report — every payout Amazon already made, with amounts and reason codes.
  3. Your unit costs — a two-column file you maintain yourself (FNSKU + landed manufacturing cost). This is also what you’d use to dispute Amazon’s lowball manufacturing-cost estimates after the 2025 policy change, so build it once and keep it fresh.

The scanner

This is the exact script I tested locally (on a synthetic ledger covering all the tricky cases: found-later netting, partial payouts, and a window already closed). It’s stdlib-only Python 3 — no pip installs.

#!/usr/bin/env python3
"""
FBA Reimbursement Claim Scanner
Reconciles the FBA Inventory Ledger (adjustments) against reimbursement
payouts to find units Amazon lost/damaged but never paid you back for,
with the 60-day claim deadline per claim type already computed.

Input CSVs (Seller Central flat-file reports, UTF-8):
  1) inventory_adjustments.csv  date,fnsku,msku,disposition,quantity
     disposition: LOST | DAMAGED | DAMAGED_BY_AMAZON | FOUND
  2) reimbursements.csv         posted_date,fnsku,amount_usd,reason
  3) unit_costs.csv             fnsku,unit_cost_usd

Output: claims_backlog.csv + console summary.
"""
import csv
import sys
from datetime import date, datetime, timedelta
from pathlib import Path

CLAIM_WINDOWS = {          # calendar days from the adjustment/ledger date
    "MISPLACED_WAREHOUSE": 60,   # unit marked Lost in Inventory Adjustment report
    "DAMAGED_WAREHOUSE":   60,
    "LOST_IN_TRANSIT":     75,   # from inbound shipment creation date
    "CARRIER_DAMAGED_RET": 45,   # carrier-damaged customer return
}

def parse_date(s: str) -> date:
    return datetime.strptime(s.strip()[:10], "%Y-%m-%d").date()

def load_adjustments(path):
    """Net lost/damaged vs. auto-FOUND units per FNSKU.

    Found-later events can arrive on a different date than the loss, so
    netting MUST happen at FNSKU level. We keep the EARLIEST adjustment
    date per FNSKU as the claim clock start (conservative on deadlines).
    """
    net = {}   # fnsku -> {"units": int, "first_date": date}
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            disp = row["disposition"].strip().upper()
            if disp not in {"LOST", "DAMAGED", "DAMAGED_BY_AMAZON", "FOUND"}:
                continue
            fnsku = row["fnsku"].strip()
            d = parse_date(row["date"])
            signed = int(row["quantity"]) * (-1 if disp == "FOUND" else 1)
            agg = net.setdefault(fnsku, {"units": 0, "first_date": d})
            agg["units"] += signed
            agg["first_date"] = min(agg["first_date"], d)
    # (fnsku, first_adjustment_date) -> net units still owed
    return {(f, a["first_date"]): a["units"] for f, a in net.items() if a["units"] > 0}

def load_reimbursements(path):
    """Total USD Amazon already paid out per FNSKU (any reason)."""
    paid = {}
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            fnsku = row["fnsku"].strip()
            paid[fnsku] = paid.get(fnsku, 0.0) + float(row["amount_usd"])
    return paid

def load_costs(path):
    with open(path, newline="", encoding="utf-8") as f:
        return {r["fnsku"].strip(): float(r["unit_cost_usd"]) for r in csv.DictReader(f)}

def build_claims(adjustments, paid, costs, today):
    claims, expired = [], 0.0
    for (fnsku, adj_date), qty in sorted(adjustments.items(), key=lambda x: x[0][1]):
        cost = costs.get(fnsku)
        if cost is None:
            print(f"WARN no unit cost for {fnsku}, skipping (add to unit_costs.csv)", file=sys.stderr)
            continue
        owed = qty * cost
        already = paid.get(fnsku, 0.0)
        if already >= owed:
            continue                          # fully reimbursed already
        outstanding = round(owed - already, 2)
        claim_type = "MISPLACED_WAREHOUSE"    # default bucket for ledger LOST/DAMAGED
        deadline = adj_date + timedelta(days=CLAIM_WINDOWS[claim_type])
        if deadline < today:
            expired += outstanding
            status = "WINDOW_CLOSED"
        else:
            status = "FILE_NOW"
        claims.append({
            "fnsku": fnsku, "adjustment_date": adj_date.isoformat(),
            "net_units_owed": qty, "claim_type": claim_type,
            "outstanding_usd": outstanding,
            "deadline": deadline.isoformat(), "days_left": (deadline - today).days,
            "status": status,
        })
    return claims, expired

def main():
    base = Path(__file__).parent
    today = date.today()                      # or pin a date for backtesting
    adjustments = load_adjustments(base / "inventory_adjustments.csv")
    paid = load_reimbursements(base / "reimbursements.csv")
    costs = load_costs(base / "unit_costs.csv")
    claims, expired = build_claims(adjustments, paid, costs, today)

    out = base / "claims_backlog.csv"
    with open(out, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(claims[0].keys()) if claims else
                           ["fnsku", "status"])
        w.writeheader()
        w.writerows(claims)

    file_now = [c for c in claims if c["status"] == "FILE_NOW"]
    print(f"Adjustment events owed (net): {len(adjustments)}")
    print(f"Claims still open : {len(file_now)}  worth ${sum(c['outstanding_usd'] for c in file_now):,.2f}")
    print(f"Window already closed on     : ${expired:,.2f} (dead money - file faster next cycle)")
    print(f"Wrote {out.name} with {len(claims)} rows")
    for c in sorted(file_now, key=lambda c: c["days_left"])[:5]:
        print(f"  {c['fnsku']}  {c['net_units_owed']}u  ${c['outstanding_usd']:>8.2f}  "
              f"deadline {c['deadline']} ({c['days_left']}d left)")
    return 0

if __name__ == "__main__":
    sys.exit(main())

Three design decisions worth understanding before you trust the output:

Netting happens per FNSKU, not per row. My first draft keyed events on (fnsku, date) — and immediately produced a false claim for a SKU that lost 14 units, got 6 found a week later, and had already received a partial payout. The corrected version aggregates all LOST/DAMAGED/FOUND events per FNSKU first, then subtracts reimbursements already paid. False claims are worse than no claims: Amazon rejects them, and a pattern of rejected claims poisons your account’s case history.

The deadline uses the earliest adjustment date. If a SKU lost units across multiple days, the clock on the oldest loss is the one that kills the claim first. Using the earliest date is conservative — you’d rather file three days early than discover the window closed while you waited.

Missing unit costs are skipped with a warning, not guessed. After the 2025 manufacturing-cost change, your cost basis is the number that determines what you recover. Guessing it silently would corrupt both the claim amount and your trust in the tool.

The actual output (from my test run)

Synthetic ledger, run on a pinned date. Note how FNSKU-001 correctly shows only the net outstanding balance after the FOUND event and the partial reimbursement — $6.60, not the $26.40 a naive scanner would claim:

Adjustment events owed (net): 4
Claims still open : 3  worth $117.80
Window already closed on     : $0.00 (dead money - file faster next cycle)
Wrote claims_backlog.csv with 3 rows
  X-FNSKU-001  8u  $     6.60  deadline 2026-12-01 (27d left)
  X-FNSKU-002  9u  $    63.90  deadline 2026-12-17 (43d left)
  X-FNSKU-004 22u  $    47.30  deadline 2026-12-24 (50d left)

In a real account, this console summary is your Monday ritual: look at the total, file anything with days_left under ~20 first, then work down the list.

Filing the claim

The scanner finds the money; you still close the loop by hand. In Seller Central, reimbursement cases live under the FBA inventory reimbursement section — you reference the FNSKU, the adjustment date from the backlog, your unit count, and attach sourcing documentation (invoice or cost basis) since the 2025 policy change made manufacturing cost the reimbursement basis. Keep each claim factual and small-grained: one FNSKU, one loss event, one amount. Amazon’s case handlers approve clean, verifiable claims and push back on bundles of “stuff you owe me.”

One honesty note: not every claim succeeds, and Amazon can reject claims it judges already-paid or ineligible. The scanner is a candidate generator, not a guarantee — which is exactly why the netting logic matters so much. File only what the reconciliation survives.

Claim quality: the difference between a recovery system and an account problem

Before you blast through the backlog, understand what you’re actually risk-managing. Amazon processes millions of reimbursement cases, and its case-handling system is tuned to detect sellers who file indiscriminately. Every rejected claim is a data point against you; a long enough pattern of over-claiming can get reimbursement privileges curtailed, which is a far bigger loss than any single claim recovers.

The rules that keep you on the right side of that line:

  • Only claim what netting survives. If the ledger shows 14 lost and 6 found, the claim is 8 units — not 14. If a reimbursement for that FNSKU already posted, subtract it. The script enforces both; don’t override it by hand because a bigger number looks better.
  • One event per case. Bundling twelve SKUs into one “you owe me $800” case looks like spam to a case handler and gets bounced. Clean, single-issue cases get approved on first pass.
  • Have your documentation before you file, not after. Since the manufacturing-cost change, the amount you recover is anchored to provable sourcing cost. An invoice from your supplier beats an assertion every time. If Amazon’s estimate comes in low, that documentation is what powers the dispute.
  • Never claim outside the window. A late claim isn’t just dead — it trains Amazon’s system to expect noise from your account. The scanner marks those WINDOW_CLOSED for a reason: that money is gone, and chasing it costs reputation.

This discipline is also, not coincidentally, the moat. Anyone can file claims; almost nobody files only correct claims at scale. That’s the difference between the services charging 25% commissions and sellers who quietly recover their own money for free.

The cash-flow frame: why this beats an equal amount of revenue

A recovered reimbursement is not ordinary revenue — it’s recovered cost, which changes the math completely. If your FBA business nets a 15% margin, you need roughly $6.70 of new sales to produce the same dollar a reimbursement claim puts in your pocket directly. Every $1,000 the scanner surfaces is equivalent, in bottom-line terms, to more than $6,000 of top-line sales you didn’t have to make.

That framing also tells you when this stop being worth it: if your account is small (a few thousand a month in FBA revenue, few SKUs), the discrepancy volume may only surface a few hundred dollars a year — run the scanner quarterly as a hygiene check. The economics get aggressive with scale: more inbound shipments, more fulfillment center touches, more returns processing, more opportunities for the network to lose your stuff on a clock you can’t see.

Scaling it up

Once the weekly ritual proves out, two upgrades compound the value:

Automate the report pulls. Amazon’s Selling Partner API exposes the same financial and inventory data the flat files contain — the Finances API returns reimbursement-relevant financial events per posted date range, and the reporting endpoints can schedule and fetch inventory ledger reports programmatically. The upgrade path looks like: a nightly job that pulls the last 7 days of ledger events and reimbursement postings, runs this exact reconciliation, and pushes you a notification only when the open-claim total crosses a threshold or any single claim drops under 14 days of window. The CSV contract here is deliberately shaped so the SP-API fetcher just writes the same three files — the scanner never changes. One caution: SP-API applications go through Amazon’s developer registration, and rate limits apply per endpoint, so back off politely rather than hammering the Finances API in a loop.

Trade the edge, don’t hoard it. A reconciliation scanner with deadline countdowns is also a sellable artifact — plenty of sellers will never write one and are already paying 25% commissions to services that run essentially this logic. A flat-fee “audit your account” offer built on this script undercuts the commission model while paying you per account instead of per dollar recovered.

The whole game in one sentence

Amazon’s reimbursement system pays the sellers who notice, on a 60-day clock, with proof — and a fifty-line reconciliation script notices everything.