Web SDK

One SDK. The framework you already use.

UI, hooks, sessions for the web stack you have. Same session on the API.

Same primitives: React, Vue, Svelte, Angular — same session shape.
Typed components and hooks: Accessible UI and hooks. Types ship in the package.
Client plus server: Components on the client. Middleware on the server. Same session.
npm install @authdog/web-sdk: One package. Framework entrypoints. No rewrite per provider.

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

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>
  );
}

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>;
}

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>;
}

123456789101112131415import express from "express";
import { createAuthdog } from "@authdog/express";

const app = express();
const authdog = createAuthdog({
  publicKey: process.env.PK_AUTHDOG!,
});

app.use(authdog.attachSession());

app.get("/me", authdog.requireAuth, (req, res) => {
  res.json(req.authdog!.user);
});

app.listen(3000);

1234567891011121314import Fastify from "fastify";
import { authdogPlugin } from "@authdog/fastify";

const app = Fastify();

await app.register(authdogPlugin, {
  publicKey: process.env.PK_AUTHDOG!,
});

app.get("/me", {
  preHandler: app.authdog.requireAuth,
}, async (request) => request.authdog!.user);

await app.listen({ port: 3000 });

Frontend frameworks

UI and hooks for your framework

Components, hooks, route guards. Pick the framework, read that page.

Next.js

React

Sign-in, profile, dropdown. Import @authdog/react-elements. Restyle them.

Remix

Session in the loader. Guard in the action. Cookie sessions.

TanStack Start

Server functions, loaders, cookie sessions. Typed from session to UI.

Vue

Provider, composables, server helpers. useUser in the component.

SvelteKit

hooks.server handle, helpers, per-request session. No UI-framework lock-in.

Astro

Middleware and per-request helpers. Islands stay UI-framework-free.

Angular

Signals service, HTTP interceptor, route guard. Fits Angular DI.

React Native

Deep-link login, secure token storage, hooks. React Native and Expo.

Gatsby

Provider in the UI. Helpers in Gatsby Functions.

RedwoodJS

Provider on web, helpers on api. One session across both sides.

Backend frameworks

Verify the same session on your API

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

Express

Session middleware, requireAuth, logout. Express 4 or 5.

Fastify

Plugin, requireAuth, typed request. Session checked on every request.

Go

Gin middleware, RequireAuth, typed session. Same wire as Node.

Python

Resolver, require_auth, logout. FastAPI, Flask, Django, Starlette, aiohttp. One core.

FastAPI

Resolver, require_auth, logout as FastAPI dependencies. Typed AuthdogContext.

Django

Middleware, require_auth decorator, logout. Sits on the Django request.

Flask

Resolver, require_auth, logout. Context lives on flask.g.

Starlette

ASGI middleware plus async session and require_auth for pure Starlette. FastAPI uses its own binding.

aiohttp

An aiohttp middleware and a require_auth wrapper that gate handlers on the same shared core.

Rust

Middleware, AuthContext extractor, require_auth. axum, actix-web, Rocket, warp, poem.

Kotlin

Resolver, requireAuth, logout for Ktor. Same wire as Node.

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.

Install the SDK for your stack

API key from the console. Entrypoint for the framework. Session on the next request.

Get your API key