Decide who gets through, in milliseconds
FraudZero is an anti-fraud rules engine. You describe the data you receive, write the rules that score the risk — in plain language, with words instead of symbols — and on every request the platform answers with a score from 0 to 100, the risk band and the signals behind it.
One rule, two ways to write it
Write the script or draw the flowchart. One of them is the source of truth — the other is generated — and you decide which, rule by rule.
Flowchart
Code
param inicio = 6
desc_pt="Hora de abertura do Pix"
desc_en="Pix opening hour"
desc_es="Hora de apertura del Pix"
param fim = 22
desc_pt="Hora de fechamento do Pix"
desc_en="Pix closing hour"
desc_es="Hora de cierre del Pix"
let hora = toNumber(input.hora)
let fora = hora < inicio or hora >= fim
let risco = input.mcc is 7995 or input.mcc is 6051
if input.tipo is "pix" and fora and risco {
Score(80,
msg_pt="Pix em MCC de risco",
msg_en="Pix at a risky MCC",
msg_es="Pix en un MCC de riesgo")
} else if input.tipo is "pix" and fora {
Score(30,
msg_pt="Pix fora de hora",
msg_en="Pix outside allowed hours",
msg_es="Pix fuera de horario")
}Evaluation response
- PT
- Pix em MCC de risco
- EN
- Pix at a risky MCC
- ES
- Pix en un MCC de riesgo
Words, not symbols
and, or, is, between, in. A rule speaks through Score, with the points and the reason; reaching the end without one is zero — there is no "approve" or "deny" to write.
The editor knows your input
After input. it offers the fields you declared, and only those. A syntax error is underlined on the right column, before you save.
One truth at a time
In drawing mode the server compiles the blocks into a script on save. In text mode the drawing is ignored and never even stored.
Three engines, three scores
Each engine evaluates the transaction its own way, independently, and returns its own score. The caller chooses which one to use.
Rules engine
Rules written by you, in plain language. The score comes explained, signal by signal.
- You decide every criterion
- Answers in milliseconds
- 161 free rules in the marketplace
Machine learning engine
A model that learns from the history of confirmed fraud and gives its own score.
- Learns from your labels
- Finds patterns no rule describes
- A score independent from the rules
LLM engine
A language model that reads the context of the transaction and gives the score with a written justification.
- Explains the decision in words
- Considers the whole context
- A score independent from the other two
All three run at the same time, each one validates on its own and builds its own score; your application decides which one to use.
Every transaction, in one graph
On one side, the path it took through the rules to reach its score. On the other, the purchases linked to it by the same card, terminal or store. It is what the analyst sees when opening an evaluation.
Selected circle
Click any circle to read what it stands for.
Transaction under evaluation
The purchase being analysed. The number is its risk score, from 0 to 100, made up by the rules that scored.
Rule that added points
A rule of the input that found what it was looking for in this transaction and added its points to the score.
Rule that did not score
A rule that ran and found nothing. The number is the order in which it ran.
Shared payment data
A piece of payment data that repeats across purchases, such as the card, the terminal or the store. Every transaction carrying the same value is linked to this circle, and it is through it that an old fraud shows up next to a new purchase.
Confirmed fraud
An earlier transaction that an analyst marked as fraud. Being linked to it is the strongest signal in the drawing.
Legitimate transaction
An earlier transaction confirmed as good.
Under review
A transaction still in the investigation queue, with no conclusion yet.
- The transaction under evaluation, with its score
- Rule that added points
- Rule that ran and did not score (the number is the order)
- Shared payment data: card, terminal, store, BIN, MCC, acquirer
- Confirmed fraud
- Legitimate transaction
- Under review
How to read the graph
On the left, the rules in the order they ran; the purple ones added the points of the score.
On the right, the payment data the transaction shares with others, and those others.
A confirmed fraud nearby is the signal the analyst is looking for.
Rules from those who already solved it
One company publishes a rule; another acquires the one that fits its input. As an editable copy or as use-only — and the script never leaves whoever wrote it. The rules in the ByteZero catalog are free of charge.
POS — Contactless purchases split below the limit
VerifiedSeveral contactless purchases with the same card, all just below the limit at which the terminal would ask for the PIN.
Authorization — Approved after high-risk attempts
VerifiedThe transaction was approved, but the same card had high-risk attempts in the last hour.
Amount — High cash withdrawal with a purchase
VerifiedThe cash withdrawn along with the purchase exceeds the ceiling, or is larger than the purchase itself.
Merchant — Merchant buying from itself
VerifiedThe buyer is the merchant itself. A self-purchase is a credit advance disguised as a sale.
Card scheme — Network
VerifiedThe five checks that only someone who sees several issuers and acquirers can make.
Geography — Malformed coordinate
VerifiedThe transaction's position arrived incomplete, is not a number or is outside the possible range.
The script never leaves
The listing says what the rule detects and which fields it consumes. Expression, structure and references show up for no account, under no role.
The field mapping is mandatory
The author's rule speaks their vocabulary; your input has another. The acquisition wires one to the other and is refused if any field is left unmapped — finding that out in production would cost dearly.
With reference, every new version reaches you
A copy is yours to edit and does not receive the author's changes. A reference is execution only: you run the published version, and when the author publishes a new one the acquirer's units start using it.
Every evaluated request becomes a record
Every evaluation is recorded by the unit itself and reaches the console through a continuous stream. The aggregate is kept hourly, so "how many high-risk today" never scans the table.
Evaluations per hour
Evaluations in 24h
12,480
High risk
3.1%
Average latency
0.015 ms
Alert configuration
Telemetry never slows the response
The unit does not wait for the console: it drops the event on a roomy channel and keeps answering. If the channel fills up, the event is discarded with a log warning — this is diagnostics and statistics, not bookkeeping.
Who can do what — and what was recorded
Roles per operation, bundled into IAM-style policies. Plus an append-only trail that the console itself neither edits nor deletes.
Roles bundled into policies
The role is the permission atom, one per operation. The policy is the bundle, IAM-style — and the policy is what you grant a person.
Seeing the code is a separate right
Without RuleScriptRead the response omits the expression and flags script_hidden. You can distribute the rule without distributing the intelligence.
Mandatory second factor
TOTP for every account, with no way to turn it off. Sign-in has two stages, and the password-stage token opens no route at all.
A hierarchy that only goes down
The parent reaches the branches and their own children. A branch never reaches the parent — except for what the parent shares, explicitly.
Audit trail
ana.souza updated the rule risco-cartao-exterior
2 min agocarlos.lima published on the marketplace velocidade-documento
18 min agoana.souza rotated the unit's token transacao
1 h agomarina.alves approved the registration Acme Pagamentos Ltda
yesterdayWritten by a middleware after the response, on every request that changes something. Append-only: no route edits or deletes a line of the trail.
Rules in plain language
Write the risk the way you write a sentence: if, else, and, or, between, and a Score with the points and the reason. No developer in the middle.
Visual builder
The same rule drawn as a flowchart, with a decision diamond and Yes and No paths. Drawing and script are one and the same.
Scores in milliseconds
Each input has its own processing unit, always available, answering with score, risk band and signals — clients reach it over HTTPS.
Data from where you already keep it
Plug in a CSV or your own database and query it from inside the rule, without exporting anything anywhere.
History and numbers
Every evaluated request becomes a record: the score, the rules that scored and the payload. Volume, risk bands and latency on one dashboard.
Rules marketplace
Publish a rule for other companies or acquire someone else's — as an editable copy or as use-only, without exposing the script.
Accounts in a hierarchy
A parent company and its branches, each with its own rules. The parent reaches the children; a child never reaches the parent.
Fine-grained permissions and MFA
Roles per operation, bundled into policies. Mandatory second factor. Seeing a rule's code is a permission of its own.
Audit trail
Who changed what, and when. Append-only: the console neither edits nor deletes its own trail.
How to get started
Send your company registration with your contact details. You get a protocol number right away; our team reviews it and, once approved, the administrator you named receives the invitation by e-mail.
Request access