Authorization as a Service.
Without the complexity.

Tenant-scoped, feature-based authorization with roles and per-user overrides. Built for growing SaaS teams.

Stop hardcoding permissions. Centralize authorization without policy engines or heavy infrastructure.

Built from real-world multi-tenant IAM experience.

Join early adopters. No spam.

Authorization breaks quietly. Until it doesn't.

Thauth.dev gives you structure without forcing a policy engine.

The Start

  • Hardcoded permission checks
  • Boolean flags
  • Simple role enums

Then reality hits

  • Multi-tenant customers
  • Feature-level permissions
  • One-off exceptions
  • Admin tooling chaos

A simple, explicit authorization model

T
Tenant
|- Features Actions // (blog, create)
|- Roles Permission pairs // Editor = [(blog, create), ...]
\- Users Role + Overrides // bob: Editor + (billing, view)

Every decision resolves to a simple (feature, action) check.

Explicit

Permissions are explicit (feature, action) pairs

Bundled

Roles bundle permissions

Flexible

Overrides handle exceptions cleanly

Isolated

Everything is tenant-isolated by default

No graphs. No DSLs. No magic.

Built for teams who've outgrown basic RBAC

But don't want OPA.

Too simple

  • Hardcoded checks
  • Feature flags abused as auth
  • Rigid role enums
The Sweet Spot

Thauth.dev

  • API-first by default
  • Deterministic authorization checks
  • Clear mental model, no DSLs

Too complex

  • Policy languages (Rego, Polar)
  • Steep learning curves
  • Operational overhead

Pricing that scales with authorization load

Simple monthly plans with included decision checks. Start free, move into production cleanly, and scale without policy-engine overhead.

Free

$0 /month

Evaluation and prototypes

Checks / month 100k
Scale 1 project • 1 teammate
  • Core RBAC, subjects, and decision API
  • Basic API keys
  • No overrides, batching, or metrics
Start with Free

Best for trying the model in a real app before production rollout.

Recommended

Starter

$49 /month

Production-ready authorization

Checks / month 1M
Scale Unlimited projects • 5 teammates
  • Overrides and batch checks
  • 7-day audit retention
  • Standard production throughput
Start with Starter

Recommended for most SaaS teams moving from hardcoded checks.

Growth

$149 /month

For scaling product usage

Checks / month 10M
Scale Unlimited projects • 15 teammates
  • 30-day audit retention
  • Usage insights and metrics
  • Higher API throughput
Choose Growth

Built for teams whose authorization layer is already on the customer path.

Scale

$399 /month

Infrastructure-level usage

Checks / month 50M
Scale Unlimited projects • Unlimited teammates
  • 90-day audit retention
  • Priority support and soft SLA
  • Advanced rate limiting controls
Choose Scale

For platforms where authorization is part of the core request path at high volume.

Usage model

Usage stays soft as you grow

Thauth bills on included authorization checks, not seats alone. When you cross plan limits, requests keep flowing and overage lands on the next invoice.

  • Monthly subscriptions with included usage
  • Checks counted per decision, including each batch item
  • Warnings at 80%, 100%, and 120% of included volume

Usage resets monthly. Overage is allowed and billed in 500k-check units at $5. Batch requests count per decision inside the batch.

Enterprise

Custom contract

Compliance and bespoke rollout

Checks / month 100M+
Rollout Custom limits • Dedicated support
  • Custom SLA and limits
  • Dedicated support path
  • Roadmap fit for SSO, SCIM, and compliance
Talk to us about Enterprise

Tell us your expected volume and compliance constraints and we will scope the rollout with you.

Prefer email? Talk to us directly.

Build features, not permission systems

Early access rolling out soon. Built in public.