# Maskbreak — Network and Device Fraud Signals > Maskbreak is a developer API for evaluating browser visits at signup, login and checkout. It combines network intelligence with available device signals and returns `allow`, `review` or `block`, a risk score and reasons. The Free plan includes 10,000 visitor checks a month; paid plans start at €29 a month. A risk signal is not proof of fraud. Product reference reviewed: 2026-10-27. Published by Sentinel Edge Networks LTD, the operator of Maskbreak. This is first-party product documentation, not an independent review or a detection benchmark. ## Start here - [Fraud detection API](https://maskbreak.com/fraud-detection-api): what one `/v1/evaluate` call checks, the allow/review/block answer with reasons, the Free plan and what it cannot see. - [API documentation](https://maskbreak.com/api): authentication, request fields, responses and limitations. - [OpenAPI specification](https://maskbreak.com/openapi.json): machine-readable HTTP contract. - [Integration guide](https://maskbreak.com/integrate.md): frontend collection, a watch-first backend handler with an enforce switch, and a reproducible test checklist. - [Integration options](https://maskbreak.com/integrations): SDKs, HTTP examples and Cloudflare Workers setup. - [Plans and pricing](https://maskbreak.com/pricing): the Free plan, paid plans and Enterprise. - [Full text collection](https://maskbreak.com/llms-full.txt): this reference, the integration guide and dated blog articles. ## Capabilities and limits | Task | Interface | Scope and limitations | |---|---|---| | Evaluate a browser visit | `POST /v1/evaluate` | Forward the browser's network `token` and `fingerprintEventId` (form fields `monocle` and `sentinel_fp`). Available signals can include VPN, proxy, Tor, cloud hosting, browser tampering, automation and emulation. The VPN/proxy service is named when known. Missing evidence is not a clean result. | | Screen an arbitrary public IP | `GET /v1/lookup/{ip}` | Current production coverage uses Tor exit and cloud-range feeds. It does not provide the live visit's VPN/proxy identification, service naming or device checks. An unknown IP is not proof of safety. | | Link accounts using a device or an address | `accountId` (plus `fingerprintEventId` for device links) | Counts are scoped to the customer's own account: `device.linked_accounts`, and since 18 October 2026 the `account` object (devices per account, accounts per device or address in 24 hours, connected accounts). Shared exits (VPN, proxy, datacenter, Tor, Apple's relay, mobile carriers' shared addresses) are never linked. Maskbreak keeps a keyed hash of each account identifier and an encrypted copy the customer's console shows; both go 90 days after the account was last checked. Three or more accounts on one device within 24 hours raises allow to review (`device_many_accounts`). Since 5 November 2026 a check with `event` `login`, `verification` or `password_change` whose `loginSucceeded` (or `succeeded`) is not true is a sign-in attempt: it counts in `device_accounts_24h` and `ip_accounts_24h` but adds nothing to that account's own devices, addresses or connected accounts. A check without `event` counts as the account's own use, as before, so send `accountId` at sign-in only once the credential was accepted, or with `event: "login"` and `loginSucceeded`. This is not cross-customer identity resolution. | | Protect logins against account takeover | `event: "login"` + `accountId` on evaluation (optional `loginSucceeded`, `sessionId`, `userAgent`, `ip`) | Since 23 October 2026, included in every plan and on for every account (a customer can switch it off in Settings); nothing is sent until the customer's server sends a login or an account event with an account ID, which is its instruction to use it. Adds `account_takeover` (`score` 0-100, `risk` low/medium/high, `signals` by name); 80 or more adds `account_takeover_risk` and raises allow to review, never to block. The score comes from a dedicated account takeover provider (United States, listed on /sub-processors) that receives, for each login or account event, the visitor's IP address and browser user agent, the email address when sent, whether the login succeeded, the customer's confirmed website domain and Maskbreak's own result for the visit (decision, risk score, the network and browser flags, the VPN service's name, the IP address's country), with keyed hashes in place of the customer's account and session IDs and of Maskbreak's device key, and learns from the logins of every customer using login protection. Test keys, test tokens and the sandbox never send a login there; a slow or failing provider answers `checked: false` within 1.5 s and the rest of the check is unaffected. Since the same day `event` also takes `"signup"`, `"password_change"`, `"verification"`, `"logout"` and `"account_change"` (with `succeeded`, `reason`, `verificationType`, `verifiedEvent`): sent to the same provider as the matching account event, no score in return, the answer carries `account_event {event, recorded}`; they teach the provider what is normal for each account, so the login scores get sharper. The server SDKs send these fields from Node 0.5.0, Python 0.4.0 and PHP 0.3.0. | | Check a signup email domain | Optional `email` on evaluation | Adds a disposable-domain signal, not mailbox ownership verification or a full email-reputation product, unless email and phone intelligence is turned on (next row). | | Score an email address or a phone number | Optional `email` and `phone` (international format) on evaluation, with email and phone intelligence on | Since 23 October 2026, included in every plan; on by default for accounts created on or after that day, off for older accounts until switched on in Settings (any account can switch it off there); nothing is sent until an address or a number arrives with a check. The address and number go to a dedicated email- and phone-intelligence provider (United States, listed on /sub-processors) and the answer gains `email.checked/score/risk/signals` (plus `online_accounts`, `breaches`, `deliverable`, `free_provider`, `domain_created`) and a `phone` object (`checked/score/risk/signals`, `valid`, `line_type`, `carrier`, `country`, `disposable`, `online_accounts`); a score of 80 or more adds `email_high_risk` or `phone_high_risk` and raises allow to review, never to block. Each address or number scored uses one of the plan's daily email-and-phone checks (Free 3, Starter 20, Growth 50, Scale 150, shared with the console's Email & phone tab; `why: "quota"` past it). The address and number are never stored or logged; the stored check keeps the scores. Test keys, test tokens and the sandbox never send anything there. The server SDKs send `phone` from Node 0.5.0, Python 0.4.0 and PHP 0.3.0. | | Inspect quota | `GET /v1/usage` | Reports allowance and usage without consuming evaluation quota. In-window counters are advisory. | | Check the integration | `GET /v1/setup` | Whether the latest check from your integration arrived complete (network and browser part), what was missing if not, and the next step in one sentence. Ask after submitting your form once; no quota used. | Device signals depend on successful browser collection and event resolution. The device block may be absent. Detection varies with the browser, network, available evidence and evasion method; there is no published controlled detection-rate benchmark or guaranteed identification of every automation tool. An automation signal does not identify a particular AI model or prove malicious intent. Maskbreak is one input to an application's security policy. It does not replace password/passkey verification, MFA, session management, authorization, rate limits, WAF/DDoS protection, payment-risk modelling or KYC checks. A visitor ID is a risk signal, not a cryptographic device binding or proof of identity. ## Good fit and not a fit Good fit: - A website or web app that wants a risk decision at signup, login, checkout, trial start or another sensitive form, collected from the visitor's browser. - Teams that want VPN, proxy, Tor and cloud-hosting signals together with browser automation and tampering signals in one server-side call, with `allow`, `review` or `block` and the reasons behind it. - Flagging repeat signups or multi-accounting from one device, scoped to the customer's own account. - Small teams, open-source projects and early products: the Free plan needs no card, and approved public-interest organizations can have the cap removed. Not a fit: - Scoring lists of IP addresses or server logs with no browser visit. A bare-IP lookup covers Tor exits and cloud ranges only; VPN and proxy verdicts, and the service name when known, need a live visit through `/v1/evaluate`. - Replacing KYC, identity-document checks, payment-risk scoring, chargeback guarantees or bulk email/phone reputation scoring. Email and phone intelligence scores only the one address or number sent with a visitor check (or typed into the console's Email & phone tab), within the plan's daily email-and-phone checks (3 a day on Free; 20, 50 and 150 on Starter, Growth and Scale); there is no bulk or list endpoint, and without it the API's `email` field is a disposable-domain signal only. - Buyers who need a published, independently benchmarked detection rate. None is published. - Blocking every VPN user outright. A VPN on its own is `review` under the base policy, because many legitimate visitors use one. ## Decisions, timing and testing - Route on `decision`, not a hardcoded score threshold or legacy `isSuspicious`. - Under the base policy, VPN-only traffic is `review`, not `block`. Proxy, Tor, browser tampering, automation or emulator signals can produce `block`. - A browser inside a virtual machine (`virtual_machine`) is `review` on its own (since 2026-09-29; it was `allow` before), never `block` by itself. - Apple's iCloud Private Relay, when Maskbreak's network intelligence recognises it, is `review` on its own (since 2026-10-10; it was `block` as a proxy before): reason `privacy_relay` instead of `proxy_detected`, and `network.privacy_relay: true` beside `network.proxy: true`. - A cloud-server signal alone does not block. Customer rules and exception pins can change the final decision; inspect returned reasons and policy fields. - `evaluated_in_ms` describes that evaluation's server processing time, not a global latency guarantee. Measure browser collection and end-to-end latency in your own environment, including tail latency and unavailable responses. - Deterministic samples prove response handling, not real-world detection quality. Never treat `sample`, `sandbox` or `test` responses as production evidence. - `401` means the key is missing or matches no account. `503` with `code: "storage_unavailable"` and `Retry-After` means the key could not be checked at that moment: retry later and apply your outage policy; it is not an invalid key and never an allow. ### Reproduce the VPN example This is a selected-field excerpt of the synthetic public sample, not a real visitor record or a measured performance claim: ```bash curl --fail-with-body 'https://maskbreak.com/v1/evaluate/sample?scenario=vpn' ``` ```json { "sample": true, "decision": "review", "risk_score": 65, "ip": "198.51.100.18", "country": "NL", "network": { "vpn": true, "proxy": false, "privacy_relay": false, "datacenter": true, "anonymous": true, "tor": false, "residential": false, "service": "PROTON_VPN" }, "reasons": ["vpn_detected", "datacenter_asn"], "evaluated_in_ms": 28 } ``` The VPN sample has no device block. Use the `bot` sample to inspect synthetic device fields. The [integration test checklist](https://maskbreak.com/integrate.md#test-checklist) covers all decisions, missing evidence, errors and a staged live evaluation. ## Integration essentials Three steps give the first complete check (network token and browser check together). The dashboard's setup uses the same names: 1. **Add the script to the page with your form.** Load `https://maskbreak.com/assets/sentinel.js` and put `class="monocle-enriched"` on the `