syntheticcfo/synthetic-cfo-sample

synthetic cfo public sample: a labelled SAP ECC fiscal year

synthetic cfo generates SAP and Oracle ledgers from accounting rules, with fraud planted, every planted record written down at the moment it is planted, and innocent look-alikes beside nearly every scheme, so fraud detection can be trained and measured without a single real record.

This is one of its worlds: one complete synthetic company for one fiscal year on SAP ECC table shapes, with the fraud recorded in a ground-truth answer key. No real company or personal data at any stage. There is no original: nothing was sampled, masked or anonymised.

Engine version 1.15.0. 18 tables, 12,028 rows, 38 labelled fraud records across 18 distinct schemes. On the same engine version, the same seed and configuration regenerate every file byte for byte; a newer engine builds a different dataset, and its certificate names the engine. data/checksums.sha256 lets you check this copy.

This is the data layer of the platform's public sample: the tables and the answer key, exported as JSON lines. The full four-layer package the same world ships in (whitepaper, articulated financial statements, forensic audit report, SQLite database, source workbooks) is the free download at https://app.syntheticcfo.com/sample (it asks for an email address), and the worked proof is at https://app.syntheticcfo.com/proof.

To make worlds of your own, a free account (no card) generates them at https://app.syntheticcfo.com/?signup=1, or from code after pip install syntheticcfo. The starter notebook on Kaggle, https://www.kaggle.com/code/syntheticcfo/find-the-fraud-then-score-yourself, scores two detectors against this key, and https://app.syntheticcfo.com/evaluate shows how to score your own.

What is in it

data/tables/ holds one JSON-lines file per table, named as the ERP names them: purchasing (EKKO, EKPO), goods movements (MSEG), accounting documents (BKPF, BSEG), the cheque register (PAYR), vendor master (LFA1), change documents (CDHDR, CDPOS), sales (VBAK, VBAP, VBRK), open receivables (BSID), the document flow (VBFA), customer master (KNA1), employee bank details (PA0009) and the tax remittance subledger (TAX_BKPF, TAX_BSEG).

data/answer_key.jsonl is one row per labelled record: module, control_id, fraud_vector, source_table, record_id, detail. It joins back to the data on source_table and record_id.

data/DATASET_CARD.md is the card the platform writes for every export (provenance, composition, the record id convention, licence).

data/Reproducibility_Certificate.txt is the source package's own certificate: the engine version, seed and configuration that made this world, and a SHA-256 for each file of that package. It names package files (the database, the workbooks, the reports), not the JSON-lines files here. Those are covered by data/checksums.sha256. The /sample download is built from the same seed and configuration, but its PDFs and workbooks carry a SAMPLE watermark, so their digests differ from the certificate's, and it ships a note in place of a certificate. A package you generate on an account carries a certificate of its own.

What is deliberately not in the tables

This world is built in the platform's evaluation mode, which is the shape a detector should be scored on. Four ground-truth marker columns that the engine writes for its own use, and which name a scheme outright on exactly the rows that carry one, are not in the tables. Neither is the risk-map view built on top of them.

The expert annotation layer, a written accounting rationale attached to records, is not deleted. It is relocated whole into the source package's audit evidence folder as SME_Reasoning.csv, keyed by table and record id, so it can be joined back deliberately by anyone who wants it and cannot be read accidentally by a model training on the tables.

The answer key ships in full either way. Nothing about which records are fraudulent is hidden from you. What is removed are the marker columns that name a scheme on its own rows, which is the difference between a dataset you can measure a detector on and one where the detector can read the answer off the rows. A single field can still isolate a scheme built on one account (phantom revenue here, see the limitations), so a detector still has to find that account from how it behaves.

If you want the marker columns, generate your own world with evaluation mode switched off. They are an engine extension rather than an ERP dictionary field, and the platform lists them openly.

Why it is useful for research rather than demonstration

The labels are recorded when each scheme is planted, never derived afterwards by querying the finished data. That matters because a derived label is a tautology: if every open receivable is labelled fraud, a rule that flags open receivables cannot be wrong and a model learns something false about every real ledger.

Innocent look-alikes are planted beside nearly every scheme. Receivables that are simply not yet due sit beside the phantom revenue. Cheques voided over a misprint and reissued sit beside the voided cheque that was never replaced. Rent invoiced with no purchase order sits beside the invoices that should have had one. So precision is measurable: a detector can be wrong.

This sample carries two of the engine's three deliberate closed sets, where the join is the analytic and an innocent instance cannot exist by construction: a user who both entered and approved the same document (C-02), and a supplier bank account shared with an employee (C-10). The third, phantom inventory, belongs to the inventory module, which the sample does not include. They are named here rather than hidden. A model scoring perfectly on those has rediscovered a query, not found a fraud.

Published baselines on this exact data

Three detectors of different skill, run against a copy with the answer key physically absent, then scored:

Detector	Precision	Recall	F1	Flags on a fraud-free twin
Generic statistical anomaly detection	0.02	0.16	0.03	422
Textbook audit rules	0.07	0.53	0.12	293
Targeted forensic rules (a ceiling, written by the engine's author)	0.10	1.00	0.18	358

Fraud is a small share here, about 3 in 100 of each module's records at the medium level, which is still far denser than a real ledger, so precision measured here is an upper bound on what a detector would see in production. The innocent look-alikes are part of the ordinary business and do not shrink with the fraud, so every rule tier flags far more innocent records than planted ones, and even the ceiling, which finds every planted record on this world, is right about one flag in ten. The first row is still the point: this fraud is behavioural, not large, and a digit or outlier test does not see it. The full experiment: https://app.syntheticcfo.com/proof

Loading it

import pandas as pd
bkpf = pd.read_json("data/tables/P2P_BKPF.jsonl", lines=True, dtype={"BELNR": str})
key = pd.read_json("data/answer_key.jsonl", lines=True, dtype={"record_id": str})
labelled = bkpf.merge(key[key.source_table == "P2P_BKPF"],
                      left_on="BELNR", right_on="record_id", how="left")

Read document numbers as strings. A numeric parse drops leading zeros and the join silently fails.

Limitations, stated plainly

• One company, one year, one platform, one jurisdiction (Germany, IFRS, VAT), two cycles. It proves quality and is deliberately too small to be a training corpus on its own.
• The sample carries the purchase-to-pay and order-to-cash subledgers and the tax remittance subledger only. It has no record-to-report layer, so there is no general ledger journal layer and no trial balance in it: its ledger integrity is that every posted document balances (P2P_BSEG, TAX_BSEG) and every key between two tables the sample ships resolves. Seven references point at master tables that ship with modules the sample does not carry, so they resolve in a package with those modules and not in this one: the material number (P2P_EKPO.MATNR, P2P_MSEG.MATNR, O2C_VBAP.MATNR) at the inventory module's material master, the house bank (P2P_PAYR.HBKID) at the treasury module's bank master, the personnel number (HR_PA0009.PERNR) at the payroll module's personnel master, and the posting account (P2P_BSEG.HKONT, TAX_BSEG.HKONT) at the record-to-report module's chart of accounts. The README inside the sample zip from https://app.syntheticcfo.com/sample says exactly that, measured on its database (this listing carries the lab export of the same world, not that zip). A generated dataset that includes record-to-report carries two accounting layers: the operational subledgers feed the financial statements, and the R2R overlay posts its own trial balance without being re-consolidated with them, so that trial balance ties to the general ledger journal layer and never to the payables or receivables documents. The platform's ERP twin says so on its integrity screens.
• Phantom revenue (C-20) sits on a single customer account that exists only for the scheme, so that account's id separates it once a detector has found the account; finding it from how the account behaves is the work.
• The innocent look-alikes share a scheme's condition, not always its whole stated rule: for some controls the forensic report's own stated rule returns exactly the labelled records on this world, and data/DATASET_CARD.md names them, measured. A perfect score there may be a rediscovered rule rather than a found fraud.
• Volumes are calibrated to plausible ratios, not to any particular company.
• It is a fiscal-year extract taken during the following close, so open items are open for the reasons a real extract has open items.

Method

Deterministic generation from accounting rules, in Python. No language model produces any field in the data. The platform's first rule is that a model may only translate a plain-language request into a validated configuration, which deterministic code then executes.

Licence and terms

Free for evaluation and non-commercial research, including publishing results on it with a citation. Not to be redistributed as files, resold, or used to train or evaluate a competing product. Full terms: https://app.syntheticcfo.com/terms

Citation

synthetic cfo. Public sample: a labelled SAP ECC fiscal year. Generated with the synthetic cfo cold start engine, version 1.15.0, 2026. https://app.syntheticcfo.com/sample