Your free Amazon tool

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

One honest snapshot of the payout transfers Amazon recorded this period, and the net value of transactions still marked Deferred. 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)

Payout transfers Amazon recorded$18,400

across 3 transfers

June 6, 2026$6,100

June 20, 2026$6,250

July 4, 2026$6,050

Marked Deferred (not yet released)$2,840

These two figures come from different transaction groups - don't add or subtract them. The $18,400 is the payout transfers Amazon recorded this period; confirm them against your bank before you treat them as cleared cash. The $2,840 is the net value of transactions still marked Deferred - a status count, not revenue, profit, or spendable cash.

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

In this sample, Amazon recorded three payout transfers totalling $18,400 this period, while $2,840 of transactions are still marked Deferred. The tool shows the exact figures from your file - the estimated release date and reason live in your Seller Central account, and it points you there rather than guessing.

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

Export your report. In Seller Central: Reports → Payments → Date Range Reports. Pick the dates you want, generate a Transaction report, and download it as a CSV. Use a start date of January 1, 2025 or later - this tool reads the Transaction Status column that only appears on newer exports.
Open your AI. ChatGPT, Claude, or Gemini - whichever you already use. All three can run the small piece of Python this tool uses; you don't need to know any code.
Copy the prompt. Hit the Copy prompt button below.
Paste it and attach your CSV - in the same message. Paste the prompt as text, attach only your Transaction CSV, and send. Don't upload the prompt as a file, or some AIs will read it instead of running it.
Read your Payout Status Map. It sorts and adds up the transfers and statuses Amazon already recorded in your file, then prints your Payout Status Map. That's it - your report never leaves the AI tool you already trust.

The Payout Status Map prompt

Hi — I'd love your help turning my Amazon report into a clear "Payout Map."

I've attached my Amazon Date Range / Unified Transaction report (a CSV) to THIS message. Below is a short, already-validated Python script that does the whole analysis: it sorts and sums the exact numbers Amazon already calculated in my file to answer one question — when did I actually get my money, and how much is Amazon still holding? It doesn't estimate a payout, predict a payout date, or use any outside knowledge of Amazon's payout cycles — it only reads what's in my file. 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.)
  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 Payout Map.

The script reconciles itself before it shows me anything: it sums my file two independent ways and only presents a Payout Map if they match to the cent. It prints a "Source file:" line and a "run-check" code so we can both confirm it read the right report.

If your tool can run Python on an uploaded file (ChatGPT, Claude, and Gemini all can), 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 - Amazon Payout Status engine (deterministic).
# It sorts and sums the numbers already present in your Amazon Date Range /
# Unified Transaction report to answer TWO status questions from that file alone:
#   (1) how much did Amazon RECORD as payout transfers during this report period, and
#   (2) what is the net value of the transactions your file marks DEFERRED?
# It NEVER claims the money reached or cleared your bank, NEVER treats a status as
# revenue/profit/cash, NEVER predicts a release date, and NEVER uses outside knowledge
# of Amazon's policies. Same input -> same output. Money is handled with Decimal
# (exact to the cent), never binary float.
import csv, io, sys, hashlib, os, datetime
from decimal import Decimal, InvalidOperation, getcontext

getcontext().prec = 34          # ample headroom; all real amounts are 2dp
CENT = Decimal("0.01")
ZERO = Decimal("0")

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
# ─────────────────────────────────────────────────────────────────────────────

MONTHS = {m: i for i, m in enumerate(
    ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"], 1)}
MONTH_FULL = {1:"January",2:"February",3:"March",4:"April",5:"May",6:"June",
              7:"July",8:"August",9:"September",10:"October",11:"November",12:"December"}

# Header signature present on EVERY Date Range / Unified Transaction export
# (2025+ and older). Found by signature, never by line count, so preamble lines
# above the table are ignored and an unrelated CSV can't be mistaken for one.
HEADER_TOKENS = ("date/time", "settlement id", "type", "total")

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 read_text(path):
    # Lossless read: try encodings in order, never an "ignore/replace errors"
    # mode that would mangle bytes. Real Amazon exports are sometimes cp1252.
    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 looks_like_report(path):
    try:
        txt = read_text(path)
        return txt is not None and header_index(txt.splitlines()[:60]) is not None
    except Exception:
        return False

def find_report():
    """Find the uploaded Amazon report(s); validated by header so an unrelated
    CSV can't be picked. Returns a list, most-recently-modified first ([] if none)."""
    import glob
    if len(sys.argv) > 1:
        return [sys.argv[1]]
    seen, cands = {}, []
    for d in (".", "/mnt/data", os.getcwd(), "/tmp"):
        try:
            for p in glob.glob(os.path.join(d, "*.csv")) + glob.glob(os.path.join(d, "*.CSV")):
                key = os.path.normcase(os.path.realpath(p))   # dedupe rel/abs + case
                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
    # Pick the file the user JUST uploaded = most recently modified (size breaks ties).
    # Tools like ChatGPT keep old uploads around; "biggest" would grab a stale copy.
    cands.sort(key=lambda p: (-mtime(p), -size(p)))
    return [p for p in cands if looks_like_report(p)]

def fmt_date(s):
    """'Jun 21, 2026 4:11:25 PM PDT' -> 'June 21, 2026'; fall back to the raw string."""
    dt = (s or "").split()
    if len(dt) >= 3 and dt[0] in MONTHS:
        try:
            return f"{MONTH_FULL[MONTHS[dt[0]]]} {int(dt[1].rstrip(','))}, {int(dt[2])}"
        except Exception:
            return s
    return s

def to_ordinal(s):
    dt = (s or "").split()
    if len(dt) >= 3 and dt[0] in MONTHS:
        try:
            return datetime.date(int(dt[2]), MONTHS[dt[0]], int(dt[1].rstrip(","))).toordinal()
        except Exception:
            return None
    return None

def money(raw):
    """Exact money parse -> Decimal, or None if blank / non-numeric. Never coerces a
    bad cell to 0 silently; strips commas / $ / quotes / spaces only."""
    c = (raw or "").replace(",", "").replace("$", "").replace('"', "").strip()
    if c == "":
        return None
    try:
        return Decimal(c)
    except (InvalidOperation, ValueError):
        return None

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())
    has_status = C("transaction status") is not None
    has_reldate = C("transaction release date") is not None

    unparse = 0
    unparse_types = {}

    B = ZERO
    status_sum = {}; status_cnt = {}
    transfers = []                       # (raw date/time string, Decimal total)
    deferred_sum = ZERO; deferred_cnt = 0
    def_with_date = 0; def_without = 0
    same_date = {}                       # transfer date-key -> count (same-day detection)
    dmin = dmax = None

    for r in rows:
        raw_total = r.get(C("total")) if C("total") else ""
        tv = money(raw_total)
        if tv is None:
            unparse += 1
            typ = (r.get(C("type")) or "?").strip() if C("type") else "?"
            unparse_types[typ] = unparse_types.get(typ, 0) + 1
            tv = ZERO
        B += tv

        # period bounds (day granularity, from the printed date/time)
        dt = (r.get(C("date/time")) or "").split() if C("date/time") else []
        if len(dt) >= 3 and dt[0] in MONTHS:
            try:
                key = (int(dt[2]), MONTHS[dt[0]], int(dt[1].rstrip(",")))
                dmin = key if dmin is None or key < dmin else dmin
                dmax = key if dmax is None or key > dmax else dmax
            except Exception:
                pass

        # status partition — every row keyed by its EXACT status value; blank
        # gets its own line, shown never hidden.
        st = (r.get(C("transaction status")) or "").strip() if has_status else ""
        st_key = st if st else "(blank)"
        status_sum[st_key] = status_sum.get(st_key, ZERO) + tv
        status_cnt[st_key] = status_cnt.get(st_key, 0) + 1

        # transfer census — every row whose type is Transfer (a second view of
        # rows already inside the partition, not a new category).
        typ = (r.get(C("type")) or "").strip() if C("type") else ""
        if typ.lower() == "transfer":
            transfers.append(((r.get(C("date/time")) or "").strip(), tv))
            dk = to_ordinal((r.get(C("date/time")) or "").strip())
            if dk is not None:
                same_date[dk] = same_date.get(dk, 0) + 1

        # Deferred census + release-date field presence (Deferred rows only)
        if st.lower() == "deferred":
            deferred_cnt += 1
            deferred_sum += tv
            rd = (r.get(C("transaction release date")) or "").strip() if has_reldate else ""
            if rd:
                def_with_date += 1
            else:
                def_without += 1

    A = sum(status_sum.values(), ZERO)
    transfer_sum = sum((t for _, t in transfers), ZERO)

    # transfer posting intervals — day gaps between consecutive Transfer dates.
    # DESCRIPTIVE ONLY: the spacing these transfers happened to have in this file.
    ords = sorted(o for o in (to_ordinal(d) for d, _ in transfers) if o is not None)
    gaps = [ords[i+1] - ords[i] for i in range(len(ords) - 1)]
    multi_same_day = any(v > 1 for v in same_date.values())

    return dict(rows=len(rows), A=A, B=B, unparse=unparse, unparse_types=unparse_types,
                status_sum=status_sum, status_cnt=status_cnt, has_status=has_status,
                has_reldate=has_reldate, transfers=transfers, transfer_sum=transfer_sum,
                deferred_sum=deferred_sum, deferred_cnt=deferred_cnt,
                def_with_date=def_with_date, def_without=def_without,
                gaps=gaps, multi_same_day=multi_same_day, dmin=dmin, dmax=dmax)

def period(d):
    if not d["dmin"]: return "your report period"
    (y1,m1,day1), (y2,m2,day2) = d["dmin"], d["dmax"]
    if (y1,m1) == (y2,m2): return f"{MONTH_FULL[m1]} {day1}-{day2}, {y1}"
    if y1 == y2: return f"{MONTH_FULL[m1]} {day1} - {MONTH_FULL[m2]} {day2}, {y2}"
    return f"{MONTH_FULL[m1]} {day1}, {y1} - {MONTH_FULL[m2]} {day2}, {y2}"

# ── neutral notes: recite only, derive no date, hardcode no Amazon policy ─────
RELEASE_DATE_NOTE = (
    "This CSV does not contain release dates for the Deferred rows in this export.\n"
    "        Seller Central may show Amazon's current estimated payment release date\n"
    "        and the reason for each deferral.")
DEFERRAL_NOTE = (
    "The timing and reason for each deferral depend on your account and Amazon's\n"
    "        applicable reserve policy. Check Seller Central for the current\n"
    "        estimated release date and the deferral reason.")

# ── what this tool does NOT do, and the records that would be needed instead ──
LIMITATIONS = [
    "bank reconciliation - it does not confirm any transfer reached or cleared your bank",
    "settlement-level reconciliation to Amazon settlement statements",
    "an opening-to-closing Amazon balance roll-forward",
    "revenue or profit analysis",
    "reserve completeness testing - whether every held amount is shown here",
    "subsequent-event testing - what happened after this file was exported",
    "confirmation of when the Deferred transactions were later released",
]
RECORDS_NEEDED = (
    "To support any of those conclusions you would need records this file does not\n"
    "  contain: your bank statements or deposit records, Amazon settlement / statement\n"
    "  reports, your accounting ledger, and a later export showing how these Deferred\n"
    "  rows resolved.")

def render(d, src=None):
    out = []; P = out.append
    def L(v): return format(abs(v), ",.2f")               # magnitude only
    def D(v): return ("-$" if v < -CENT/2 else "$") + L(v) # signed dollar
    def rw(n): return f"{n:,} row" + ("" if n == 1 else "s")

    held = d["deferred_sum"]
    transfer_sum = d["transfer_sum"]
    recorded = abs(transfer_sum)
    n_tx = len(d["transfers"])
    ties = (d["A"] == d["B"])                              # exact, Decimal

    # pre-format the dated transfer lines (abs = magnitude Amazon recorded)
    tx_lines = [(fmt_date(dt), abs(tv)) for dt, tv in d["transfers"]]

    # run-check over the core figures (rows, A, B, deferred sum, transfer sum).
    # Signature of the FIGURES, not the code: same numbers -> same code, always.
    sig = hashlib.sha1(
        f"{d['rows']}|{d['A']:.2f}|{d['B']:.2f}|{d['deferred_sum']:.2f}|{d['transfer_sum']:.2f}"
        .encode()).hexdigest()[:10]

    # ── an ingestion / control-total failure is the ONLY thing that stops us ──
    if d["unparse"] != 0 or not ties:
        P(f"YOUR AMAZON PAYOUT STATUS — {period(d)}")
        P(f"Rows read: {d['rows']:,}")
        if src: P(f"Source file: {src}")
        P("")
        P("⚠ I stopped before showing you a status summary, because a parsing control did not pass.")
        P("  This summary is only worth reading if every row parsed and the control total matches first.")
        P("")
        if d["unparse"] != 0:
            P(f"  • Unparseable or missing 'total' cells: {d['unparse']}  (this must be 0).")
            P(f"    By type: {d['unparse_types']}")
            P("    Your file's largest amounts are the first casualties of a damaged read.")
            P("    Re-download the report as CSV and run this again.")
        if not ties:
            P(f"  • Sum of all status groups   A = {D(d['A'])}")
            P(f"    Whole-file 'total' sum       B = {D(d['B'])}")
            P(f"    A and B differ by {D(d['A']-d['B'])} — they must match exactly. Some rows were")
            P("    not included in the status aggregation; re-download the CSV and run it again.")
        P("")
        P(f"[Margins & Me Payout Status engine · run-check {sig}]")
        return "\n".join(out)

    # ══════════════════════════════════════════════════════════════════════════
    # LAYER 1 — STATUS AT A GLANCE
    # ══════════════════════════════════════════════════════════════════════════
    P(f"YOUR AMAZON PAYOUT STATUS — AT A GLANCE  ·  {period(d)}")
    if src: P(f"Source file: {src}")
    P(f"Rows read: {d['rows']:,}")
    P("")
    P("  Read this first. The two figures below come from different transaction")
    P("  populations and different timing bases. Do not add them, subtract one from the")
    P("  other, or treat them as two parts of one cash figure. Each is a status count")
    P("  from this file only — neither is confirmed bank cash, revenue, or profit.")
    P("")
    # 📤 Payout transfers RECORDED (never "paid", never "reached your bank")
    P(f"  📤  Payout transfers Amazon RECORDED in this report period: ${L(recorded)}"
      + (f", across {n_tx} transfer" + ("" if n_tx == 1 else "s") + "." if n_tx else "."))
    if n_tx == 0:
        P("        Your file contains no Transfer rows dated inside this period.")
    elif n_tx <= 8:
        for dstr, amt in tx_lines:
            P(f"        {dstr} — ${L(amt)}")
    else:
        first, last = tx_lines[0], tx_lines[-1]
        P(f"        {first[0]} — ${L(first[1])}")
        P(f"        …and {n_tx - 2} more — say 'show me more'")
        P(f"        {last[0]} — ${L(last[1])}")
    if n_tx:
        P("        These are Transfer rows Amazon recorded on these dates. They may include")
        P("        activity from earlier periods, and this report does NOT prove the money")
        P("        reached or cleared your bank. Confirm receipt and clearing against your")
        P("        bank activity, and use bank-confirmed cash for spending decisions.")
    P("")
    # ⏳ Net value of DEFERRED transactions (never "earnings", "cash", "spendable")
    if held > CENT / 2:
        P(f"  ⏳  Net value of transactions marked DEFERRED: ${L(held)}  ({rw(d['deferred_cnt'])}).")
        P("        Deferred means these transactions have not yet been released into")
        P("        settlement. This is a transaction-status measure from your file — not")
        P("        revenue, profit, sales, bank cash, or money available to spend.")
        P(f"        {RELEASE_DATE_NOTE}")
        P(f"        {DEFERRAL_NOTE}")
    elif held < -CENT / 2:
        P(f"  ⏳  Net value of transactions marked DEFERRED: {D(held)}  ({rw(d['deferred_cnt'])}).")
        P("        The Deferred rows net to a negative here. Your file reports it this way;")
        P("        I won't invent a reason. This is a transaction-status measure, not cash.")
        P(f"        {RELEASE_DATE_NOTE}")
    else:
        P("  ⏳  No transactions in this report are currently marked DEFERRED.")
        P("        This does not by itself prove that every released amount has already")
        P("        been transferred or received in the bank — it only means this file")
        P("        marks nothing as still deferred.")
    P("")
    P("  A note on 'Released': in this file, Released means a transaction is eligible for")
    P("  or has entered Amazon's settlement flow. It does NOT prove that amount was")
    P("  transferred to you or received in your bank.")
    P("")
    P(f"  Every figure here is a direct sum of your own file — no amount estimated, no")
    P(f"  release date guessed. (All {d['rows']:,} rows were read and included.)")
    P("")
    P("  Want to go deeper? Say \"show me more\" for every transfer and the full receipt.")
    P("")
    # one honest next action (no cash/earnings/spendable claims)
    if held > CENT / 2:
        P(f"The most useful next step: ${L(held)} of transactions are still marked Deferred (not")
        P("yet released into settlement), and the transfers above are amounts Amazon recorded,")
        P("not confirmed bank deposits. Reconcile the transfer amounts to your bank records")
        P("before treating them as available cash, and check Seller Central for the estimated")
        P("release dates and reasons on the Deferred rows.")
    else:
        P("The most useful next step: this file marks nothing as still Deferred, but that alone")
        P("doesn't prove the recorded transfers reached your bank. Reconcile the transfer")
        P("amounts to your bank records before treating them as available cash.")
    P("")
    # why this matters — the use, phrased as something YOU do with confirmed cash
    P("Why does this matter? Because payout transfers, once you've confirmed them against")
    P("your bank, are what you can actually plan around — not the total that sold. Confirmed")
    P("cash is the first thing I pull into my own weekly cash flow forecast.")
    P("")
    # forward hook — generic, naming nothing
    P("This summary shows the payout status Amazon recorded. The natural next question is")
    P("where working capital goes once cash is confirmed — because for most Amazon sellers a")
    P("large share of it ends up in inventory sitting in a warehouse. That's worth a look next.")
    P("")

    # ══════════════════════════════════════════════════════════════════════════
    # LAYER 2 — TL;DR + "show me why"
    # ══════════════════════════════════════════════════════════════════════════
    if held > CENT / 2:
        P(f"TL;DR: Amazon recorded ${L(recorded)} of payout transfers in this period across")
        P(f"{n_tx} transfer" + ("" if n_tx == 1 else "s") + f", and ${L(held)} of transactions are")
        P("marked Deferred (not yet released into settlement). Neither figure is confirmed bank")
        P("cash; the transfers still need reconciling to your bank, and the Deferred release")
        P("dates and reasons live in Seller Central → Payments → Deferred transactions.")
    else:
        P(f"TL;DR: Amazon recorded ${L(recorded)} of payout transfers in this period across")
        P(f"{n_tx} transfer" + ("" if n_tx == 1 else "s") + ", and this file marks nothing as still")
        P("Deferred. That is not proof the transfers reached your bank — reconcile them to your")
        P("bank records before treating them as available cash.")
    P("")
    P("Want to check a figure? Say \"show me why\" on any line above and I'll trace it back to")
    P("the exact rows in your file and the arithmetic behind it.")
    P("")

    # ══════════════════════════════════════════════════════════════════════════
    # LAYER 3 — THE RECEIPT (full aggregation, printed in full)
    # ══════════════════════════════════════════════════════════════════════════
    P("────────────────────────────────────────────────────────────")
    P("HOW EVERY FIGURE WAS AGGREGATED  ↓")
    P("The receipt, if you want it — proof, not homework. Below is the full aggregation:")
    P("every transaction status in your file with its row count and total, the control")
    P("total that had to match, your transfer census, and the Deferred census. You never")
    P("have to read it. It's here because you should always be able to.")
    P("────────────────────────────────────────────────────────────")
    P("")
    P("(0) Status coverage — every distinct Transaction Status value in your file:")
    for st in sorted(d["status_sum"]):
        P(f"      {st:<12} {rw(d['status_cnt'][st])}")
    P("")
    P("(1) Status partition — each status, its summed total and the rows that fed it:")
    for st in sorted(d["status_sum"]):
        P(f"      {st:<12} {d['status_cnt'][st]:>7,} rows   {D(d['status_sum'][st])}")
    P(f"      {'ALL':<12} {sum(d['status_cnt'].values()):>7,} rows   A = {D(d['A'])}")
    P("")
    P(f"(2) Unparseable or missing 'total' cells: {d['unparse']}   "
      + ("✓ (must be 0)" if d["unparse"] == 0 else "✗ ingestion damaged — do not trust"))
    P(f"(3) Sum of all status groups                     A = {D(d['A'])}")
    P(f"(4) Sum of the 'total' column over every row     B = {D(d['B'])}")
    P("      " + ("✓ A = B — the status groups sum to the whole-file 'total' column, so every"
                  if ties else "✗ A ≠ B — some rows were left out of the status aggregation."))
    if ties:
        P("        parsed row was included in the status aggregation. This is an INTERNAL")
        P("        control total on one file and one column. It does NOT reconcile to your")
        P("        bank activity, Amazon settlement statements, your general ledger, revenue,")
        P("        or Amazon opening/closing balances, and it does not prove any figure is")
        P("        correct — only that no parsed row was dropped.")
    P("")
    P(f"    Net value of DEFERRED transactions = {D(d['deferred_sum'])}   ({rw(d['deferred_cnt'])})")
    P("")
    P(f"(5) Transfer census — every row whose type is Transfer: {rw(n_tx)}, "
      f"summing to {D(d['transfer_sum'])}")
    P(f"      → Amazon recorded ${L(recorded)} of payout transfers (magnitude of the census sum).")
    for dt, tv in d["transfers"]:
        P(f"      {fmt_date(dt):<20} {D(tv)}")
    if d["gaps"]:
        gtxt = ", ".join(str(g) for g in d["gaps"])
        P(f"      Transfer posting intervals in this file: {gtxt} "
          f"day{'s' if not (len(d['gaps'])==1 and d['gaps'][0]==1) else ''}. Descriptive only;")
        P("      not a payout schedule or forecast. Intervals may reflect separate settlements,")
        P("      accounts, marketplaces, or adjustments.")
    if d["multi_same_day"]:
        P("      Note: more than one transfer posted on the same date; each is counted separately.")
    P("")
    P(f"(6) Deferred release-date field: of {d['deferred_cnt']:,} Deferred rows, "
      f"{d['def_with_date']:,} carry a value in the 'Transaction Release Date' field and "
      f"{d['def_without']:,} are blank.")
    rd_ok = (d["def_with_date"] + d["def_without"]) == d["deferred_cnt"]
    P("      " + ("✓ the two counts sum to the Deferred row count."
                  if rd_ok else "✗ counts don't sum to the Deferred total — read of the Deferred rows is broken."))
    if d["deferred_cnt"] and d["def_with_date"] == 0:
        P("      Every Deferred row is blank in that field in THIS export. That is only a fact")
        P("      about this file; Seller Central may show an estimated release date and reason.")
    P("")
    # ── item 10: explicit limitations ──
    P("(7) What this summary does NOT do:")
    for lim in LIMITATIONS:
        P(f"      • {lim}")
    P(f"  {RECORDS_NEEDED}")
    P("")
    P(f"[Amazon payout status computed by the Margins & Me engine · run-check {sig}]")
    return "\n".join(out)

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"
    return list(csv.DictReader(io.StringIO("\n".join(lines[hdr:])))), "ok"

if __name__ == "__main__":
    if UPLOADED_FILE.strip() and len(sys.argv) <= 1:
        reports = [UPLOADED_FILE.strip()]      # the tool told us exactly which file is yours
    else:
        reports = find_report()
    if not reports:
        print("I couldn't find your Amazon Date Range / Unified Transaction report. "
              "Please upload that CSV (Seller Central > Reports > Payments > Date Range "
              "Reports > Transaction) and run this again.")
        sys.exit(0)
    path = reports[0]
    rows, status = load(path)
    if status == "not_a_report":
        print("That file doesn't look like an Amazon Date Range / Unified Transaction report "
              "(I couldn't find the expected header row). Please upload that exact report and run again.")
        sys.exit(0)
    if status == "unreadable" or rows is None:
        print("I couldn't read that file. Please re-download your Amazon Transaction report "
              "as CSV and try again.")
        sys.exit(0)
    # Step-1 gate: this summary REQUIRES the 2025+ Transaction Status column.
    cols_lower = {c.strip().lower() for c in (rows[0].keys() if rows else [])}
    if "transaction status" not in cols_lower:
        print("Your report is an older layout without the Transaction Status column this summary "
              "needs. Re-export the Date Range Transaction report with a start date of "
              "Jan 1, 2025 or later, then run this again.")
        sys.exit(0)
    if len(reports) > 1:
        print(f"⚠ Heads up: I found {len(reports)} files that look like Amazon reports and used your "
              f"MOST RECENT upload ({os.path.basename(path)}). If that's not the report you meant, "
              f"check the 'Source file' line below, or start a fresh chat with only that file.\n")
    print(render(analyze(rows), src=os.path.basename(path)))
```

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 CSV. 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 runs an internal control total - every parsed row has to add up to the whole-file total to the cent - and stops if it ever doesn't. 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: the payout transfers Amazon recorded this period, how many there were, and the net value of transactions still marked Deferred - clearly labelled as status counts from your file, not confirmed bank cash, revenue, or profit.
What it is - and what it isn't: It reads the statuses and amounts already in your file. It never claims the money reached your bank, never predicts a payout, never guesses a release date, and never uses outside knowledge of Amazon’s policies. The estimated release date and reason for anything still marked Deferred live in your Seller Central account, and the tool points you there rather than guessing.
It never invents a number. It only sorts and adds up figures already in your report, and it runs an internal control total - every parsed row has to add up to the whole-file total to the cent - before it shows you anything. If that doesn't match, it's built to stop and tell you, not guess. (That check confirms nothing was dropped; it isn't a bank or settlement reconciliation.)

← 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.