Proof of Human for Digital Platforms.

HEIP tells your server whether a real person is behind a payment, login or withdrawal, at the moment it happens. No puzzles. No personal data.

Book a demo See how it works

For exchanges, fintechs, AI products and online platforms.

What your visitor sees

Nothing extra. No puzzle, no pop-up.

↓ Your server asks HEIP

What your server gets

{
  "success": …,
  "decision": …,
  "reasons": [ ]
}

Press the button to see what your server gets.

Example response

Your login checks who. Nothing checks whether anyone is there.

An account passes every identity check on Monday. On Tuesday a script logs in with it and moves money. Every check was right. Nobody asked whether a person was at the controls.

Sign in
password, MFA
check who you are
Session
time passes
control can change
Action
withdraw, pay,
approve
Decision
your server
asks HEIP

Logins prove a moment. Sensitive actions happen later.

The web is no longer mostly people

53%: of web traffic in 2025 was automated, in Thales's dataset; Source: Thales, 2026 Bad Bot Report, full-year 2025 data
12.5×: more AI-enabled bot attacks than the year before; Source: Thales, 2026 Bad Bot Report
+1,700%: growth in daily AI-agent requests in one year; Source: Cloudflare, Sep 2026, its own network

Not all automation is bad. Agents that act for real users are useful. The question for your platform is narrower: for this action, right now, is the right person in control?

Your tools each answer a different question

Layer	The question it answers	You probably have
Identity checks	Who is this person?	KYC, ID and selfie checks
Sign-in	Can they prove they own the account?	passwords, MFA, passkeys
Bot management	Does this traffic look automated?	edge and network bot tools
Fraud scoring	Does this transaction look like fraud?	risk engines, transaction rules
HEIP	Is a person in control at the moment of this action?	the missing row

HEIP works alongside every row above. It replaces none of them. Use its answer on its own, or as one more input to the decision you already make.

One withdrawal, start to finish

A customer signs in.
Password and MFA pass. Everything looks normal.
Twenty minutes later, a withdrawal.
$20,000 to a wallet address added today.
Your server asks HEIP.
About this exact withdrawal, in this session, right now.
HEIP answers: step up.
Not enough evidence for this action's policy.
You ask for a passkey.
A person confirms in seconds. A script stops here.

Every check passed at sign-in. HEIP is the one that ran when it mattered.

Put it where automation costs you money

What changes for your business

A check at the moment money moves, not only at login: Because HEIP answers per action, at the time of the action
Less friction for real customers: Because HEIP asks your app to step up only when it isn't sure
Faster reviews and fewer “why was I blocked?” tickets: Because HEIP gives a reason with every decision
A safe way to try it: Because HEIP runs in observe mode first and blocks nothing
No new personal data to protect: Because HEIP never collects identity, biometrics or what people type
A small change for your engineers: Because HEIP adds one script and one server call
Control stays with you: Because HEIP returns a recommendation; your platform enforces

Built for every team that owns risk

Know whether a person is at the controls before a sensitive action goes through. Every decision has reasons and a record your team can review.

Security and data

How HEIP fits into your app

Add one script
Your page loads HEIP with a public key that only works on your domains. Visitors see nothing new.
Your server asks
When someone presses Pay, your backend asks HEIP about that exact action, using your secret key.
You decide
HEIP answers allow, step up or deny, with reasons. You choose what happens, and a record is kept.

The full explanation

Two snippets. That's the integration.

HEIP is an API and two small SDKs. It doesn't change your user flows. It tells your server what it found, and you decide what happens.

browser: one script tag or npm package
server: Node.js SDK, or any language over HTTPS
first: your first decision in about 30 minutes

Developer overview

This goes in your web page.

<script src="YOUR_SDK_URL" data-site-key="pk_live_…" async></script>

<script>
  form.addEventListener("submit", async (e) => {
    e.preventDefault();
    const { sessionId, actionNonce } = await HEIP.prepareAction("checkout");

    await fetch("/api/checkout", {
      method: "POST",
      body: JSON.stringify({ sessionId, actionNonce }),
    });
  });
</script>

This runs on your backend.

import { HeipServer, allow } from "heip-sdk/server";

const heip = new HeipServer({ secretKey: process.env.HEIP_SECRET_KEY });

const result = await heip.verify({ sessionId, actionNonce, action: "checkout" });

if (!allow(result)) {
  return res.status(403).json({ error: "verification_failed" });
}

This is what comes back.

{
  "success": false,
  "decision": "STEP_UP",
  "reasons": [ … ]
}

What we tell you, and what we don't

Server-only answers: The browser never sees the decision. Only your server, with your secret key, can read it.
One token per action: Each protected action gets a token that works once, for that action and that session, and expires in seconds.
Domain-locked keys: Your public key works only on the domains you list. Copied elsewhere, it is useless.
Secret keys: Stored hashed, shown once, rotated without downtime, revoked everywhere at once.
Leak tripwire: If a secret key is ever used from a browser, HEIP refuses it and logs an alert.
Fails closed: If HEIP can't be reached, the server SDK says no by default. You can change that per action.
Reasons and records: Every decision has reasons. History is kept 30 days; every configuration change is logged for a year.
Versioned API: /v2 today. Breaking changes get a new version, with notice.

Security and data, in full

One question. Three answers.

Decision	What it means	What you usually do
ALLOW	Enough evidence that a person is in control.	Let the action through.
STEP_UP	Not enough evidence yet for this action.	Ask for a passkey, a one-time code or another check you already have.
DENY	Strong evidence this is automated.	Refuse the action and log the reasons.

You set how strict each action is. A withdrawal can be strict while posting a comment stays effortless.

We check how, never who

HEIP never collects

What was typed or which keys were pressed
Names, emails, IDs, faces or voices
Cookies or a cross-site fingerprint
Page content or form values

Built in

Server-only decisions
Domain-locked keys
Fails closed
Reasons on every decision

Try it without blocking anyone

Baseline
Pick one action. Note how it's protected today.
Observe
HEIP decides on real traffic but blocks no one.
Compare
Review its decisions against what you already know.
Enforce
Turn it on for that action only if it earns it.

Most teams go from observe to enforce on their first action in 6 to 8 weeks. How onboarding works

Questions

What is HEIP?

HEIP tells your server whether a real person is actually doing an important action on your website, like a payment, a login or a withdrawal, without asking them to solve a puzzle and without learning who they are.

Does it replace our MFA, KYC or bot protection?

No. Each of those answers a different question. HEIP adds the one they don't: is a person in control at the moment of this action? Use it alongside them.

Who makes the final decision?

You do. HEIP returns allow, step up or deny with reasons. Your platform decides what happens and stays in charge of the action.

Is this a CAPTCHA?

No. Visitors never solve anything. Your app only adds a step when HEIP answers STEP_UP.

What do my customers see?

Nothing new. No badge, pop-up or delay.

What does HEIP collect?

It looks at how the page is being used, not who is using it. It never records what is typed, form values, page content, names, emails, faces, voices or cookies.

Can I try it without risk?

Yes. Observe mode records what HEIP would have decided and changes nothing for your customers.

What if HEIP gets something wrong?

Observe mode shows you before it costs you. Uncertain cases become a step-up, not a block. Policies let you relax one action without weakening the rest. Every decision has reasons you can review with us.

Does it work with AI agents?

Yes, as a human checkpoint: before an agent's action goes through, check that a person approved it in your web app.

Which platforms are supported?

Websites on desktop and mobile browsers today. Native mobile SDKs are planned.

How long does integration take?

Most teams see their first decision in about 30 minutes. Moving one action from observe to enforce usually takes 6 to 8 weeks.

What happens if HEIP can't be reached?

The server SDK refuses by default, so an outage never silently lets an action through. You can choose otherwise for low-risk actions.

How do I get started?

Book a demo. We'll walk through the actions you want to protect, set up your account and keys, and help you run your first decision in observe mode.

Trust has to move with the action.

When digital actions can be automated, trust must move with them.

Book a demo Talk to sales