Web SDK

One identity SDK for every web framework

Drop-in auth UI, hooks, and session management for the stack you already ship with, paired with server middleware that verifies the same session on your API.

One SDK, every framework: The same primitives across React, Vue, Svelte, Angular, and more.
Drop-in and typed: Accessible prebuilt components and hooks with full TypeScript types.
Frontend to backend: Client components pair with server middleware, so sessions verify end to end.
npm install @authdog/web-sdk: One package, framework entrypoints, no provider-specific rewrite.

Quick start

Wrap your app, then read the session from a hook

Install the package for your stack, then use the same shape across every framework below.

1Technology

2Package manager

3Library

1npm install @authdog/react-elements

12345678910111213141516171819import { AuthdogProvider } from "@authdog/nextjs-app";

export default function RootLayout({ children }) {
  return (
    <AuthdogProvider>
      <html lang="en">
        <body>{children}</body>
      </html>
    </AuthdogProvider>
  );
}

// Anywhere in the tree
import { useUser } from "@authdog/nextjs-app";

function Profile() {
  const { user } = useUser();
  return <span>{user?.email}</span>;
}

123456789101112131415161718import { AuthdogProvider, useAuth } from "@authdog/react-elements";

function App() {
  return (
    <AuthdogProvider>
      <Dashboard />
    </AuthdogProvider>
  );
}

function Dashboard() {
  const { user, signOut } = useAuth();
  return (
    <button onClick={signOut}>
      Sign out {user?.email}
    </button>
  );
}

12345678910111213import { getSession } from "@authdog/remix-node";

// app/routes/dashboard.tsx
export async function loader({ request }) {
  const session = await getSession(request);
  if (!session) throw redirect("/sign-in");
  return { user: session.user };
}

export default function Dashboard() {
  const { user } = useLoaderData<typeof loader>();
  return <p>Welcome, {user.email}</p>;
}

Frontend frameworks

Prebuilt UI and hooks for your framework

Components, hooks, and route guards tailored to each framework. Pick yours and start integrating.

Next.js

React

Drop-in, accessible auth UI and hooks with @authdog/react-elements. Sign-in, profile, and session management, fully typed.

Remix

Loaders, actions, and cookie-based sessions wired for the Remix data flow. Protect routes without leaving the framework.

TanStack Start

Type-safe auth for TanStack Start with server functions and loaders. End-to-end typed from session to UI.

Vue

Composables and ready-made components for Vue 3. Reactive session state and guarded routes with minimal wiring.

SvelteKit

Hooks, load functions, and form actions for SvelteKit. Server-side sessions with a lightweight client footprint.

Astro

Add auth to Astro pages and endpoints with island-friendly components and middleware. Ship static-first, secure by default.

Angular

Services, guards, and interceptors for Angular. Manage sessions and protect routes with idiomatic DI patterns.

React Native

Native auth flows for Expo and React Native. Secure token storage, deep links, and biometric-ready sign-in.

Gatsby

A React client provider plus server helpers for Gatsby Functions. Wrap your root element once and enforce sessions in src/api routes.

RedwoodJS

A web-side provider and api-side helpers for functions and services. One SDK across both Redwood workspaces, sharing a single session.

Backend frameworks

Verify the same session on your API

Middleware, plugins, and extractors that resolve and enforce sessions on the server.

Express

Middleware to verify sessions and protect routes in any Express API. Drop it in front of the handlers that matter.

Fastify

A Fastify plugin for session verification and route guards. High-throughput auth with first-class TypeScript types.

Go

First-class Gin middleware for session resolution and a RequireAuth gate. On the same wire as the Node SDKs, with idiomatic Go types.

Python

Idiomatic bindings for FastAPI, Flask, Django, Starlette, and aiohttp: a session resolver, a require_auth gate, and a logout handler over one shared core.

FastAPI

A session resolver, a require_auth gate, and a logout handler as first-class FastAPI dependencies. Typed AuthdogContext, resolved once per request.

Django

A session-resolving middleware, a require_auth view decorator, and a logout handler wired into the Django request lifecycle.

Flask

A session resolver cached on flask.g, a require_auth decorator, and a logout handler. Plain Flask, secure by default.

Rust

Session middleware, an AuthContext extractor, and a require_auth gate for axum, actix-web, Rocket, warp, and poem. High-throughput auth with secure defaults.

Kotlin

A Ktor session resolver, a requireAuth gate, and a logout handler for JVM backends. Validate Authdog sessions on the same wire as the Node SDKs.

Free trial

Request a free trial

Tell us what you're building and we'll get you set up with a trial, plus someone who can answer questions as you evaluate.

Full access to the platform while you evaluate it
Help wiring it into your stack from someone who knows it
Answers on SSO, SCIM, residency, and compliance requirements

Install

Add @authdog/web-sdk and import the entrypoint for your framework.

Wrap

Mount the provider once, then read session and user state from a hook.

Enforce

Guard routes on the client and verify the same session on your API.

Ship auth in your framework today

Grab your API key from the console, install the SDK for your stack, and add identity in your next commit.

Get your API key