Portreeve.

Abuse stops at the gate.

One API call at signup, trial, and checkout returns an allow, review, or block verdict in under 100 ms, before it costs you a cent. Not a lookup: the gate remembers what it has already seen.

Card on file, charged only for what you use. First cohort onboarding now.

One event, three frames — stone / dissolution / boundary

I  THE GATEc. 1370
II  DISSOLUTIONt = 0.5

We'll man the gate.

{
  "verdict": "block",
  "reasons": ["disposable_email"],
  "latency_ms": 88
}
III  THE BOUNDARY~88 ms
01 · The API

One request. One verdict.

Requestcurl
# fires on every signup, trial, or checkout event
curl https://api.portreeve.dev/v1/verdict \
  -H "Authorization: Bearer sk_live_…" \
  -d '{
    "event_type":       "trial_start",
    "email":            "jm482@tempmailo.net",
    "ip":               "185.220.101.47",
    "device_token":     "dtk_9c41d2",
    "external_user_id": "usr_31007"
  }'
Response200 · 88ms
{
  "id":      "evt_01J8Z3KQ9V",
  "verdict": "block",
  "reasons": [
    { "code": "disposable_email" },
    { "code": "velocity_cluster_trials",
      "detail": { "cluster_trials_30d": 13, "threshold": 3 } }
  ],
  "policy_version": "2026-08-12.1"
}
✓allow

Clean traffic passes untouched. Your good users never see a CAPTCHA or an extra step.

~review

Gray cases land in a queue you clear with one keystroke each, or auto-resolve on your rules.

✕block

Abuse ends at the request. Nothing is provisioned and no charge is attempted, so there is nothing to clean up afterwards.

SDK for Node · Python and Go on the roadmap · webhooks for async flows · sandbox keys on signup

02 · Memory

The gate remembers.

A lookup answers one request and forgets it. The gate keeps a ledger, and the ledger is what the next request is judged against.

  • A lookup has no yesterday. It answers one question about one request, then forgets. The next request from the same person arrives as a stranger, and so does the one after that.
  • Every event is matched against the ones before it. On the keys that belong to a person: email, device token, card fingerprint, payer wallet. Matching keys pull those accounts into one cluster.
  • The fourth trial account from a known device does not look like a first. The verdict returns identity_cluster with the accounts already linked, and velocity_cluster_trials because this cluster has opened trials before. Same call, same shape, still under 100 ms.
  • An IP is correlation and never identity. Offices, campuses and mobile carriers put thousands of strangers behind one address, so a shared IP never merges two people in your graph. Only keys that belong to a person do that.
  • The ledger is yours. Keys are hashed before they are stored and scoped to your tenant, so your graph is built from your traffic and no one else's.
Illustration of an identity cluster: dark spheres connected by lines through space, with two of the connected nodes marked in oxblood.
identity ledger · your tenant only · marked nodes are accounts the same keys linked

same device · new email · trial account no. 4
a lookup sees a brand new customer

03 · What it stops

Four ways strangers bill you

Card-testing

A bot finds your checkout and runs thousands of stolen cards through it overnight. You wake up to dispute fees, a spiking decline rate, and a warning email from Stripe. Portreeve kills the burst at the first request.

✕ BLOCKED

Free-trial abuse

The same person, on their 14th disposable email, burning your compute and your AI credits on a trial they will never convert. The device fingerprint gives them away on account two.

✕ BLOCKED

Fake signups

Bot-registered accounts that poison your metrics, fill your database, and get your transactional email domain flagged for spam. Verdicts at signup keep them out of your funnel entirely.

✕ BLOCKED

Multi-accounting

One user opens six workspaces and pays for zero seats: coupon stacking, referral farming, dodged per-seat limits. Linked identity across email, device, and payment method surfaces the cluster.

✕ BLOCKED
04 · Who it's for

Built for growing teams.

Solo founders

No fraud team required

Card-testers don't check your headcount before they find your checkout. The burst lands between support tickets and deploys, and the dispute fees land on your Stripe account.

the loss · card-testing fees on Stripe
Indie SaaS

Metrics you can trust

Fake signups don't just sit in the database. They poison activation rates, wreck cohort math, and turn every launch decision into a guess. Verdicts at signup keep the funnel human.

the loss · fake signups poisoning metrics
AI-app builders

Your margin is the target

Every farmed trial burns real inference. One person on their fourteenth burner email is a trial farm spending your AI credits with no intention of ever paying.

the loss · trial farms burning AI credits
05 · Security & trust

Judgment without the homework.

hashed device signals

Device and network signals are hashed before they're stored; we keep the fingerprint's shadow. Raw identifiers never sit in our database.

no PII resale

Your users' data exists to judge your traffic and for no other purpose. It is never sold, shared, or pooled into ad tech; the subscription pays the bills.

sub-100 ms verdicts

p99 measured at about 90 ms, fast enough to sit inline at signup and checkout without your users ever feeling the gate. If we're degraded, we fail open and say so in the response, so your funnel never hangs on us.

correct by default

Rules ship tuned, with false-positive discipline: a wrongly blocked customer costs you more than a wrongly allowed bot, and the defaults are weighted accordingly. Growing teams have better things to do than tune a rules engine; the defaults do that work.

06 · The agent era

When agents start paying, the gate already knows them.

Agent traffic doesn't arrive with a browser and an inbox. It arrives with a wallet. Portreeve treats a payer wallet like any other identity key: email, IP, device, wallet, one more column in the same ledger, judged by the same graph.

The API is designed for x402: when machine payments reach your endpoints, verdicts drop into the SDK's lifecycle hooks. Judge on onProtectedRequest, settle only through onBeforeSettle. There is no parallel fraud stack to run for a second kind of customer.

The abuse ledger nobody else keeps:
this agent's 14th trial account.

x402 lifecyclenode sdk
// an agent paying per-call is a checkout attempt — same contract
pay402.onProtectedRequest(async (req) => {
  const v = await portreeve.verdict({
    event_type: "checkout_attempt",
    ip:         req.ip,
    identity:   { wallet: req.payer }  // one more identity key
  });
  if (v.verdict === "block") return req.deny(v.id);
});

pay402.onBeforeSettle(assertVerdicted); // no verdict, no settlement
07 · Free tools

Check the damage first

Free · no account

Card-testing exposure scanner

Export your recent payment events, drop the CSV in, and see card-testing bursts, BIN clusters, and probe patterns flagged in seconds, before your processor flags them for you.

portreeve.com/scan · free, launching on this domain
Free · no account

Disposable email checker

Paste any address or domain and check it against the live blocklist Portreeve uses in production: thousands of burner domains, updated continuously.

portreeve.com/check · free, launching on this domain

Both tools launch free on this domain. No signup required, and no verdict on you.

08 · Pricing

What the gate costs

The engine does not change between plans. A free account gets the same verdicts and the same review queue as the largest one. What the price buys is how far back the gate can remember.

early access is free while it lasts · the plans below are what launch looks like

Free

$0 /mo

memory depth 7 days
screened events
1,000 a month
overage
$5 per 1,000 events
support
documentation

Indie

$19 /mo

memory depth 90 days
screened events
10,000 a month
overage
$4 per 1,000 events
support
docs and community

Growth

$79 /mo

memory depth 12 months
screened events
50,000 a month
overage
$3 per 1,000 events
support
email support

Scale

$249 /mo

memory depth no limit
screened events
250,000 a month
overage
$2 per 1,000 events
support
priority support
one event = one verdict call at signup, trial start, or checkout 7 days catches the lazy farmer · 90 days catches the patient one
09 · Questions

The short answers

QWhat data do I send you?

An event type and the identifiers you already have: email, IP, a device token, your user id. Card numbers and passwords never touch us; for payments we take the processor's card_fingerprint rather than the card itself.

QWhat happens on "review"?

The gray cases land in a queue you clear with one keystroke each, or auto-resolve on rules you set once. Most traffic never sees one; review exists so a household on a VPN is never treated like a bot.

QHow long does integration take?

One endpoint, called at signup, trial, or checkout. Most builders ship their first verdict in under an hour with the Node SDK, and sandbox keys come with signup. Python and Go SDKs are on the roadmap.

QDoes it work with Stripe?

Yes. Call Portreeve before you create the customer or checkout session. A block verdict means no charge is ever attempted, so card-testers never reach Stripe and your dispute rate stays yours.

Put a portreeve at your gate.

Early access is rolling out to the first cohort now. One API call; verdicts you can act on.

free tier at 1,000 events a month · paid plans from $19