Skip to content
AvraAvra
Esc
↑↓navigate↵open⌘Jpreview
On this page

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.

Row by row: every account passesaccount_idopened_atchecks3318Mar 02pass5402Mar 03pass0771Mar 03pass9124Mar 05passAs a network: one ring3318540207719124dev 77addr 12shared deviceshared address
Four accounts that pass every row-level check. Through their keys, all four share one device and three share one address: one ring, not four customers. Illustrative data.
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.

Where to go next

Was this page helpful?