Fraud detection
Catch the ring, not just the row. Collusion and shared structure that row-level models can't reach, ranked into the queue your analysts already work.
Fraud decisions come one record at a time: open this account or hold it, let this payment through or stop it, review this case before that one. This page shows how to frame those decisions as prediction problems over your own tables, how the scores reach your rules and your review queue, and how to measure them before they decide anything.
Fraud is a network problem
Rules and row-level models judge each record on its own, and that’s how they catch known patterns. Coordinated fraud is built to pass that test: every application looks clean, and every account looks legitimate.
The structure behind them doesn’t. Shared devices, shared owners, shared addresses, and coordinated timing are invisible row by row and plain as a network.
| Pattern | Row-level view | Relational view |
|---|---|---|
| Shell companies | Clean registration, no red flags | Connections, a few hops away, to known bad actors |
| Identity fraud | Valid documents, matching records | Unusual ownership networks and address clusters |
| Bust-out schemes | A good payment history building up | A trajectory toward known fraud patterns |
| Collusion rings | Unrelated, legitimate-looking accounts | Shared structure and coordinated behavior |
Avra RFM reads four kinds of signal from your tables:
| Signal | What it shows |
|---|---|
| Records | Registration anomalies, address inconsistencies, ownership patterns, and activity that doesn’t match the declared business |
| Relationships | Counterparties, ownership chains, and infrastructure shared with other accounts, several hops away |
| Behavior | Transaction velocity and payment patterns, compared with similar legitimate records |
| Time | How a record is changing. Fast changes in who an account connects to often come before fraud or distress |
For Brazilian companies, Avra GFM embeddings can add company-level context from outside your data, such as ownership structure, to your own fraud models.
The data
A fraud model reads the tables that connect an account to the people behind it, the devices and addresses it uses, and the payments it sends and receives, with your confirmed cases as labels. The schema below is illustrative. The RFM reads yours as it is, and the keys between the tables are what bring the shared structure into view. See Relational data.
Two accounts that never transact can still share a device through their sessions, or an address through their registration. The _at columns are event times: when each row happened. Every table also carries its snapshot time, when your systems recorded the row, so a prediction sees only what was known on its date. See Time and history.
| Data | Purpose |
|---|---|
| Fraud labels | Confirmed fraud and confirmed legitimate cases from your history; they define what fraud means for you |
| Accounts and events | Applications, sessions, payments, devices, and addresses, with the keys that link them |
| Outcomes over time | When each case was confirmed, so evaluations only see what was known at the time |
A case still under investigation is neither fraud nor legitimate yet. Send it once it’s confirmed, with the date it was confirmed.
The prediction problem
Each fraud decision becomes a question with three parts: who is scored, the outcome, and the window it must happen in. These are three common ones:
| Decision | Who is scored | Outcome | Window |
|---|---|---|---|
| Onboarding | Each account opened recently | Confirmed as fraud | 7 days |
| Payments | Each payment, as it happens | Confirmed as fraud | 30 days |
| Portfolio screening | Every active account, on a schedule | A confirmed fraud case | 90 days |
The window decides which fraud the target covers. A short one yields labels sooner but covers only fraud that surfaces fast. A longer one also covers schemes that build up slowly, such as bust-outs, and its labels take longer to arrive: a confirmed case counts as a labelled example only once its window has closed, so a 30-day payment label becomes usable 30 days after the payment. See What you can predict.
From score to decision
The score ranks, and your rules decide. Set the thresholds from your own outcomes and from how many cases your analysts can review in a day.
The queue is where the ranking pays off. Analysts work the highest scores first, so the cases most likely to be fraud get reviewed while there’s still time to act. Every case they close becomes a label: send it through data ingestion with the date it was confirmed, and later predictions can use it as a labelled example once its window has closed.
How it’s evaluated
Every model is backtested out of time on your history: it predicts at past dates, sees only what was known on each date, and is scored on the cases confirmed afterward. Its results are compared with the rules or model you run today. Then it runs in shadow on live traffic before it decides anything. See Evaluation.
| Metric | What it tells you |
|---|---|
| PR-AUC | The precision and recall trade-off across all thresholds. The main metric, because fraud is rare |
| ROC-AUC | Overall separation between fraud and legitimate activity |
| False-positive rate at a fixed recall | How many legitimate customers get flagged at the catch rate you want |
| Precision at your review capacity | How many of the cases your team can review in a day turn out to be fraud |
Integration
| Moment | Path | How it’s used |
|---|---|---|
| Onboarding | Live predictions | Screen new accounts and counterparties before the relationship starts |
| Transactions | Live predictions | Score payments as they happen, through the API |
| Portfolio screening | Batch inference | Rescore existing relationships on a schedule |
| Investigations | Live predictions or batch | Prioritize the queue when suspicious activity is flagged |
What a model returns, and its field names, are set per model and listed in the model version’s schema. Read the schema of the version behind production before you integrate:
curl https://api.avra.ai/v1/api/models/{model_id}/versions/production \
-H "Authorization: Bearer $AVRA_API_KEY"
The schema lists the version’s inputs and outputs, each with a name, a type, whether it’s optional, and an example. Before you score payments live, check the rate limits against your payment volume.
Embeddings for your own fraud models
If you run your own fraud models, GFM embeddings can join their features. Because the embeddings can be shortened, the same vectors can serve both: short vectors (64–128 dimensions) for real-time scoring, where latency matters on every payment, and full vectors (512–1024 dimensions) for deeper review of the company behind an account.
Distance from a segment’s typical position in the embedding space can serve as an anomaly feature. See Applications.