Humifortis
Stop relying on slow SIEMs and siloed Auth providers. Humifortis is the universal, real-time risk middleware that protects your Users, API Keys, and Devices instantly.
{
"entity_id": "u-83bd9f",
"entity_type": "user",
"risk_score": 72,
"risk_level": "HIGH",
"confidence": 0.83,
"last_update": "2025-12-13T09:45:00Z",
"expires_at": "2025-12-13T10:15:00Z",
"contributing_factors": [
"impossible_travel",
"failed_login_attempts",
"admin_endpoint_access"
]
}Learn more about Humifortis and how it transforms security infrastructure
Note: This video may require authentication or may not be publicly embeddable. Click above to view on YouTube.
Watch how incremental events update risk scores in milliseconds.
This is live. It updates in real time. It shows how risk changes over time.
For hands-on experimentation with custom attack scenarios, visit our interactive try now.
Real-time protection without the complexity
Query risk scores in under 10ms. No batch processing delays.
Works with any system via REST API. No vendor lock-in.
Minimal data retention. No logs, no PII, no compliance headaches.
Auditable algorithms. Configure rules, understand results.
Your infrastructure is fragmented. Your risk context shouldn't be.
SIEMs and Data Lakes work in batches. By the time they detect a threat, the data is already exfiltrated. We operate in milliseconds.
Okta doesn't talk to your WAF. Your API Gateway doesn't know about User behavior. Humifortis connects them all.
Proprietary "Adaptive Auth" is expensive and opaque. Humifortis is transparent, configurable, and vendor-agnostic.
We don't sell AI magic. We sell robust engineering.
We don't claim to stop all attacks. We provide a tool to make better decisions in real-time.
Every risk calculation is auditable. No black-box ML. You configure the rules, you understand the output.
Boring technology that works. Redis, simple math, standard protocols. No hype, just engineering.
Standard REST API. Works with any system that can make HTTP calls.
Query risk score before routing requests (Cloudflare Workers, Nginx).
Trigger MFA or block login based on user risk (Keycloak, Auth0).
Dynamically adjust limits per API key risk level (Kong, custom gateways).
Technical answers to questions that determine credibility, safety, and adoption.
Humifortis provides an incremental, reusable risk state that bridges the gap between detection systems (WAF logs, auth events, SIEM alerts) and enforcement points (API gateways, authentication providers). It does not replace detection or analytics â it maintains a real-time risk context that your existing tools can query and act upon in milliseconds, eliminating the fragmentation and latency inherent in batch-processing architectures.
No. Humifortis operates on minimal persistence by design. It stores only aggregate risk scores and metadata (entity ID, timestamp, contributing signal types) â not raw logs or event payloads. All data is ephemeral with configurable TTLs (typically 15-30 minutes). No PII is retained. The architecture follows privacy-by-design principles: the less we store, the less can leak.
Risk calculation is incremental and O(1). Each incoming event applies a weighted delta to the current score based on a configurable signal table (e.g., +15 for failed login, +30 for impossible travel). Scores decay exponentially over time using a temporal function â recent events weigh more heavily than old ones. No heavy aggregations or database scans. Updates complete in under 10ms. The algorithm is transparent, deterministic, and auditable.
Humifortis exports a risk signal via a simple REST API
(GET /risk/{entity_id}). It does not enforce policies or make blocking
decisions â that remains your infrastructure's job. Cloudflare Workers query the API
before routing. Keycloak plugins check risk before issuing tokens. Kong middleware
adjusts rate limits dynamically. Integration is deliberate: ~10 lines of code,
~10 minutes to deploy. We provide SDKs and reference implementations for
common platforms.
The system is designed to fail open / fail safe. Humifortis operates in the observability path, not the critical path. If the service is unreachable, integrations fall back to default behavior (no blocking, standard rate limits, normal auth flow). You retain full control of fallback logic in your enforcement layer. Removing Humifortis requires no schema migrations or data cleanup â simply stop querying the API. Your infrastructure continues operating unchanged.