Your free Amazon tool

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

Certified July 2026 · tested on ChatGPT, Claude & Gemini

One honest snapshot of what Amazon actually did with your money last period. 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)

Gross sales$27,940

What Amazon kept (fees)−$12,780

Selling fees (referral)$4,190

FBA fulfillment$5,870

Storage & inventory$310

Service / program fees$2,410

Other money in & out−$790

refunds, promotions and reimbursements, netted

Net proceeds before your costs$14,370

Still held by Amazon$1,204

Every line ties to the cent - and a run-check code confirms the official engine produced it.

In this sample, the seller keeps about 51¢ of every sales dollar. Most sellers guess higher.

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.
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 Money Map. It sorts and adds up the numbers Amazon already put in your file, then prints your Money Map. That's it - your report never leaves the AI tool you already trust.

The Money Map prompt

Hi - I'd love your help turning my Amazon report into a clear "Money 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 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.)
  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 Money Map.

The script 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 - Money Map engine (deterministic).
# It sorts and sums the numbers Amazon already calculated in your Date Range /
# Unified Transaction report. It NEVER estimates a fee. Same input -> same output.
import csv, io, sys, hashlib, os

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"}

TMAP = {  # every NON Order/Refund type -> bucket (Adjustment handled by sign)
 "fba transaction fees":"Fulfillment","shipping services":"Fulfillment",
 "fba inventory fee":"Storage & inventory","service fee":"Service / program fees",
 "coupon":"Service / program fees","deal fee":"Service / program fees",
 "amazon fees":"Selling fees","safe-t reimbursement":"Reimbursements",
 "a-to-z guarantee":"Refunds (net)","chargeback":"Refunds (net)",
 "liquidations":"Other / unclassified","order_retrocharge":"Taxes (pass-through)",
 "refund_retrocharge":"Taxes (pass-through)","transfer":"Transfers (payout)",
 "debt":"Transfers (payout)","amazon charges":"Other / unclassified",
}
HEADER_TOKENS = ("date/time", "type", "total", "product sales")

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):
    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 de-duplicated list, biggest 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 analyze(rows):
    cols = {c.strip().lower(): c for c in rows[0].keys()} if rows else {}
    def C(n): return cols.get(n.lower())
    unparse = [0]
    def parse(raw):
        v = (raw or "").strip().replace(",", "")
        if v in ("", "-"):      # a blank / dash cell is a clean zero, not an error
            return 0.0
        try:
            return float(v)
        except ValueError:
            unparse[0] += 1     # genuine non-numeric text -> flagged, treated as 0
            return 0.0
    def num(r, n):
        c = C(n)
        return parse(r.get(c) or "") if c else 0.0
    cat = {k: 0.0 for k in ["Sales (gross)","Promotions","Selling fees","Fulfillment",
        "Storage & inventory","Service / program fees","Taxes (pass-through)","Reimbursements",
        "Refunds (net)","Other / unclassified","Transfers (payout)","Unrecognized"]}
    catrows = {k: 0 for k in cat}
    tcov = {}; unrec = {}
    B = 0.0; deferred = 0.0; defrows = 0; dmin = dmax = None
    for r in rows:
        t = (r.get(C("type")) or "").strip(); tl = t.lower()
        tot = parse(r.get(C("total")) or "")
        B += tot
        dt = (r.get(C("date/time")) or "").split()
        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
        if (r.get(C("transaction status")) or "").strip().lower() == "deferred":
            deferred += tot; defrows += 1
        if tl == "order":
            parts = {"Sales (gross)": num(r,"product sales")+num(r,"shipping credits")+num(r,"gift wrap credits"),
                     "Promotions": num(r,"promotional rebates"),
                     "Selling fees": num(r,"selling fees"),
                     "Fulfillment": num(r,"fba fees"),
                     "Taxes (pass-through)": num(r,"product sales tax")+num(r,"shipping credits tax")
                          +num(r,"giftwrap credits tax")+num(r,"promotional rebates tax")
                          +num(r,"marketplace withheld tax")+num(r,"Regulatory Fee")+num(r,"Tax On Regulatory Fee"),
                     "Other / unclassified": num(r,"other transaction fees")+num(r,"other")}
            parts["Other / unclassified"] += (tot - sum(parts.values()))   # catch-all: Order row reconciles
            for k, v in parts.items():
                cat[k] += v
                if abs(v) > 1e-9: catrows[k] += 1
            tcov.setdefault("Order", [0, "by column"])[0]; tcov["Order"][0] += 1
        elif tl == "refund":
            cat["Refunds (net)"] += tot
            if abs(tot) > 1e-9: catrows["Refunds (net)"] += 1
            tcov.setdefault("Refund", [0, "Refunds (net)"])[0]; tcov["Refund"][0] += 1
        elif tl == "adjustment":
            b = "Reimbursements" if tot >= 0 else "Other / unclassified"
            cat[b] += tot
            if abs(tot) > 1e-9: catrows[b] += 1
            tcov.setdefault("Adjustment", [0, "+Reimbursements / -Other"])[0]; tcov["Adjustment"][0] += 1
        elif tl in TMAP:
            b = TMAP[tl]; cat[b] += tot
            if abs(tot) > 1e-9: catrows[b] += 1
            tcov.setdefault(t, [0, b])[0]; tcov[t][0] += 1
        else:
            cat["Unrecognized"] += tot
            if abs(tot) > 1e-9: catrows["Unrecognized"] += 1
            u = unrec.setdefault(t, [0, 0.0]); u[0] += 1; u[1] += tot
            tcov.setdefault(t, [0, "Unrecognized"])[0]; tcov[t][0] += 1
    return dict(cat=cat, catrows=catrows, tcov=tcov, unrec=unrec, A=sum(cat.values()), B=B,
                unparse=unparse[0], deferred=deferred, defrows=defrows, rows=len(rows), 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}"

def render(d, src=None):
    c = d["cat"]; cr = d["catrows"]; out = []; P = out.append
    def L(v): return format(abs(v), ",.2f")          # magnitude only
    def D(v): return ("-$" if v < -0.005 else "$") + L(v)   # signed dollar
    def sgn(v): return "-" if v < -0.005 else "+"
    def rw(n): return f"{n:,} row" + ("" if n == 1 else "s")
    gross = c["Sales (gross)"]
    feesum = c["Selling fees"] + c["Fulfillment"] + c["Storage & inventory"] + c["Service / program fees"]
    kept = -feesum                                   # what Amazon kept (positive when fees are negative)
    other = c["Other / unclassified"]; unrec_tot = c["Unrecognized"]
    net = (gross + c["Promotions"] + c["Refunds (net)"] + c["Selling fees"] + c["Fulfillment"]
           + c["Storage & inventory"] + c["Service / program fees"] + c["Reimbursements"] + other + unrec_tot)

    P(f"YOUR AMAZON MONEY MAP - {period(d)}")
    P(f"Rows read: {d['rows']:,}   ✓ I read every row in your file.")
    if src: P(f"Source file: {src}")
    P("")
    if d["unparse"] > 0:
        P(f"⚠ HEADS UP: {d['unparse']} cell(s) in your file couldn't be read as a number, so these")
        P(f"  totals are INCOMPLETE. Re-download the report as CSV and run this again before")
        P(f"  relying on anything below.")
        P("")
    P("── The trust check (shown before anything else) ─────────────")
    P("   Every row's total was sorted into exactly one bucket below, and the buckets")
    P("   add back to your file's own grand total - so nothing was dropped or counted")
    P("   twice. (This confirms completeness, not that a bucket is the 'right' one.)")
    order = ["Sales (gross)","Selling fees","Fulfillment","Storage & inventory","Service / program fees",
             "Taxes (pass-through)","Reimbursements","Refunds (net)","Promotions","Other / unclassified",
             "Transfers (payout)","Unrecognized"]
    for k in order:
        label = "⚠️ Unrecognized" if k == "Unrecognized" else k
        if k == "Unrecognized" and abs(c[k]) < 1e-9 and cr[k] == 0:
            P(f"     {label:<24} {0:>6} rows   $0.00  (none - nothing unexplained)"); continue
        P(f"     {label:<24} {cr[k]:>6} rows   {sgn(c[k])}${L(c[k])}")
    P("   (Transfers = money moved to your bank; shown for completeness, not a fee.)")
    P(f"   Cells we couldn't read as a number: {d['unparse']}")
    P(f"   Sum of all categories        A = {D(d['A'])}")
    P(f"   Sum of the file's own totals B = {D(d['B'])}")
    P("   " + ("✓ A = B, to the cent - every dollar is accounted for."
             if abs(d['A']-d['B']) < 0.005
             else "✗ A doesn't equal B - something went wrong reading your file. Don't rely on "
                  "these numbers; re-download the report as CSV and run it again."))
    P("")
    P(f"Gross Sales                                          {D(gross)}")
    P("    the total value of products sold before Amazon deducted fees")
    P("")
    P("  ── What Amazon charged you in fees ────────────────────")
    for lbl, key in [("Selling fees (referral)","Selling fees"),("Fulfillment","Fulfillment"),
                     ("Storage & inventory","Storage & inventory"),("Service / program fees","Service / program fees")]:
        P(f"        {lbl:<24} {sgn(c[key])}     ${L(c[key])}")
    P("          ⚠ This bucket can include Amazon advertising and other program")
    P("            charges - this report doesn't split them out.")
    pct = f"  ·  ≈ {kept/gross*100:.0f}% of your gross sales" if gross > 0.005 else ""
    P(f"  ▓▓ WHAT AMAZON KEPT (fees)                          {D(kept)}")
    P(f"        the four lines above{pct}")
    P("")
    P("  ── Other money in and out ────────────────────────")
    P(f"        Money Amazon owed you back (reimbursements)   {sgn(c['Reimbursements'])}   ${L(c['Reimbursements'])}")
    P(f"        Refunds this period (net of fees returned)    {sgn(c['Refunds (net)'])}   ${L(c['Refunds (net)'])}")
    P(f"        Promotions / coupons                          {sgn(c['Promotions'])}   ${L(c['Promotions'])}")
    P(f"        Other / unclassified                          {sgn(other)}   ${L(other)}")
    if abs(unrec_tot) > 1e-9 or d['unrec']:
        P(f"        ⚠️ Unrecognized - worth checking              {sgn(unrec_tot)}   ${L(unrec_tot)}")
        for t, (n, s) in d['unrec'].items():
            P(f"             • {t}  {sgn(s)}${L(s)} ({rw(n)})")
    P(f"  ▓▓ NET PROCEEDS BEFORE YOUR OWN BUSINESS COSTS      {D(net)}")
    if net < -0.005:
        P("        this period, Amazon's fees and refunds added up to more than your sales -")
        P("        so this is a loss on Amazon's side, before your own costs are even counted.")
    else:
        P("        after Amazon's charges, before your own costs. This is NOT profit.")
    P("")
    P(f"  ⏳ Still held by Amazon (deferred)                   {D(d['deferred'])}")
    P(f"        {rw(d['defrows'])} earned this period but not yet paid to you -")
    P("        a timing difference, not an expense.")
    P("")
    # Check-it-yourself: signed addends that literally sum to net proceeds.
    comps = [("- $"+L(kept) if kept >= 0 else "+ $"+L(-kept)),
             (sgn(c['Reimbursements'])+" $"+L(c['Reimbursements'])),
             (sgn(c['Refunds (net)'])+" $"+L(c['Refunds (net)'])),
             (sgn(c['Promotions'])+" $"+L(c['Promotions'])),
             (sgn(other)+" $"+L(other))]
    if abs(unrec_tot) > 1e-9:
        comps.append(sgn(unrec_tot)+" $"+L(unrec_tot))
    check_val = gross - kept + c['Reimbursements'] + c['Refunds (net)'] + c['Promotions'] + other + unrec_tot
    P(f"Check it yourself:  {D(gross)}  {'  '.join(comps)}")
    P(f"                    =  {D(net)}   " + ("✓ ties to the cent" if abs(check_val-net) < 0.005 else "✗ does not tie"))
    P("")
    taxnet = c["Taxes (pass-through)"]
    if abs(taxnet) < 0.01:
        P("Sales tax: Amazon collected and remitted it (nets to $0.00), so it was")
        P("never your money and is left out entirely.")
    else:
        P(f"Heads up: your sales tax doesn't fully net out ({D(taxnet)}). Worth confirming")
        P("with your accountant. I've left it out of the map above.")
    P("")
    P("WHAT THIS REPORT CAN'T TELL YOU YET")
    P("  • Advertising can be included in 'Service / program fees' - this report")
    P("    doesn't split it out, so it's shown as one honest bucket, not guessed.")
    P("  • Product-level detail isn't reliable from this export, so no per-SKU numbers.")
    P("  • This is Amazon's side only - not your product cost or overhead - so")
    P("    'net proceeds' is not your final profit.")
    P("")
    P("THE ONE THING WORTH YOUR ATTENTION")
    bits = []
    if gross > 0.005:
        bits.append(f"Amazon kept ≈{kept/gross*100:.0f}% of your gross sales ({D(kept)}) before your own costs.")
    else:
        bits.append(f"Amazon's fees this period were {D(kept)}.")
    if gross > 0.005 and abs(c["Service / program fees"]) > 0.03*gross:
        bits.append(f"Your biggest unclear bucket is Service / program fees ({D(c['Service / program fees'])}) - "
                    "that's the one place ad spend can hide, so it's worth checking against your ad invoice.")
    if gross > 0.005 and d["deferred"] > 0.05*gross:
        bits.append(f"And {D(d['deferred'])} you earned is still held by Amazon - real, but not yet cash.")
    P("  " + " ".join(bits))
    P("")
    sig = hashlib.sha1(f"{d['rows']}|{d['A']:.2f}|{d['B']:.2f}|{kept:.2f}|{net:.2f}".encode()).hexdigest()[:10]
    P(f"TL;DR: Amazon kept {D(kept)} in platform fees, leaving {D(net)} before your")
    P("own product costs and operating expenses.")
    P(f"[Money Map 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.")
    elif 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.")
    else:
        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. At the top you'll see a trust check where every category adds back to your file's own total, to the cent. At the very bottom is 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: what Amazon charged you, what it kept, your refunds and reimbursements, and money Amazon is still holding.
What it can't see: your product costs, overhead, or advertising broken out. So "net proceeds" is not your final profit. It tells you the truth about that, too.
It never invents a number. It only sorts and adds up figures already in your report. If the math doesn'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.