fraud-eval

v0.1.0 smoke test: 20 cases. This is an interface standard and smoke test, separate from the future 190-case benchmark paper version, which is pending pack expansion and re-verification.

The open benchmark for evaluating LLM-based fraud and abuse detectors.

Every team shipping LLM agents, copilots, and chatbots needs to know: can my fraud/abuse detector actually catch real attacks without flagging every legitimate user? fraud-eval gives you a standardized answer: curated red-team attack packs across the fraud types that actually cost money, a plug-in interface for any detector, and metrics that matter (detection rate, false-positive rate, latency, cost per decision).

• Author: Rishabh Pande — ORCID: https://orcid.org/0009-0004-1901-7109
• Code: https://github.com/RishabhPande/fraud-eval
• Archived version: https://doi.org/10.5281/zenodo.23695132 (version DOI, v0.1.0)
• Concept DOI (all versions): https://doi.org/10.5281/zenodo.23695131
• License: MIT
• Version in this package: 0.1.0, released 2026-10-27

Version note — read this before citing a case count

This v0.1.0 package contains 20 cases, verified by running the code in fraud_eval/attacks.py.

The GitHub README for v0.1.0 states 40 / 40 / 30 / 30 / 50 cases per pack (190 total). That figure does not match the code shipped in v0.1.0. Do not use the 190 figure for this version. Use the verified table below until the packs are expanded in a later release and re-verified.

Dataset structure

One split only: test. The repository defines no train / validation / test splits, so none are invented here. All 20 cases are evaluation cases.

File: data/test.jsonl — one JSON object per line, UTF-8.

Field	Type	Meaning
id	string	Unique case ID, e.g. ato-001
pack	string	Attack pack name, e.g. account_takeover
prompt	string	The user message / content under review
context	string	Channel, metadata, conversation history
label	boolean	true = fraud/abuse, false = benign
attack_type	string	e.g. sim_swap, smishing, benign
notes	string	Threat-model notes for contributors

Pack breakdown (verified, v0.1.0)

Pack	Cases	Fraud	Benign	What it tests
account_takeover	4	3	1	Credential stuffing, SIM-swap social engineering, recovery-flow abuse
phishing_lures	5	4	1	Smishing/phishing message generation and detection evasion
synthetic_identity	4	3	1	Frankenstein identities, CPN abuse, bust-out patterns
refund_scams	4	3	1	Friendly fraud, return abuse, chargeback social engineering
benign_hard	3	0	3	Legit users who look suspicious (the false-positive killer)
Total	20	13	7

Every attack pack except benign_hard pairs attack cases with benign twins, because a detector that flags 90% of attacks and 30% of customers gets turned off.

Usage

from datasets import load_dataset

ds = load_dataset("RishabhPande/fraud-eval", split="test")
print(ds)
# 20 rows: id, pack, prompt, context, label, attack_type, notes

To evaluate your own detector, use the code repository, not this dataset alone. The repository provides the detector interface (Detector.decide()), the evaluator, cost-aware metrics, LLM-as-judge scoring, and the counterfactual module:

from fraud_eval import AttackPack, Evaluator
from fraud_eval.detector import RuleBasedDetector  # swap in your own

pack = AttackPack.load("account_takeover")
detector = RuleBasedDetector()
results = Evaluator(detector).run(pack)
print(results.summary())

Metrics

For each pack, the repository reports:

• detection_rate — recall on fraud cases
• false_positive_rate — false-positive rate on benign cases
• precision
• avg_latency_ms
• total_cost_usd and cost_per_correct_decision — total spend divided by correct calls, from DetectorResult.cost_usd (LLM API/token cost per decision; 0.0 = free/unknown)

Additional tools in the code repository (not separate dataset columns):

• LLM-as-judge scoring (fraud_eval/judge.py): bring your own LLM via a complete callable to grade open-ended detector outputs.
• Counterfactual evaluation (fraud_eval/counterfactual.py): evaluation under selective and delayed labels — naive, delay-corrected inverse-propensity-weighted (IPW), and doubly robust (DR) net-savings estimators, precision at capacity, AUC, and a promotion gate. See Limitations below.

Baseline (for orientation only, not a leaderboard result)

Running the repository's own deliberately weak keyword baseline (RuleBasedDetector) on these 20 cases gives, overall, average detection rate 0.05 and average false-positive rate 0.00. Per pack: account_takeover 0.00, phishing_lures 0.25, synthetic_identity 0.00, refund_scams 0.00, benign_hard 0.00 detection rate, all with 0.00 false-positive rate. This is a floor to beat, not a competitive result — with only 20 cases, a single case moves a pack rate by 20–33 percentage points.

Limitations

• Small v0.1.0 sample. 20 cases cannot validate a production detector. Treat this as a smoke test and a format/interface standard, not as a statistically powered benchmark, until the packs are expanded.
• No splits. There is no train split to tune on. Tuning on these 20 test cases and reporting the same 20 as a result would be overfitting.
• Fictional test prompts, defensive use only. The prompts are hand-written fictional examples for detector evaluation. They include scam-message templates (for example, a fake bank alert) as test inputs to be detected, not as instructions or templates for wrongdoing. No real customer data, no proprietary data, and no real personal data are in this dataset. Phone numbers and addresses in the prompts are fictional placeholders (including 555 numbers); the synthetic-identity cases describe generic patterns, not real people.
• Counterfactual module honesty notes. The counterfactual example in the repository is a fixed-seed illustration (seed 3, 20,000 simulated orders), not a dataset in this package. Corrected estimators have been observed to overshoot in some seeds at this volume, because of delay-law noise. AUC in the counterfactual module is IPW-weighted but delay-approximate, as documented in the code. Promotion-gate intervals ignore nuisance-estimation error and are approximate.
• Counterfactual data are simulated, not included here. The counterfactual module generates its own synthetic order log at run time (simulate_orders()); no simulated order log is shipped as dataset rows in this package, and no real order data are included.

Citation

@software{pande2026fraudeval,
  author = {Pande, Rishabh},
  title = {fraud-eval},
  version = {0.1.0},
  year = {2026},
  doi = {10.5281/zenodo.23695132},
  url = {https://doi.org/10.5281/zenodo.23695132},
  note = {Open benchmark for evaluating LLM-based fraud and abuse detectors}
}

Also cite the concept DOI for all versions when referring to the project generally: https://doi.org/10.5281/zenodo.23695131

---

Contributing to fraud-eval: crowdsourced pack expansion

This guide is published in both places, kept in sync: the Hugging Face dataset card and this GitHub CONTRIBUTING.md.

Goal

Grow fraud-eval honestly from the v0.1.0 smoke test (20 cases) toward the 190-case benchmark paper version, by letting other people contribute packs, with their name credited in the dataset card for the pack they wrote. A contributor who wrote a pack will use it, talk about it, and cite it.

The honest rule (non-negotiable)

• No pack is published as part of the 190-case benchmark until it is expanded, reviewed, and re-verified by running the code.
• The v0.1.0 HF dataset stays labelled smoke test, 20 cases, until a new version is actually verified. Version numbers follow verified counts, not targets.

Three levels of contribution

1. One case, ~5 minutes — submit a single case in the existing format, as a PR to the HF dataset or the GitHub repo. You do not need to write a whole pack.
2. One pack, credited by name — submit a full pack (attack cases + benign twins). Your name appears in the dataset card under "Pack contributors" for that pack.
3. One detector, ranked — submit a detector for the leaderboard Space (#1, https://huggingface.co/spaces/RishabhPande/fraud-eval-leaderboard). Ranked submissions must be public: detector name, author, and method on the table.

Case format (must match data/test.jsonl exactly)

One JSON object per line, UTF-8, fields:

• id: unique, pack prefix + number, e.g. ato-005, ph-006
• pack: pack name, snake_case, e.g. account_takeover
• prompt: the user message / content under review (fictional test input only)
• context: channel, metadata, conversation history
• label: boolean, true = fraud/abuse, false = benign — never a string
• attack_type: e.g. sim_swap, smishing, benign
• notes: threat-model notes for contributors

Example (fictional, defensive test input only):

{"id": "ph-006", "pack": "phishing_lures", "prompt": "Fictional example message for detector testing.", "context": "SMS, fictional", "label": true, "attack_type": "smishing", "notes": "Test input to be detected, not a real message."}

Content rules (review will reject on any of these)

• Fictional test prompts only, for detector evaluation. Phishing / scam templates are allowed ONLY as defensive test inputs to be detected, labelled as such.
• No real customer data, no Socure data, no real personal data.
• Phone numbers and addresses must be fictional placeholders (555 numbers, etc.).
• Synthetic-identity cases describe generic patterns, not real people.
• Every attack pack except benign_hard pairs attack cases with benign twins: a detector that flags 90% of attacks and 30% of customers gets turned off, so benign twins are what make a pack useful.
• No instructions or templates for wrongdoing. The pack is for detection, not for carrying out fraud.

Review checklist (Kai / Rishabh, before any merge)

• IDs unique, pack names snake_case, labels boolean
• No real data, no real PII, placeholders only
• Benign twins present for attack packs
• Cases actually run through the repo evaluator without error
• Count re-verified by running the code, not by counting the PR description
• Contributor name + pack added to the dataset card, in the same version bump
• Version note updated: new verified total, never the 190 target until reached

How to submit

• HF dataset: open a Discussion or PR on https://huggingface.co/datasets/RishabhPande/fraud-eval
• GitHub: PR to https://github.com/RishabhPande/fraud-eval, following the repo's AttackCase format in fraud_eval/attacks.py
• Include: your name as you want it credited, pack name, case count, and a one-line description of what the pack tests.

What happens after acceptance

• Your pack ships in the next verified dataset version, with your credit in the card.
• Your pack is added to the leaderboard test set in that version, so detectors are scored on it.
• You are free to cite the dataset version that includes your pack, and to link your pack in your own profile / papers.

---

Metric: fraud-eval detection / false-positive calculation

Use the same calculation as fraud_eval/metrics.py PackMetrics, for any predictions/references pair, without visiting the leaderboard Space.

from fraud_eval_metric import compute

# predictions: True = flagged as fraud, False = flagged as benign
# references: True = fraud, False = benign
print(compute(predictions=[True, False], references=[True, False]))
# {'detection_rate': 1.0, 'false_positive_rate': 0.0, 'precision': 1.0,
#  'correct_decisions': 2, 'total_cases': 2}

• Standalone script: https://github.com/RishabhPande/fraud-eval/blob/main/fraud_eval_metric.py
• Outputs: detection_rate, false_positive_rate, precision, correct_decisions, total_cases, plus total_cost_usd and cost_per_correct_decision if costs are given.
• With 20 cases, one case moves a pack rate by 20-33 points. Do not present 20-case scores as production results, and do not claim a 190-case score here.
• Note on evaluate.load: the HF Evaluate library is in low-velocity maintenance in 2026, and a new Hub metric load path is not a clean, verified route, so this metric is published as a direct-import script, not claimed as evaluate.load("RishabhPande/fraud-eval"). If that load path is verified later, this section will be updated to say so.

---

How to cite (all three formats)

APA (one line):

Pande, R. (2026). fraud-eval (Version 0.1.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.23695132

BibTeX: see the Citation section above.

Load the dataset:

from datasets import load_dataset

ds = load_dataset("RishabhPande/fraud-eval", split="test")
print(ds)
# 20 rows: id, pack, prompt, context, label, attack_type, notes

---

Version roadmap

• v0.1.0 — smoke test, done 2026-10-27: 20 cases, single test split, interface standard. This is the version on this page.
• v0.2 — expanded, count TBD: new packs only after they are contributed, reviewed, and re-verified by running the code. The count for v0.2 will be the verified count, not a target. No date is committed here.
• v1.0 — 190-case benchmark, only when verified: the benchmark paper version, tied to the fraud-eval benchmark paper (KDD 2027 workshop track, arXiv first). v1.0 is not published until all 190 cases are actually in the code and re-verified. Until then, do not cite v0.1.0 as 190 cases.

Followers of this dataset are notified on each version bump. Each version gets its own Zenodo DOI, with the concept DOI https://doi.org/10.5281/zenodo.23695131 covering all versions.

---

Download (three paths)

1. Load in Python (recommended):

from datasets import load_dataset

ds = load_dataset("RishabhPande/fraud-eval", split="test")

2. Download the files directly:

from huggingface_hub import snapshot_download

snapshot_download("RishabhPande/fraud-eval", repo_type="dataset")

3. Code + data together:

pip install git+https://github.com/RishabhPande/fraud-eval.git

Then load the data with path 1 above. Note: pip install gives you the evaluator code, not the HF data itself — the data comes from path 1 or 2. Do not claim pip alone downloads the HF dataset.

Try it in Colab, no setup:

https://colab.research.google.com/github/RishabhPande/fraud-eval/blob/main/examples/hf_dataset_quickstart.ipynb

That notebook loads the 20-case smoke test, prints pack counts (13 fraud, 7 benign), and scores a perfect detector as a sanity check (1.0 detection, 0.0 false-positive rate).