Authentication for modern developers
A multi-tenant authentication platform built for developers. Secure, customizable, and developer-friendly with SDKs for popular frameworks.
// src/index.jsx
import React from 'react';
import ReactDOM from 'react-dom/client';
import { AuthavaProvider } from '@authava/react-client';
import App from './App';
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
<AuthavaProvider config={{ domain: 'auth.yourdomain.com' }}>
<App />
</AuthavaProvider>
</React.StrictMode>
);Built for developers, by engineers
Authava provides a complete authentication solution with the flexibility developers need and the security modern applications require.
Developer-First SDKs
TypeScript-native SDKs for React and vanilla JS with full type safety and IntelliSense support to accelerate your development.
Security-First Design
Multi-tenant isolation, MFA, passwordless login, and robust security practices built into the core of our platform.
Infrastructure as Code
Terraform provider for managing authentication domains, settings, and configurations through your IaC workflow.
Full Customization
White-label authentication with custom domains, branding, email templates, and UI components to match your brand.
Seamless Integration
Drop-in components for React with automatic session management and refresh to get up and running quickly.
Usage Insights
Track active users, authentication events, and security metrics to understand how your users interact with your app.
Integrate in minutes, not days
Our client libraries make it easy to add authentication to any application with just a few lines of code.
React Integration
npm install @authava/react-client @authava/client// src/index.jsx or src/main.jsx
import React from 'react';
import ReactDOM from 'react-dom/client';
import { AuthavaProvider } from '@authava/react-client';
import App from './App';
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
<AuthavaProvider config={{
domain: 'auth.yourdomain.com',
secure: true,
autoRefresh: true,
refreshBuffer: 5
}}>
<App />
</AuthavaProvider>
</React.StrictMode>
);import { useAuthava } from '@authava/react-client';
function Profile() {
const { isLoading, session, sessionState } = useAuthava();
if (isLoading) {
return <div>Loading...</div>;
}
if (!session) {
return <div>Please log in</div>;
}
return (
<div>
<h1>Welcome, {session.user.email}!</h1>
<p>Session status: {sessionState.status}</p>
</div>
);
}import { useAuthava } from '@authava/react-client';
function AdminPanel() {
const { hasRole, hasPermission } = useAuthava();
// Check for a single role
if (!hasRole('admin')) {
return <div>Access denied</div>;
}
// Check for multiple permissions (any match)
const canManageUsers = hasPermission(['create_user', 'delete_user']);
return (
<div>
<h1>Admin Panel</h1>
{canManageUsers && <UserManagement />}
</div>
);
}TypeScript/JavaScript Integration
npm install @authava/clientimport { AuthavaClient } from '@authava/client';
// Initialize the client
const authava = new AuthavaClient({
domain: 'auth.yourdomain.com',
secure: true,
autoRefresh: true
});
// Check if user is authenticated
const isAuthenticated = await authava.isAuthenticated();
if (isAuthenticated) {
// User is logged in
const session = await authava.getSession();
console.log(`Logged in as: ${session.user.email}`);
} else {
// Redirect to login
window.location.href = authava.getLoginUrl();
}// Listen for session changes
authava.onSessionChange((session) => {
if (session) {
console.log('Session updated', session);
} else {
console.log('User logged out');
}
});
// Manual logout
await authava.logout();
// Check user roles and permissions
const session = await authava.getSession();
if (session) {
const isAdmin = session.user.roles.includes('admin');
const canDeleteUsers = session.user.permissions.includes('delete_user');
}Infrastructure as Code with Terraform
terraform {
required_providers {
authava = {
source = "authava/authava"
version = "~> 0.1.0"
}
}
}
provider "authava" {
api_token = var.authava_api_token
# Optional: host = "https://api.authava.com/v1"
}resource "authava_domain" "example" {
domain = "auth.example.com"
# Email settings
email_provider = "authava"
from_email = "[email protected]"
from_name = "Example Auth"
# Whitelabel settings
company_name = "Example Corp"
logo_url = "https://example.com/logo.png"
favicon_url = "https://example.com/favicon.ico"
primary_color = "#2563eb"
secondary_color = "#4f46e5"
footer_text = "© 2024 Example Corp"
terms_url = "https://example.com/terms"
privacy_url = "https://example.com/privacy"
# Allowed origins
origins = [
"dashboard.example.com",
"auth.example.com"
]
}How Authava Works
Authava simplifies authentication with a powerful, flexible platform that integrates seamlessly with your application.
resource "authava_domain" "main" {
domain = "auth.${var.app_domain}"
company_name = var.company_name
logo_url = var.logo_url
primary_color = var.brand_color
origins = [
"auth.${var.app_domain}",
"dashboard.${var.app_domain}"
]
}Set Up Your Auth Domain
Create a custom authentication domain with your branding, colors, and allowed origins. Deploy with infrastructure-as-code or through our dashboard.
import { AuthavaProvider } from '@authava/react-client';
function App() {
return (
<AuthavaProvider
config={{
domain: 'auth.yourdomain.com',
autoRefresh: true
}}
>
<YourApplication />
</AuthavaProvider>
);
}Integrate the SDK
Add Authava to your application with just a few lines of code. Our SDKs handle authentication flows, session management, and token refresh automatically.
import { useAuthava } from '@authava/react-client';
function Profile() {
const { session, isLoading } = useAuthava();
if (isLoading) return <Spinner />;
if (!session) return <LoginRedirect />;
return (
<div>
<h1>Welcome, {session.user.name}!</h1>
<UserDetails user={session.user} />
</div>
);
}Protect Your Routes
Use our hooks and components to protect routes, check permissions, and display user information. Authava handles the complex authentication logic for you.
Manage & Monitor
Use the Authava dashboard to manage users, view authentication metrics, configure social providers, and customize your authentication experience.
import { useAuthava } from '@authava/react-client';
function ProfileManagement() {
const {
session,
changePassword,
setupTotp,
verifyTotp,
removeMfaMethod
} = useAuthava();
// Access built-in profile management
// or implement your own custom flows
return (
<div>
{/* Use Authava's built-in profile portal */}
<a href={`https://${domain}/profile`}>
Manage Profile
</a>
{/* Or build custom UI with our SDK */}
<CustomProfileUI
onChangePassword={changePassword}
onSetupMFA={setupTotp}
/>
</div>
);
}User Profile Management
Every Authava domain includes a white-labeled profile portal where users can manage their passwords, set up multi-factor authentication, and update their information. Developers can either direct users to this built-in portal or implement custom profile management using our comprehensive SDK.
Getting Started with Authava
Watch our tutorial to learn how to integrate Authava into your application in minutes.
Video Tutorial Coming Soon
Our comprehensive video guide will walk you through setting up Authava from start to finish.
Security-First Architecture
Authava is built with security as a core principle, providing the features you need to protect your users and data.
Multi-Tenant Isolation
Complete data isolation with separate databases per tenant for maximum security and privacy.
Advanced Authentication
Support for MFA, passwordless login, and customizable password policies to protect user accounts.
Audit Logging
Comprehensive audit trails for all authentication events and administrative actions for transparency.
Custom Access Controls
Fine-grained role and permission management with custom access policies for your application.
Modern Authentication
Support for WebAuthn, social login providers, and magic links for a seamless user experience.
Session Management
Configurable session controls including idle timeout, forced logout, and device tracking.
We're committed to continuously improving our security practices as we grow
Learn more about our security approach →Frequently Asked Questions
Get answers to common questions about Authava's authentication platform.
What makes Authava different from other authentication solutions?
Authava combines the flexibility of a custom authentication solution with the convenience of a managed service. We offer true multi-tenant isolation, developer-first SDKs with TypeScript support, and infrastructure-as-code deployment options that integrate seamlessly with your DevOps workflow.
Can I customize the authentication UI to match my brand?
Yes! Authava is fully white-label. You can customize the authentication domain, logo, colors, email templates, and UI components to create a seamless branded experience for your users. All customizations can be managed through our dashboard or via infrastructure-as-code.
What authentication methods does Authava support?
Authava supports a wide range of authentication methods including:
- Email/password authentication
- Magic link (passwordless) login (coming soon)
- Multi-factor authentication (MFA)
- Social login (Google, GitHub, etc.)
- WebAuthn/FIDO2 support (coming soon)
- OAuth 2.0 and OpenID Connect
- SAML for enterprise SSO
- Custom authentication flows
How does Authava handle user data and privacy?
Authava is designed with privacy and security as core principles. We use multi-tenant isolation with separate databases per tenant, ensuring complete data separation. All sensitive data is encrypted at rest and in transit. We're compliant with GDPR, CCPA, and other privacy regulations, and we provide tools to help you meet your compliance requirements.
Can I migrate my existing users to Authava?
Yes, we provide migration tools and APIs to help you transition your existing users to Authava. While our platform supports importing user data, for security reasons, users will need to reset their passwords during the first login. This ensures proper encryption and security standards are maintained. We provide a streamlined password reset flow to make this process as smooth as possible for your users.
How does Authava handle user profile management?
Authava provides a complete solution for user profile management. Every authentication domain includes a white-labeled profile portal where users can manage their passwords, set up multi-factor authentication, update their information, and manage their security settings. This means developers don't have to build these features themselves.
For power users who want more control, our client libraries expose a comprehensive API that allows you to build custom profile management experiences. The @authava/react-client library provides hooks for all profile operations including changePassword, setupTotp, verifyTotp, removeMfaMethod, and more.
What kind of support does Authava offer?
All Authava plans include comprehensive documentation, code examples, and community support. Our paid plans include priority email support, SLAs, and dedicated support channels. Enterprise plans offer dedicated account management, custom implementation assistance, and 24/7 emergency support.
Open Source Client Libraries
Our client libraries are open source and available on GitHub. Contribute, report issues, or customize them to fit your needs.
// Example of a custom authentication flow
import { AuthavaClient } from '@authava/client';
// Initialize with your domain
const authava = new AuthavaClient({
domain: 'auth.yourdomain.com'
});
// Custom login with email and password
async function login(email, password) {
try {
const session = await authava.login({
email,
password,
options: {
redirectTo: '/dashboard',
rememberDevice: true
}
});
return {
user: session.user,
token: session.token,
expiresAt: session.expiresAt
};
} catch (error) {
console.error('Login failed:', error.message);
throw error;
}
}
// Check if user has required permissions
function hasAccess(session, requiredPermissions) {
if (!session) return false;
return requiredPermissions.every(permission =>
session.user.permissions.includes(permission)
);
}Ready to secure your application?
Join our growing community of developers building with Authava.