Your free Amazon tool

Your Amazon Inventory Map - about 2 minutes once you have your report.

One honest snapshot of how many units Amazon is holding for you, and what it's costing you every month to keep them there. It runs inside the AI you already use, on your own report. Your file never comes to us.

What you'll actually see

(sample data)

Units held (in Amazon's warehouses)60,000 units

Holding cost / month$6,800

Amazon's estimate for next month

Base storage$2,800

Aging surcharge$4,000

Aging (181+ days)18,000 units · 30%

Over a year old (366+ days)9,000 units · 15%

$4,000 of that $6,800 monthly bill is aging surcharge, not base storage - and it's tied to the 18,000 units that have sat past 180 days. The 9,000 that are over a year old draw the highest surcharge rate, so clearing those takes the priciest dollars off the bill first.

Every number is a straight sum of your own report - and a run-check code confirms the official Margins & Me engine produced it.

In this sample, the seller is paying $6,800 a month to store 60,000 units - and $4,000 of that is aging surcharge on stock that's simply sat too long. That's the part you can actually move.

Run it on your numbers - the steps below take about 2 minutes once you have your report.

Export your report. In Seller Central: Reports → Fulfillment → Inventory. Download the Inventory Age report (you'll also find it under Manage Inventory Health). It comes as a tab-separated .txt or a CSV - either one works.
Open ChatGPT. It runs the small piece of Python this tool is built on - you don't need to know any code. (Claude works too; those are the two we check this on.) If your AI can't run code, it can't run this, and it's built to say so and stop, rather than hand you a guess.
Copy the prompt. Hit the Copy prompt button below.
Paste it and attach your report - in the same message. Paste the prompt as text, attach only your Inventory Age file, and send. Don't upload the prompt as a file, or some AIs will read it instead of running it.
Read your Inventory Map. It sorts and adds up the units and the holding costs Amazon already put in your file, then prints your Inventory Map. That's it - your report never leaves the AI tool you already trust.

The Inventory Map prompt

Hi - I'd love your help turning my Amazon inventory report into a clear "Inventory Map."

I've attached my Amazon FBA Inventory Age report (a tab- or comma-separated file) to THIS message. Below is a short, already-validated Python script that does the whole analysis: it sorts and sums the units and the holding dollars Amazon already estimated in my file, and prints a clean, plain-English summary. The logic is correct and tested, so please DON'T rewrite, simplify, or "improve" it, and don't do the math yourself.

Please just:
  1. Near the TOP of the script there's a line: UPLOADED_FILE = ""  . Put the path of the report I attached to THIS message between the quotes (in ChatGPT that's usually /mnt/data/<the file name>). That single line is the ONLY thing you change - it just points the script at my file. (If you're sure only one report is present, you can leave it blank and it will auto-detect the most recent upload.)
  2. Run the script exactly as written otherwise - don't rewrite the analysis or do any math yourself.
  3. Show me its output character-for-character, inside a plain code block, EXACTLY as the script printed it - do NOT retype, reformat, round, or "tidy" any number or line. That printed text IS my Inventory Map.

The script prints a "Source file:" line and a "run-check" code so we can both confirm it read the right report. It also runs its own trust checks (it re-counts the same units two different ways and stops if they ever disagree) before it shows a single number.

If your tool can run Python on an uploaded file (ChatGPT and Claude both can - those are the two I've checked this on), this takes a few seconds. If it genuinely can't, tell me - don't estimate the numbers by hand.

Here's the script - run it on my file:

```python
#!/usr/bin/env python3
# Margins & Me - Inventory Map engine (deterministic).
# It sorts and sums the units and the Amazon-estimated holding dollars already in
# your FBA Inventory Age report. It NEVER estimates a fee or a rate. Same input ->
# same output. Units-only: this review uses no product costs (that's a later map).
import csv, io, sys, os, glob, hashlib
from decimal import Decimal, InvalidOperation, ROUND_HALF_UP

try:
    sys.stdout.reconfigure(encoding="utf-8")   # safe output on any console
except Exception:
    pass

# ─────────────────────────────────────────────────────────────────────────────
#  IF YOUR AI TOOL HAS TROUBLE FINDING THE RIGHT FILE (e.g. ChatGPT keeps old
#  uploads around), paste the path of the report you just uploaded between the
#  quotes below. In ChatGPT that's usually "/mnt/data/<your file name>".
UPLOADED_FILE = ""      # leave "" to auto-detect your most recent upload
# ─────────────────────────────────────────────────────────────────────────────

# --- Exact FBA Inventory Age column names (matched case-insensitively) ---
COARSE = [("0-90","inv-age-0-to-90-days"),("91-180","inv-age-91-to-180-days"),
          ("181-270","inv-age-181-to-270-days"),("271-365","inv-age-271-to-365-days"),
          ("366-455","inv-age-366-to-455-days"),("456+","inv-age-456-plus-days")]
FINE = [("0-30","inv-age-0-to-30-days"),("31-60","inv-age-31-to-60-days"),
        ("61-90","inv-age-61-to-90-days"),("181-330","inv-age-181-to-330-days"),
        ("331-365","inv-age-331-to-365-days")]
STORAGE_COL = "estimated-storage-cost-next-month"
AVAIL_COL   = "available"
TIERS = ["181-210","211-240","241-270","271-300","301-330","331-365","366-455","456-plus"]
TLABEL = {t:("456+" if t=="456-plus" else t) for t in TIERS}
AIS_D = {t: f"estimated-ais-{t}-days" for t in TIERS}
AIS_Q = {t: f"quantity-to-be-charged-ais-{t}-days" for t in TIERS}
RESERVED_CANDS = ["total reserved quantity","reserved-quantity","reserved-qty","fc-processing-quantity"]
UNFUL_CANDS    = ["unfulfillable-quantity","unfulfillable-qty","unfulfillable"]
SNAPSHOT_CANDS = ["snapshot-date","snapshot_date"]
AGE_COLS = [c for _,c in COARSE] + [c for _,c in FINE]
# A file is an Inventory Age report iff it has sku + the age buckets.
HEADER_TOKENS = ("sku", "inv-age-0-to-90-days", "inv-age-456-plus-days")

Z = Decimal("0.00")
def q2(d): return d.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
def q1(d): return d.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP)
def money(d): return f"${d:,.2f}"
def rw(n): return f"{n:,} row" + ("" if n == 1 else "s")
def uu(n): return f"{n:,} unit" + ("" if n == 1 else "s")

def read_text(path):
    try:
        for enc in ("utf-8-sig","utf-8","cp1252","latin-1"):
            try:
                with open(path, encoding=enc, newline="") as f:
                    return f.read()
            except UnicodeDecodeError:
                continue
    except (FileNotFoundError, IsADirectoryError, PermissionError, OSError):
        return None
    return None

def header_index(lines):
    for i, l in enumerate(lines):
        low = l.lower()
        if all(k in low for k in HEADER_TOKENS):
            return i
    return None

def looks_like_report(path):
    try:
        txt = read_text(path)
        return txt is not None and header_index(txt.splitlines()[:80]) is not None
    except Exception:
        return False

def find_report():
    """Find the uploaded Inventory Age report(s), validated by header so an
    unrelated file can't be picked. Newest upload first (size breaks ties)."""
    if UPLOADED_FILE.strip():
        return [UPLOADED_FILE.strip()]
    if len(sys.argv) > 1:
        return [sys.argv[1]]
    seen, cands = {}, []
    for d in (".", "/mnt/data", os.getcwd(), "/tmp"):
        try:
            for ext in ("*.txt","*.TXT","*.csv","*.CSV","*.tsv","*.TSV"):
                for p in glob.glob(os.path.join(d, ext)):
                    key = os.path.normcase(os.path.realpath(p))
                    if key not in seen:
                        seen[key] = p; cands.append(p)
        except Exception:
            pass
    def mtime(p): return os.path.getmtime(p) if os.path.exists(p) else 0
    def size(p):  return os.path.getsize(p) if os.path.exists(p) else 0
    cands.sort(key=lambda p: (-mtime(p), -size(p)))   # newest upload wins
    return [p for p in cands if looks_like_report(p)]

def load(path):
    txt = read_text(path)
    if txt is None:
        return None, "unreadable"
    lines = txt.splitlines()
    hdr = header_index(lines)
    if hdr is None:
        return None, "not_a_report"
    delim = "\t" if "\t" in lines[hdr] else ","
    body = "\n".join(lines[hdr:])
    return list(csv.DictReader(io.StringIO(body), delimiter=delim)), "ok"

# --- cell parsing: exact, never lossy ---
def parse_num(s):
    """Returns (Decimal|None, is_blank, is_bad)."""
    t = (s or "").strip()
    if t in ("", "-"):
        return None, True, False
    t2 = t.replace(",","").replace("$","").strip()
    try:
        return Decimal(t2), False, False
    except InvalidOperation:
        return None, False, True

def analyze(rows):
    cols = {c.strip().lower(): c for c in rows[0].keys()} if rows else {}
    def C(n): return cols.get(n.lower())
    def first_col(cands):
        for n in cands:
            if C(n): return C(n)
        return None
    res_col = first_col(RESERVED_CANDS); unf_col = first_col(UNFUL_CANDS)
    snap_col = first_col(SNAPSHOT_CANDS); sku_col = C("sku"); asin_col = C("asin")

    coarse = {k: 0 for k,_ in COARSE}; fine = {k: 0 for k,_ in FINE}
    ais_d = {t: Decimal(0) for t in TIERS}; ais_q = {t: 0 for t in TIERS}
    storage = Decimal(0); avail = 0; reserved = 0; unful = 0
    age_bad = 0; age_bad_samples = []; money_unparse = 0; commas = 0
    first_sku = last_sku = first_asin = last_asin = ""
    snapshot = ""

    def val(r, col):
        return r.get(col) if col else ""

    for i, r in enumerate(rows):
        if snap_col and not snapshot:
            snapshot = (r.get(snap_col) or "").strip()
        sk = (r.get(sku_col) or "").strip() if sku_col else ""
        an = (r.get(asin_col) or "").strip() if asin_col else ""
        if i == 0: first_sku, first_asin = sk, an
        last_sku, last_asin = sk, an
        # age buckets: blank OR non-numeric here is a DEFECT
        for k, col in COARSE:
            v, blank, bad = parse_num(val(r, C(col)))
            if blank or bad:
                age_bad += 1
                if len(age_bad_samples) < 8: age_bad_samples.append((i+1, col))
            else:
                coarse[k] += int(v)
        for k, col in FINE:
            v, blank, bad = parse_num(val(r, C(col)))
            if blank or bad:
                age_bad += 1
                if len(age_bad_samples) < 8: age_bad_samples.append((i+1, col))
            else:
                fine[k] += int(v)
        # available / reserved / unfulfillable (composition)
        v, blank, bad = parse_num(val(r, C(AVAIL_COL)))
        if v is not None: avail += int(v)
        if res_col:
            v, b, bd = parse_num(r.get(res_col)); reserved += int(v) if v is not None else 0
        if unf_col:
            v, b, bd = parse_num(r.get(unf_col)); unful += int(v) if v is not None else 0
        # storage (blank = $0, not a defect)
        raw = val(r, C(STORAGE_COL)); v, blank, bad = parse_num(raw)
        if bad: money_unparse += 1
        elif v is not None:
            storage += v
            if "," in (raw or ""): commas += 1
        # AIS dollars + charged qty (blank = 0)
        for t in TIERS:
            raw = val(r, C(AIS_D[t])); v, blank, bad = parse_num(raw)
            if bad: money_unparse += 1
            elif v is not None:
                ais_d[t] += v
                if "," in (raw or ""): commas += 1
            raw = val(r, C(AIS_Q[t])); v, blank, bad = parse_num(raw)
            if bad: money_unparse += 1
            elif v is not None: ais_q[t] += int(v)

    total = sum(coarse.values())
    total_fine = (fine["0-30"]+fine["31-60"]+fine["61-90"] + coarse["91-180"]
                  + fine["181-330"]+fine["331-365"] + coarse["366-455"] + coarse["456+"])
    seam_0_90_fine = fine["0-30"]+fine["31-60"]+fine["61-90"]
    seam_181_365_coarse = coarse["181-270"]+coarse["271-365"]
    seam_181_365_fine = fine["181-330"]+fine["331-365"]
    ais_total = sum(ais_d.values(), Decimal(0))
    holding = storage + ais_total
    units_181 = coarse["181-270"]+coarse["271-365"]+coarse["366-455"]+coarse["456+"]
    units_366 = coarse["366-455"]+coarse["456+"]
    top_rate = ais_d["366-455"] + ais_d["456-plus"]
    charged_total = sum(ais_q.values())
    charged_1yr = ais_q["366-455"] + ais_q["456-plus"]
    nested = {
        "181-270": ais_d["181-210"]+ais_d["211-240"]+ais_d["241-270"],
        "271-365": ais_d["271-300"]+ais_d["301-330"]+ais_d["331-365"],
        "366-455": ais_d["366-455"], "456+": ais_d["456-plus"],
    }
    pct = lambda n: (Decimal(n)/Decimal(total)*100) if total else Decimal(0)
    return dict(coarse=coarse, fine=fine, ais_d=ais_d, ais_q=ais_q, storage=q2(storage),
        ais_total=q2(ais_total), holding=q2(holding), top_rate=q2(top_rate), nested=nested,
        total=total, total_fine=total_fine, seam_0_90_fine=seam_0_90_fine,
        seam_181_365_coarse=seam_181_365_coarse, seam_181_365_fine=seam_181_365_fine,
        units_181=units_181, units_366=units_366, pct_181=q1(pct(units_181)),
        pct_366=q1(pct(units_366)), charged_total=charged_total, charged_1yr=charged_1yr,
        avail=avail, reserved=reserved, unful=unful, res_col=bool(res_col), unf_col=bool(unf_col),
        age_bad=age_bad, age_bad_samples=age_bad_samples, money_unparse=money_unparse,
        commas=commas, rows=len(rows), first_sku=first_sku, last_sku=last_sku,
        first_asin=first_asin, last_asin=last_asin, snapshot=snapshot or "your report period")

def gate_failures(d):
    """Return a list of hard-stop reasons (empty = all gates pass)."""
    fails = []
    if d["age_bad"] > 0:
        fails.append(("Missing/unreadable age-bucket cells",
            f"{d['age_bad']} age-bucket cell(s) were blank or non-numeric (samples: "
            f"{d['age_bad_samples'][:5]}). Every SKU must have all six age buckets. "
            "Re-download the Inventory Age report as a fresh file and run this again."))
    if d["total"] != d["total_fine"]:
        fails.append(("Unit-integrity check failed (two partitions disagree)",
            f"Coarse buckets total {d['total']:,} but the fine buckets total "
            f"{d['total_fine']:,}. The age columns didn't read consistently - don't trust "
            "these numbers; re-download the report as CSV/TSV and run it again."))
    if d["coarse"]["0-90"] != d["seam_0_90_fine"]:
        fails.append(("0-90 seam failed",
            f"0-90 coarse ({d['coarse']['0-90']:,}) != 0-30+31-60+61-90 ({d['seam_0_90_fine']:,})."))
    if d["seam_181_365_coarse"] != d["seam_181_365_fine"]:
        fails.append(("181-365 seam failed",
            f"181-270+271-365 ({d['seam_181_365_coarse']:,}) != 181-330+331-365 "
            f"({d['seam_181_365_fine']:,})."))
    if d["avail"] > d["total"]:
        fails.append(("Sanity check failed",
            f"'available' units ({d['avail']:,}) exceed on-hand units ({d['total']:,}); "
            "the columns are misaligned. Re-download and run again."))
    return fails

def render(d, src=None):
    out = []; P = out.append
    total = d["total"]; holding = d["holding"]; storage = d["storage"]; ais = d["ais_total"]
    u181 = d["units_181"]; u366 = d["units_366"]; top = d["top_rate"]

    # ---- Layer 1: THE MAP AT A GLANCE ----
    P(f"YOUR INVENTORY, AT A GLANCE - snapshot {d['snapshot']}")
    P(f"Rows read: {d['rows']:,}   ✓ I read every SKU in your file.")
    if src: P(f"Source file: {src}")
    P("")
    P(f"  \U0001F4E6  You're holding {total:,} units in Amazon's warehouses.")
    P(f"  \U0001F4B8  Holding them costs about {money(holding)}/month - Amazon's own estimate for next month.")
    P(f"  ⏳  {d['pct_181']}% of that stock is old enough to be racking up aging surcharges - and")
    P(f"      {d['pct_366']}% is over a year old, at Amazon's top rate.")
    # 🎯 tied line - pick variant by the data (never manufacture a problem)
    if ais > Z:
        P(f"  \U0001F3AF  The lever: your {u181:,} aged units are what generate that surcharge - {money(ais)}")
        P(f"      of the monthly bill above is pure aging penalty" + (
            f", and the {u366:,} units over a year" if u366 else "."))
        if u366:
            P(f"      old drive {money(top)} of it at Amazon's top rate. Move those units and that whole")
            P(f"      penalty comes off the bill.")
    elif u181 > 0:
        P(f"  \U0001F3AF  Your {u181:,} aged units aren't drawing an aging surcharge on next month's estimate")
        P(f"      - your holding cost is all base storage. Worth keeping an eye on, nothing to fix today.")
    else:
        P(f"  \U0001F3AF  No aging penalty here: nothing has crossed the 181-day surcharge line. Your holding")
        P(f"      cost is all base storage - that's what healthy looks like.")
    P("")
    if u181 > 0:
        P("  In plain terms: the longer stock sits, the more Amazon charges to keep it - so moving the")
        P("  aged units is the fastest way to bring that monthly bill down.")
    else:
        P("  In plain terms: your stock is turning over well - barely any of it is old enough to be")
        P("  racking up aging surcharges. Nothing here needs fixing today; this is what healthy looks like.")
    P("")
    P(f"  Every number here comes straight from your own Amazon report - estimated only where Amazon")
    P(f"  estimates, nothing invented. (I read all {d['rows']:,} SKUs in your file, start to finish.)")
    P("")
    P('  Want to go deeper? Say "show me more" for the full age breakdown - units and charges side by')
    P("  side - and where each unit is sitting.")
    P("")

    # ---- Layer 2: TL;DR + show me why ----
    if u181 > 0:
        P(f"TL;DR: {d['pct_181']}% of your inventory ({u181:,} units) is old enough to be accruing aging")
        P(f"surcharges - {money(ais)} of your {money(holding)}/month holding estimate is that penalty alone -")
        P(f"and {d['pct_366']}% ({u366:,} units) is over a year old, driving {money(top)} of it at Amazon's")
        P("top rate (all estimated next month, from your own file).")
    else:
        P(f"TL;DR: you're holding {total:,} units at about {money(holding)}/month (Amazon's estimate for next")
        P("month), and effectively none of it is old enough to be accruing an aging surcharge - a healthy sign.")
    P("")
    P('Want to check my math? Say "show me why" on any line above, and I\'ll trace it back to the exact')
    P("SKUs and age buckets in your file - and the arithmetic behind it.")
    P("")

    # ---- Layer 3: THE RECEIPT ----
    P("─" * 60)
    P("HOW I CHECKED EVERY NUMBER  ↓")
    P("The receipt, if you want it - proof, not homework. Every figure above traces straight back to")
    P("your file. This is the full reconciliation I ran before showing you a single number.")
    P("─" * 60)
    P(f"  Rows read (SKUs)           : {d['rows']:,}")
    P(f"  First SKU / ASIN           : {d['first_sku']} / {d['first_asin']}")
    P(f"  Last  SKU / ASIN           : {d['last_sku']} / {d['last_asin']}")
    P(f"  Unparseable age-bucket cells: {d['age_bad']}   (must be 0)")
    P("")
    P("  Unit-integrity check (the same units counted two different ways must agree):")
    P(f"     Partition A (six coarse buckets) = {total:,}")
    P(f"     Partition B (fine buckets)       = {d['total_fine']:,}")
    P("     " + ("✓ A = B, to the unit - the age columns read consistently."
                 if total == d["total_fine"] else "✗ A != B - do not trust these numbers."))
    P("  Per-region seams:")
    P(f"     0-90    : coarse {d['coarse']['0-90']:,}  ==  0-30+31-60+61-90 {d['seam_0_90_fine']:,}   "
      + ("✓" if d['coarse']['0-90']==d['seam_0_90_fine'] else "✗"))
    P(f"     181-365 : 181-270+271-365 {d['seam_181_365_coarse']:,}  ==  181-330+331-365 "
      f"{d['seam_181_365_fine']:,}   " + ("✓" if d['seam_181_365_coarse']==d['seam_181_365_fine'] else "✗"))
    P(f"     91-180  : {d['coarse']['91-180']:,}   366-455 : {d['coarse']['366-455']:,}   456+ : {d['coarse']['456+']:,}   (shared columns)")
    P("")
    P("  On-hand units by age bucket (this IS Partition A - not re-derived):")
    for k,_ in COARSE:
        P(f"     {k:<8} {d['coarse'][k]:>8,} units")
    P(f"     {'TOTAL':<8} {total:>8,} units")
    P("")
    comp = f"     available {d['avail']:,}"
    if d["res_col"]: comp += f"  ·  reserved {d['reserved']:,}"
    if d["unf_col"]: comp += f"  ·  unfulfillable {d['unful']:,}"
    P("  Where those units sit (composition):")
    P(comp)
    known = d["avail"] + (d["reserved"] if d["res_col"] else 0) + (d["unful"] if d["unf_col"] else 0)
    rem = total - known
    if (d["res_col"] or d["unf_col"]) and rem != 0:
        P(f"     unreconciled (likely FC transfers / timing): {rem:,}")
    P(f"     sanity: available {d['avail']:,} <= on-hand {total:,}   "
      + ("✓" if d['avail']<=total else "✗"))
    P("")
    P("  Dollars tie-out (every line a pure sum of Amazon's own estimate cells, never a rate):")
    P(f"     Base storage (estimated next month, all SKUs) = {money(storage)}  [one un-split total]")
    P("     Aged surcharge by tier  (units Amazon plans to charge / its estimated $):")
    for t in TIERS:
        P(f"        {TLABEL[t]:<8} {d['ais_q'][t]:>7,} u  /  {money(d['ais_d'][t])}")
    P(f"     Total aged surcharge = {money(ais)}   (the eight tiers above sum to this, to the cent)")
    P(f"     Units Amazon plans to charge = {d['charged_total']:,}  ·  of which over a year "
      f"(366-455 + 456+) = {d['charged_1yr']:,}")
    P(f"     Estimated monthly holding = {money(storage)} + {money(ais)} = {money(holding)}")
    P("     TIMING NOTE: the charged-unit counts are Amazon's projection at NEXT MONTH'S charge date;")
    P("     the age buckets above count units TODAY. Two different dates - not an error, not reconciled.")
    P("     Blank surcharge/storage cells were read as $0 (Amazon leaves them empty when no charge applies).")
    P("")
    P("  Aging math (from the reconciled buckets above):")
    P(f"     Surcharge-exposed (181+ days) = {u181:,} units = {d['pct_181']}% of {total:,}")
    P(f"     Over a year (366+ days)       = {u366:,} units = {d['pct_366']}% of {total:,}")
    P(f"     Top-rate surcharge $ (366-455 + 456+ tiers) = {money(top)}")
    if d["commas"] or d["money_unparse"]:
        P(f"     (comma-formatted cells handled: {d['commas']}  ·  non-numeric money cells: {d['money_unparse']})")
    P("")
    sig = hashlib.sha1(
        f"{d['rows']}|{total}|{holding}|{storage}|{ais}|{u181}|{u366}".encode()
    ).hexdigest()[:10]
    P(f"[Inventory Map computed by the Margins & Me engine · run-check {sig}]")
    return "\n".join(out)

def main():
    reports = find_report()
    if not reports:
        print("I couldn't find your Amazon FBA Inventory Age report. Please upload that file "
              "(Seller Central > Reports > Fulfillment > Inventory > Inventory Age / Manage "
              "Inventory Health) and run this again.")
        return
    path = reports[0]
    rows, status = load(path)
    if status == "not_a_report":
        print("That file doesn't look like an Amazon FBA Inventory Age report (I couldn't find the "
              "age-bucket columns like 'inv-age-0-to-90-days'). Please upload that exact report and run again.")
        return
    if status == "unreadable" or rows is None:
        print("I couldn't read that file. Please re-download your Inventory Age report as CSV/TSV and try again.")
        return
    if len(reports) > 1:
        print(f"⚠ Heads up: I found {len(reports)} files that look like inventory reports and used your "
              f"MOST RECENT upload ({os.path.basename(path)}). If that's not the report you meant, check the "
              f"'Source file' line below, or start a fresh chat with only that file.\n")
    d = analyze(rows)
    fails = gate_failures(d)
    if fails:
        print("I stopped before showing you an Inventory Map, because a trust check didn't pass -")
        print("I won't hand you numbers I can't stand behind:\n")
        for name, why in fails:
            print(f"  ✗ {name}\n    {why}\n")
        return
    print(render(d, src=os.path.basename(path)))

if __name__ == "__main__":
    main()
```

That's it - run it and paste the output back exactly. Thanks so much!

Paste this as your message - don't attach it as a file. Attach only your Inventory Age report. When the prompt is uploaded as a file, some AIs review it instead of running it.

Heads up: the AI runs a short, already-validated script - it doesn't do the math itself. Before it shows you a single number, it counts your units two different ways and stops if they ever disagree. At the very bottom you'll see a run-check code - your proof the official Margins & Me engine produced these exact numbers, unchanged. Want to check a single line? Just ask it “show me why.”

How we keep this honest

Your data never comes to us. You run this in your own AI, on your own file. Nothing is uploaded to Margins & Me.
What it shows: how many units you're holding, what Amazon estimates it'll cost to store them next month, how much of that stock is old enough to draw an aging surcharge, and how much is over a year old.
What it is - and what it isn't: one honest snapshot at today’s ages. Not a live dashboard, not a feed that updates on its own. It reads units and Amazon’s own holding estimates, not your product cost, not what a unit is worth to you, and not per-SKU advice. Want a fresh read next month? Run it again.
It never invents a number. It only sorts and adds up figures already in your report, and it counts your units two ways before it trusts them. If they don't reconcile, it's built to stop and tell you, not guess.

← See all free tools

Stay in the loop

Want to hear when new tools drop?

Get new tools and plain-English finance tips as they land. Unsubscribe any time.

We'll only use your email to send you new tools and the occasional note - unsubscribe any time. See the Privacy Policy.