Amazon Promo Leak Monitor - Flag Leaks with Proof

Extract leaked Amazon promo and coupon codes from public deal pages into evidence rows. Paste one seller allow-list in, get one row per verified leak or stack abuse with source URL, timestamps, and a verify-before-act notice — clean polls stay silent at $0.

Click Try for free — input opens prefilled. Start as-is, check rows, then raise the allow-list.

What it does

Monitors your private, influencer, and email promo codes against public coupon and deal pages, and flags every allow-list match as a typed evidence row. Built for Amazon sellers who run promo-code campaigns and need proof — not rumors — before acting.

• Allow-list leak flags — private or email codes spotted on public pages, one row per code with evidence URL
• Stack-abuse flags — code-plus-coupon combinations with worst-case stack math attached
• Clean polls stay silent — no code visible means zero rows at $0, never a guessed price
• Expired codes ignored — expired allow-list entries are decorative and never bill
• Evidence on every row — source URL, first-seen and checked timestamps, verify-before-act notice
• Per-run spend cap — a dollar cap that stops spend and holds state when tripped
• Free one-shot check — one code plus one deal page, $0, before you commit to the full watch

Quick start

1. Click Try for free — the input opens with a demo allow-list prefilled (a $0 first run).
2. Replace the demo ASINs and codes with your own allow-list (keep checkHours: 6).
3. Leave observed empty for the first run: it returns zero rows, $0, quiet — proof the actor boots.
4. Click Save & Start, then open the Dataset tab for evidence rows and the Key-value store OUTPUT record for the run summary.
5. Re-run with your full allow-list: every caught leak bills $0.03 per row, clean polls stay $0, capped at $3 per run.

Input

Minimal copy-paste input (required fields only, matches the Console prefill exactly):

{
  "configId": "demo-seller-01",
  "brandAsins": ["B012345678", "B0ABCDEFGH"],
  "groupCodes": [
    { "code": "SAVE20", "scope": "private", "expiresAt": "2027-06-01T00:00:00.000Z" },
    { "code": "INFLU10", "scope": "influencer", "expiresAt": "2027-06-01T00:00:00.000Z" }
  ],
  "checkHours": 6,
  "stackWatch": true,
  "maxTotalChargeUsd": 3
}

Full input with all optional fields:

{
  "configId": "demo-seller-01",
  "brandAsins": ["B012345678", "B0ABCDEFGH"],
  "groupCodes": [
    { "code": "SAVE20", "scope": "private", "expiresAt": "2027-06-01T00:00:00.000Z" },
    { "code": "INFLU10", "scope": "influencer", "expiresAt": "2027-06-01T00:00:00.000Z" }
  ],
  "checkHours": 6,
  "stackWatch": true,
  "maxTotalChargeUsd": 3,
  "capMode": "capped",
  "sellerRef": "demo-seller-ref",
  "observed": {
    "checkedAt": "2026-09-28T12:00:00.000Z",
    "observations": [
      { "code": "SAVE20", "codeScope": "private", "sourceUrl": "https://deals.example.invalid/t/save20-leak-4821" }
    ]
  }
}

field	type	required	default	units	limits
configId	string	yes	—	—	lowercase letters, digits, dashes; 1–64 chars; scope/state key, use a fresh value per watch list
brandAsins	array of string	yes	—	ASINs	1–30 items; each B0 + 8 uppercase letters/digits
groupCodes	array of object	yes	—	codes	max 50; each needs code (1–64 chars), scope (email, influencer, private), expiresAt (RFC 3339 UTC)
checkHours	integer	yes	6	hours	only 6 accepted (fixed 6-hour sweep cadence)
stackWatch	boolean	yes	true	—	false = leak flags only, stack math suppressed
maxTotalChargeUsd	number	yes	3	USD	0–3; per-run spend cap and cost ceiling
capMode	enum	no	capped	—	capped (default, max $3 for up to 100 rows) or complete-input (entire allow-list; worst case $Y = codes × $0.03 quoted before any charge, never above the frozen $1.50 ceiling)
sellerRef	string	no	—	—	max 64 chars; opaque reference, never a credential
observed	object	no	—	—	frozen observation replay for smoke/demo runs only (checkedAt + observations of code/codeScope/sourceUrl plus optional couponPercent/codePercent); omit for the quiet boot

Job-titled recipes (one line each):

• quiet boot — the minimal JSON above with no observed: zero rows, $0, quiet
• seller leak audit — minimal JSON plus observed with your frozen observation set: leak + stack rows with proof
• leak-only watch — same as audit with "stackWatch": false: stack math suppressed, leaks only
• expired-code cleanup check — include an expired entry in groupCodes: it is ignored and never bills

Output

Every run writes one summary record to the default key-value store (OUTPUT key: rows, per-config report, billing tally, typed misses, quiet flag) and mirrors each verified leak/stack row as a typed evidence item to the default dataset (quiet runs write zero dataset rows).

Alias map: KV rowType means dataset leakClass (leak = allow-list code seen off-list with evidence, stack = code plus verified coupon with worst-case math); KV sourceUrl means dataset evidenceUrl (the same evidence page URL). Canonical for all new keys is leakClass + evidenceUrl.

Dataset item fields (one item per verified flag):

field	type	notes
rowId	string	stable row key {configId}:{code}:{codeScope}
sellerRef	string	your opaque reference echoed back
asin	string	representative brand ASIN (first allow-list entry)
code	string	promo code text exactly as observed
codeScope	enum	email, influencer, or private
leakClass	enum	leak or stack
evidenceUrl	string	public page where the code was seen
firstSeenAt	string	first-seen timestamp (UTC)
checkedAt	string	verification timestamp (UTC)
notice	string	verify-before-act notice
billableEvent	string	verified-leak-or-stack-alert
billedAmountUsd	number	0.03 per row
discountDepth	number	stack rows only; observed discount percent, never estimated
worstCaseStackMath	string	stack rows only; worst-case combination math

Real example rows (shortened for viewing — timestamps and notice text abridged):

{ "rowId": "demo-seller-01:SAVE20:private", "code": "SAVE20", "codeScope": "private", "leakClass": "leak", "evidenceUrl": "https://deals.example.invalid/t/save20-leak-4821", "firstSeenAt": "2026-09-28T06:00:00.000Z", "checkedAt": "2026-09-28T12:00:00.000Z", "notice": "allow-list leak with evidence URL — verify-before-act", "billableEvent": "verified-leak-or-stack-alert", "billedAmountUsd": 0.03 }

Rows shortened for viewing. The KV OUTPUT record carries sourceUrl per row; the dataset mirror carries the same URL as evidenceUrl plus sellerRef, asin, and the per-row billing stamp. Walled, dead, or timed-out sources are reported as typed misses in the OUTPUT record — never a guessed row. Malformed input is rejected at the schema gate before any spend; a run with no loaded config reports a rejection detail and bills nothing.

How much will it cost?

From $30.00 per 1,000 verified rows. The billable event is verified-leak-or-stack-alert: one unit bills per evidence row published. Clean polls, typed misses, expired-code observations, and seed runs emit zero rows and bill $0.

plan	$ per 1,000 verified rows
Free / Starter / Scale / Business	$30.00 / $30.00 / $30.00 / $30.00

Single meter on all plans; the Console Pricing tab is authoritative.

Worked math:

• Small run, 2 flags (1 leak + 1 stack): 2 × $0.03 = $0.06 per run
• Quiet week, 0 new flags: $0.00 (silence is the correct output, not a failure)
• Busy run, 10 flags: 10 × $0.03 = $0.30, still far under the cap
• Monthly projection, one sweep a day averaging 1 flag: ~30 rows ≈ $0.90/mo
• Worst case per run: the $3 cap holds at most 100 rows per run — spend stops, state is held, and counts are still published when the cap trips
• Complete-my-input run, full 50-code allow-list: worst case 50 × $0.03 = $1.50, quoted before any charge, never above the frozen $1.50 ceiling

Cap, floor, and quiet costs: maxTotalChargeUsd (max $3) is the cost ceiling — set it lower to bound any run further. Billing respects the platform max-charge setting and stops on the charge limit. There is no minimum per run beyond the platform floor; failed, empty, and quiet runs are not billed for rows. Quiet costs disclosed: each run start carries the platform actor-start event plus standard compute units — row charges ($0.03 each) apply only to published evidence rows.

Completeness mode (capMode): capped (default) keeps the promise above verbatim — max $3 for up to 100 rows, trip lands SUCCEEDED with counts only. complete-input processes your entire allow-list in one run: the run's first log line and the OUTPUT record quote your actual worst case $Y (your codes × $0.03) before anything bills, and spend never exceeds the frozen $1.50 ceiling (50 codes × $0.03 — $Y above $1.50 fails closed to capped). One click, no billing field, no human; your billing pin still lowers any run, and schedules/task runs always run capped. Every trip lands SUCCEEDED with counts only and state held.

event:verified-leak-or-stack-alert | $/1k 30.00/30.00/30.00/30.00 | includes_usage:true | billed_on_empty:false | caps:[maxTotalChargeUsd] | quiet:[actor-start]

Trial

Start free: run once with 1 allow-list code plus 1 deal page as a one-shot check per watch list — $0, no card required. The free check returns the same evidence-row shape as the paid watch, so you can verify the output before spending anything.

• First use per watch list runs the free check ($0, nothing charged, state recorded).
• A second check on the same list runs as the full watch: $0.03 per verified row, clean polls $0, per-run cap $3.00.
• As a yardstick, $5 of platform credit covers about 166 verified rows at this meter.

Click Try for free — input opens prefilled. Start as-is, check rows, then raise the allow-list.

Compatibility

Works with any public promo or coupon page you allow-list. Verified live:

• Private-scope leak flag — lululemon Like New, Oct 2026 — one allow-list leak flagged with proof
• Influencer-scope stack flag — NVIDIA promo page, Oct 2026 — one stack flagged with proof, worst-case math attached
• Clean pages stay silent — verified quiet pair, Oct 2026 — no code visible means zero rows at $0, never a guessed price

Not covered: login-walled or bot-walled deal sources, dead or timed-out transports. These return typed misses — never a guessed price. Every flag carries source URL, timestamps, and a verify-before-act notice.

Not affiliated with NVIDIA or lululemon; third-party names belong to their owners, no endorsement or sponsorship implied.

What people use it for

• Seller promo-leak watch — daily sweep of your private codes against public coupon pages
• Influencer-code abuse check — catch influencer codes stacked with site coupons, with worst-case math
• Pre-campaign baseline — quiet boot first, so later runs emit only new leaks
• Leak-only monitoring — stackWatch: false for sellers who want leaks without stack math
• Allow-list hygiene — expired codes surface as ignored, so you can prune them

What this Actor does NOT do

• Does not change your codes, prices, or listings — read-only comparison with evidence
• Does not read login-walled or bot-walled deal sources — those return typed misses, never guessed rows
• Does not edit Amazon listings or pull codes down — every flag ends with a verify-before-act notice
• Does not guess discount percentages — stack math appears only when both percentages are observed

Use with schedules, webhooks, API, and MCP

Schedule a daily watch (alert only when new rows appear):

{ "configId": "my-shop-watch", "brandAsins": ["B012345678"], "groupCodes": [{ "code": "SAVE20", "scope": "private", "expiresAt": "2027-06-01T00:00:00.000Z" }], "checkHours": 6, "stackWatch": true, "maxTotalChargeUsd": 3 }

Webhook pattern — fire downstream only when rows exist (pseudo-code on the run's OUTPUT record):

const output = await keyValueStore.getRecord('OUTPUT');
if (!output.quiet && output.rows.length > 0) await notify(output.rows);

Call the API (one-liners):

$curl -X POST "https://api.apify.com/v2/acts/steadyworks~amazon-promo-leak-monitor/runs?token=$APIFY_TOKEN" -H "Content-Type: application/json" -d '{"configId":"my-shop-watch","brandAsins":["B012345678"],"groupCodes":[{"code":"SAVE20","scope":"private","expiresAt":"2027-06-01T00:00:00.000Z"}],"checkHours":6,"stackWatch":true,"maxTotalChargeUsd":3}'

run = client.actor("steadyworks/amazon-promo-leak-monitor").call(run_input={...})
rows = run["defaultDatasetId"] and client.dataset(run["defaultDatasetId"]).list_items().items

const run = await client.actor('steadyworks/amazon-promo-leak-monitor').call({ ...input });

Connect via MCP (agent dispatcher config):

{ "mcpServers": { "apify": { "command": "npx", "args": ["-y", "@apify/mcp-server"], "env": { "APIFY_TOKEN": "<your-token>" } } } }

Then call the steadyworks/amazon-promo-leak-monitor Actor through the Apify MCP tools with the input above. Note: actor calls return immediately — poll the run or use a webhook for completion, never block longer than ~45 seconds waiting.

Troubleshooting

symptom	cause	fix
0 rows on first run	Fresh key boots quietly by design (zero rows, $0)	Expected — re-run with the observed replay or your live allow-list to see flags
0 rows every run	No code visible on the checked pages (clean poll)	Correct output, billed $0 — verify the observation set covers the right pages
Input rejected, run ends immediately	ASIN pattern, checkHours not 6, or missing required field	Match the Input table: ASINs B0 + 8 chars, checkHours: 6, RFC 3339 expiresAt
Run stops at the spend cap	maxTotalChargeUsd tripped (spend stops, state held, counts published)	Lower the allow-list size or raise-and-rerun with a fresh configId
Expired code never flags	Expired entries are decorative by design	Renew or remove the code; it will never bill
Walled/dead source, no row	Login wall, bot wall, or dead transport → typed miss	Check the OUTPUT record misses; use a public readable page — misses never bill

FAQ

Does this change my data? No — read-only. It compares your allow-list against observed public pages and writes evidence rows; it never edits listings, codes, or prices.

How much does one check cost? The free one-shot check (1 code + 1 deal page) is $0. After that, $0.03 per verified row; a 2-flag run is $0.06; quiet runs are $0; no run exceeds the $3 cap.

What are the limits? Up to 30 ASINs and 50 group codes per run; checkHours fixed at 6; at most 100 billed rows per run under the $3 cap.

Does it work behind logins? No. Login-walled or bot-walled sources return typed misses, never guessed rows.

What personal data does it process? None beyond what you supply: promo-code strings, ASINs, and public page URLs. No buyer credentials are ever requested or stored.

Is scraping these pages allowed? The actor reads only public pages and never bypasses access controls. Every flag carries a verify-before-act notice — confirm a leak on the live page before acting, and respect each site's terms.

Legality

Reads public promo and coupon pages only; no login bypass, no credential handling, no personal-data collection. Store names in the Compatibility block belong to their owners — no affiliation, endorsement, or sponsorship implied. Verify each flag on the live page before acting.

Other Actors you might need

need	what to do instead
One-off single-code check	Run this Actor once with 1 ASIN + 1 code (the free check)
Leaks only, no stack math	Same Actor with "stackWatch": false (leak-only mode)
Restock or price tracking	Search the Apify Store for a restock or price monitor — this Actor covers promo-code leaks only
Full-site coupon crawl	This Actor compares an allow-list against observations; it is not a general site crawler

Changelog and support

./CHANGELOG.md — 2026-10-02 entries cover the adoption baseline and the dataset evidence mirror. Questions or wrong-fit reports: use the Issues tab on the Store listing.