Sign in
Transaction monitoring engine

Your rules.
Live. Tested.
Auditable.

Stop shipping rule changes as code deploys. ezrules gives fraud and compliance teams a control plane to draft, shadow-test, roll out, and audit decision logic — while your systems call one API.

Sign in
ezrules — live evaluation
$ curl -X POST https://api.ezrules.io/v2/evaluate
-H "X-API-Key: ek_live_••••••••"
-d '{"amount": 7840, "currency": "EUR", "country": "MX"}'
{
"outcome": "REVIEW_HIGH",
"rules_fired": 3,
"latency_ms": 12,
"shadow_diff": true
}

How it works

One event in. One decision out.
Everything in between is visible.

01

Ingest

Your system sends a JSON event — a payment, a login, a transfer — to the evaluation endpoint.

02

Evaluate

Rules fire in priority order. Conditions match event fields, lists, thresholds, velocity checks.

03

Decide

An outcome is returned — approve, review, block — with a full trace of which rules contributed.

04

Audit

Every decision is stored with full provenance. Labels, backtests, and quality reports follow.

Capabilities

Not just rules. A decision control plane.

Shadow & rollout testing

Run candidate rules beside production logic. Compare outcomes on live traffic before anything changes for analysts. Percentage rollouts let you ramp gradually.

Precision & recall reports

Label events with ground truth. See which rules are signal, which are noise — F1, TP, FP, FN per rule.

Rule lifecycle

Draft, test, promote, pause, restore. Every state change is tracked. No mystery edits in production.

Backtesting

Replay historical events through proposed rule changes. Know the impact before you ship.

Decision tracing

Hover across a decision to see which payload fields matched which rule conditions. Full provenance, not just a label.

User lists & lookups

Maintain allow/deny/watchlists inside the product. Reference them in rule conditions without touching code.

Graph analytics

Follow the network behind every decision.

Fraud doesn't live in one transaction — it lives in the links between them. ezrules connects every event to the entities behind it, so your rules reason over the whole graph: count distinct cards, devices, or accounts reachable from a user across bounded hops and time windows.

  • Graph features in rules — reference traversal stats directly, e.g. stat[user.unique_cards_graph_90d]
  • Bounded by design — preset windows up to 180 days, entity allowlists, max-depth and expansion caps, with a full activation & audit lifecycle
  • Visual investigation — expand any decision into its entity network and hop across shared users, cards, devices, and merchants
ezrules cloud
Managed We run it. You use it.
Rules 47 active
Events 2.1M / mo
History full audit
export & migrate
anytime
your infrastructure
Self-hosted Same code. Your servers.
PostgreSQL your DB
Docker compose up
API same contract

Zero lock-in

Leave whenever you want. Take everything with you.

ezrules is open-source. The cloud version runs the exact same code you'd self-host. Your rules, audit history, outcomes, and configuration are yours — export and migrate to your own infrastructure whenever it makes sense. No proprietary formats. No hostage data. No "enterprise exit fee."

  • Same codebase — cloud and self-hosted run identical logic
  • Full data export — rules, events, labels, audit history
  • Standard stack — PostgreSQL, Redis, FastAPI, Docker
  • Open source — inspect, fork, extend, contribute

Integration

One endpoint.
Five lines.

Send events, get decisions. The heavy lifting — rule ordering, list matching, outcome resolution, audit logging — happens on our side.

<15ms p99 latency
REST JSON in, JSON out
Self-host or managed cloud
python 
import requests

response = requests.post(
    "https://api.ezrules.io/v2/evaluate",
    headers={"X-API-Key": api_key},
    json={
        "transaction_id": "txn_91bd",
        "event_data": {
            "amount": 7840,
            "currency": "EUR",
            "country": "MX",
        }
    }
)

outcome = response.json()["outcome"]
# "REVIEW_HIGH"

Get started

Take control of your rules.

Run it on our cloud or your own infrastructure. Same engine, same API, nothing locked away.

Request access Self-host on GitHub