Guide

Better Auth, l'authentification sur ton propre serveur

Better Auth est une bibliothèque d'authentification TypeScript sous licence MIT qui stocke les comptes dans ta base. Installation, plugins, sécurité et pièges.

L'équipe CodeWorlds21 min de lecture ·

Pratique HTML et CSS dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Better Auth est une bibliothèque d'authentification TypeScript qui s'exécute dans ton processus et stocke les comptes dans ta propre base de données. La version actuelle est la 1.7.1, la licence est MIT, et le dépôt better-auth/better-auth compte environ 29,6 mille étoiles. Il n'y a pas de frais par utilisateur ici, mais la maintenance et la sécurité restent de ton côté.

En quoi elle diffère d'un service hébergé

Des services comme Clerk ou Auth0 prennent en charge toute la couche d'identité. L'utilisateur arrive sur leur domaine ou sur leur composant, ils émettent le token, ils détiennent la table des comptes, et ton application reçoit un identifiant tout fait. La facture croît avec le nombre d'utilisateurs actifs, car c'est le modèle de facturation de toute cette catégorie d'outils.

Better Auth place cette frontière à l'endroit opposé. Tu installes une dépendance, tu montes un seul handler sous le chemin /api/auth/* et tu lui donnes une connexion à la base de données. À partir de là, les tables user, session, account et verification se trouvent à côté de tes propres tables, et les mots de passe ainsi que les tokens de session ne passent que par ton processus. Les seules requêtes sortantes sont celles que tu initie toi-même vers un fournisseur de connexion sociale.

Cet arrangement a deux faces et les deux méritent d'être regardées avant de décider. Côté gain, tu obtiens la pleine propriété des données, aucun frais qui croît avec le nombre de comptes et la possibilité d'ajouter une colonne à la table des utilisateurs sans demander la permission à personne. Les requêtes qui joignent un compte au reste de ton modèle de domaine sont de simples jointures en base plutôt que des appels à une interface de fournisseur avec un quota de requêtes.

Côté coût, il y a ce qu'on oublie facilement au stade du prototype. Les mises à jour de sécurité sont à appliquer par toi, dans un délai raisonnable. Surveiller les tentatives de connexion, faire tourner les secrets, traiter les signalements de compte compromis, satisfaire l'auditeur d'un client entreprise, tout cela passe à ton équipe. Un fournisseur hébergé te donne un rapport d'audit de sécurité que tu peux simplement transmettre. Avec ta propre installation, il n'y a rien à transmettre.

L'échelle du projet est respectable pour une bibliothèque née en mai 2024. Le registre npm indique environ 5,9 millions de téléchargements pour la semaine se terminant le 19 août 2026, le dépôt n'est pas archivé, et le dernier commit date du jour où ce texte a été écrit. Les issues ouvertes sont au nombre d'environ six cent soixante, ce qui, à ce rythme de développement, dit que la liste de choses à faire grandit aussi vite que la bibliothèque elle-même.

Installation, version et licence

La situation de la licence est simple ici, même si dans cette catégorie de bibliothèques la simplicité n'est pas la norme. J'ai vérifié trois sources et toutes disent la même chose. Le fichier LICENSE.md du dépôt contient le texte MIT avec une mention de copyright pour Bereket Engida datant de 2024. Le champ license dans les métadonnées du paquet sur le registre npm indique MIT. Le paquet publié de la version 1.7.1, téléchargé et lu de l'intérieur, contient le même texte MIT. L'interface GitHub indique aussi MIT. Il n'y a pas de divergence du genre qui peut te surprendre lors d'un audit de dépendances ailleurs.

L'installation elle-même tient en une commande, après quoi il te faut encore un secret et une adresse de base pour l'application.

Bash
npm install better-auth

# generate a secret with the command line tool
npx @better-auth/cli@latest secret

# minimal .env file
# BETTER_AUTH_SECRET=generated_value
# BETTER_AUTH_URL=http://localhost:3000

Les variables d'environnement que la bibliothèque lit d'elle-même sont BETTER_AUTH_SECRET, BETTER_AUTH_URL et BETTER_AUTH_TRUSTED_ORIGINS. Il y a aussi BETTER_AUTH_SECRETS, destinée à la rotation, où tu fournis une liste d'entrées séparées par des virgules au format <version>:<secret>. La première entrée est la courante, les autres servent à lire les anciennes signatures, donc une rotation n'invalide pas toutes les sessions d'un coup.

Si tu laisses le secret non défini, la bibliothèque se rabat sur une valeur par défaut en développement, tandis qu'en production elle lève une erreur avec un message sans ambiguïté. C'est un bon comportement, mais il a un effet de bord : les sessions créées en local ne se transposeront pas en production, car elles ont été signées avec une autre clé. Un avertissement sur un secret trop court apparaît en dessous de trente-deux caractères.

La configuration serveur vit généralement dans un fichier auth.ts et se résume à un seul appel de fonction.

TypeScript
import { betterAuth } from 'better-auth'
import { drizzleAdapter } from 'better-auth/adapters/drizzle'
import { db } from './db'
import * as schema from './db/schema'

export const auth = betterAuth({
  appName: 'my-application',
  baseURL: process.env.BETTER_AUTH_URL,
  basePath: '/api/auth',
  secret: process.env.BETTER_AUTH_SECRET,
  database: drizzleAdapter(db, {
    provider: 'pg',
    schema,
    usePlural: false,
    camelCase: true
  }),
  emailAndPassword: {
    enabled: true,
    minPasswordLength: 8,
    maxPasswordLength: 128,
    requireEmailVerification: true,
    autoSignIn: true,
    revokeSessionsOnPasswordReset: true,
    sendResetPassword: async ({ user, url }) => {
      await sendMail(user.email, url)
    }
  },
  socialProviders: {
    github: {
      clientId: process.env.GITHUB_CLIENT_ID!,
      clientSecret: process.env.GITHUB_CLIENT_SECRET!
    }
  },
  session: {
    expiresIn: 60 * 60 * 24 * 7,
    updateAge: 60 * 60 * 24,
    freshAge: 60 * 60 * 24,
    cookieCache: { enabled: true, maxAge: 5 * 60 }
  },
  trustedOrigins: ['https://my-application.com'],
  telemetry: { enabled: false }
})

Les valeurs montrées ci-dessus pour la section session sont aussi les valeurs par défaut, donc tu peux les omettre. Une session vit sept jours, se rafraîchit au plus une fois par jour et compte comme fraîche pendant vingt-quatre heures après la connexion, ce qui importe pour les opérations sensibles comme la suppression d'un compte. Le cache de session dans un cookie est par défaut de cinq minutes et reste désactivé tant que tu ne l'actives pas.

Les dépendances peer sont toutes marquées comme optionnelles, donc ton gestionnaire de paquets ne t'imposera rien d'inutile. La liste comprend next, react, vue, svelte, solid-js, @sveltejs/kit, @tanstack/react-start, ainsi que les pilotes de base de données pg, mysql2, mongodb et better-sqlite3. Tu ne choisis que ce que tu utilises vraiment.

Schéma de base de données et outil en ligne de commande

Le cœur de la bibliothèque a besoin de quatre tables. user contient l'identité, session les sessions actives, account les liens vers les fournisseurs externes ainsi que le mot de passe, et verification les tokens à usage unique pour la vérification d'adresse et les réinitialisations de mot de passe. Une cinquième table, rateLimit, n'apparaît que lorsque tu passes la limitation de requêtes sur un stockage en base de données.

Les plugins ajoutent leurs propres tables. La connexion à deux facteurs ajoute twoFactor avec les champs secret, backupCodes, verified, failedVerificationCount et lockedUntil. Le plugin organization ajoute organization, member, invitation, plus team et teamMember quand les équipes sont activées, et organizationRole en plus quand les rôles dynamiques sont utilisés.

Tu n'écris pas le schéma à la main. Un outil séparé en ligne de commande le génère, publié sous le nom de paquet @better-auth/cli, aujourd'hui en version 1.4.21 et lui aussi sous MIT.

Bash
# generate the schema file from the configuration in auth.ts
npx @better-auth/cli@latest generate --config ./src/auth.ts --output ./src/db/schema.ts

# apply changes to the database, built-in Kysely adapter only
npx @better-auth/cli@latest migrate --config ./src/auth.ts

# interactively add the library to an existing project
npx @better-auth/cli@latest init --skip-db --package-manager pnpm

# print the detected configuration, useful when diagnosing
npx @better-auth/cli@latest info

Il y a ici un piège qu'il vaut mieux connaître d'avance. La commande migrate ne fonctionne qu'avec l'adaptateur Kysely intégré. Avec Prisma et avec Drizzle, l'outil s'arrête et affiche un message disant que le schéma doit être produit avec generate puis appliqué par le mécanisme de migration propre à cet outil. Ce n'est ni un bug ni un oubli mais une décision délibérée : ces deux bibliothèques gardent leur propre historique de migrations, et y toucher de l'extérieur finirait en état divergent.

Les adaptateurs disponibles sont Drizzle, Prisma, MongoDB, Kysely et un adaptateur en mémoire pour les tests. L'adaptateur Drizzle prend une instance de base de données et un objet de configuration avec un champ provider acceptant pg, mysql ou sqlite, suivi de schema, usePlural, camelCase, schemaName, transaction et debugLogs. Si tes tables sont nommées au pluriel ou vivent dans un schéma de base séparé, tu le règles ici au lieu de modifier le fichier généré.

Les sections user, session, account et verification de la configuration te permettent d'ajouter tes propres colonnes à ces tables et de renommer les champs pour suivre la convention du reste de ta base. C'est la différence avec un service hébergé que l'on n'apprécie qu'après quelques mois de produit. Un numéro de client issu du système comptable, des réglages de notifications, un indicateur d'acceptation des conditions, tout peut se trouver dans la même table que l'adresse e-mail, et une requête qui joint ces données est une simple requête de base de données. Dans la variante hébergée, tu gardes généralement une seconde table de profils de ton côté et tu maintiens la synchronisation avec le compte chez le fournisseur, et chaque divergence entre ces deux sources de vérité est un bug que quelqu'un devra finir par reproduire et corriger.

Client, session et intégration avec Next.js

Côté navigateur, tu crées un client avec createAuthClient. Tu choisis l'import selon ton framework, car la bibliothèque publie des variantes séparées sous better-auth/react, better-auth/vue, better-auth/svelte, better-auth/solid et better-auth/client pour le code qui n'utilise aucun d'eux.

TSsrc/lib/auth-client.ts
// src/lib/auth-client.ts
import { createAuthClient } from 'better-auth/react'

export const authClient = createAuthClient({
  baseURL: process.env.NEXT_PUBLIC_APP_URL
})

// src/app/api/auth/[...all]/route.ts
import { toNextJsHandler } from 'better-auth/next-js'
import { auth } from '@/auth'

export const { GET, POST } = toNextJsHandler(auth)

// client component
export function Profile() {
  const { data, isPending, error, refetch } = authClient.useSession()

  if (isPending) return <p>Loading</p>
  if (error) return <p>{error.message}</p>
  if (!data) return <button onClick={() => authClient.signIn.social({ provider: 'github' })}>Sign in</button>

  return (
    <div>
      <span>{data.user.email}</span>
      <button onClick={() => authClient.signOut().then(() => refetch())}>Sign out</button>
    </div>
  )
}

Les méthodes du client reflètent les chemins des endpoints. Le chemin /sign-in/email correspond à authClient.signIn.email, /sign-up/email correspond à authClient.signUp.email, et /revoke-sessions correspond à authClient.revokeSessions. Le hook useSession renvoie un objet avec les champs data, isPending, isRefetching, error et une fonction refetch.

Côté serveur, tu lis la session via auth.api.getSession en passant les en-têtes de la requête. Cet endpoint exige les en-têtes explicitement et accepte deux paramètres de requête, disableCookieCache et disableRefresh, utiles quand tu as besoin de l'état directement depuis la base plutôt que depuis le cache du cookie.

Dans Next.js, tu montes le handler avec toNextJsHandler, qui renvoie des fonctions pour les méthodes GET, POST, PATCH, PUT et DELETE. Au tableau plugins de la configuration serveur, tu ajoutes nextCookies(), et il doit être la dernière entrée de ce tableau, car le plugin écrit les cookies dans un hook qui s'exécute après les autres.

Plugins : connexion à deux facteurs et organisations

Le système de plugins est ce qui distingue cette bibliothèque d'une fine enveloppe autour d'une session. Le paquet de la version 1.7.1 contient vingt-six répertoires de plugins. Outre ceux décrits plus bas, il y a, entre autres, admin, magic-link, email-otp, phone-number, username, anonymous, multi-session, bearer, jwt, generic-oauth, captcha, device-authorization, one-time-token, haveibeenpwned et open-api. Les fournisseurs de connexion sociale intégrés sont au nombre de trente-cinq, de Google et GitHub à Kakao, Naver, Linear et Vercel.

Un plugin est à la fois un ensemble d'endpoints, un fragment de schéma de base de données et une extension de types. Tu l'ajoutes à deux endroits en même temps, sur le serveur et sur le client, sinon l'inférence de types cesse de fonctionner.

TypeScript
// server
import { betterAuth } from 'better-auth'
import { twoFactor, organization } from 'better-auth/plugins'
import { createAccessControl } from 'better-auth/plugins/access'

const ac = createAccessControl({
  invoice: ['read', 'issue', 'cancel'],
  project: ['read', 'edit', 'delete']
})

const accountant = ac.newRole({ invoice: ['read', 'issue'] })

export const auth = betterAuth({
  plugins: [
    twoFactor({
      issuer: 'my-application',
      skipVerificationOnEnable: false,
      trustDeviceMaxAge: 60 * 60 * 24 * 30,
      accountLockout: {
        enabled: true,
        maxFailedAttempts: 5,
        durationSeconds: 900
      }
    }),
    organization({
      allowUserToCreateOrganization: true,
      organizationLimit: 5,
      creatorRole: 'owner',
      membershipLimit: 100,
      invitationExpiresIn: 60 * 60 * 48,
      cancelPendingInvitationsOnReInvite: true,
      requireEmailVerificationOnInvitation: true,
      ac,
      roles: { accountant },
      teams: { enabled: true, allowRemovingAllTeams: false },
      sendInvitationEmail: async ({ email, organization, invitation }) => {
        await sendInvitation(email, organization.name, invitation.id)
      }
    })
  ]
})

// client
import { createAuthClient } from 'better-auth/react'
import { twoFactorClient, organizationClient } from 'better-auth/client/plugins'

export const authClient = createAuthClient({
  plugins: [twoFactorClient(), organizationClient()]
})

La connexion à deux facteurs prend en charge trois méthodes : les codes temporels suivant le standard TOTP, les codes à usage unique envoyés par un canal séparé et les codes de secours. Les endpoints sont /two-factor/enable, /two-factor/disable, /two-factor/get-totp-uri, /two-factor/verify-totp, /two-factor/send-otp, /two-factor/verify-otp, /two-factor/generate-backup-codes et /two-factor/verify-backup-code. Le plugin apporte sa propre règle de limitation de requêtes, trois tentatives par dix secondes, plus un verrouillage de compte optionnel après un nombre défini de vérifications échouées.

Le plugin organization est plus gros et couvre tout le besoin typique d'une application vendue à des entreprises. Il expose trente-cinq endpoints, dont la création et la suppression d'organisations, la vérification qu'un identifiant textuel est libre, la définition de l'organisation active sur la session, le cycle complet des invitations avec refus et annulation, la gestion des membres et des rôles, des équipes avec une liste de membres séparée, et des rôles dynamiques créés à l'exécution une fois que tu actives dynamicAccessControl. Tu construis le système de permissions avec la fonction createAccessControl, en fournissant un ensemble de ressources et les actions autorisées sur elles, et les rôles sont des sous-ensembles de cet ensemble.

Garde une chose en tête : chaque plugin qui modifie le schéma demande de relancer generate et de déployer une migration. Ajouter un plugin seulement dans la configuration se termine par une erreur de table manquante à la première requête qui la touche.

La sécurité qui passe de ton côté

Les mots de passe sont hachés avec scrypt, avec les paramètres N de 16384, r de 16, p de 1 et une longueur de clé de 64 octets, avec un sel aléatoire de seize octets. Le résultat est stocké sous la forme du sel et de la clé séparés par deux-points, tous deux en hexadécimal. Les paramètres sont raisonnables et ne demandent rien de ta part, même si tu peux remplacer tout le mécanisme via emailAndPassword.password avec ses champs hash et verify. C'est la seule voie sensée pour migrer des comptes depuis un système qui utilisait un autre algorithme.

La limitation de requêtes est activée par défaut uniquement en production, avec une fenêtre de dix secondes et une limite de cent requêtes. Le stockage par défaut du compteur est la mémoire du processus, et c'est là que la plupart des déploiements perdent la protection sans s'apercevoir qu'ils l'ont perdue. Dans un environnement serverless, ou derrière un load balancer, chaque instance compte séparément, donc la limite effective est multipliée par le nombre d'instances. La solution est de passer à la base de données ou à un cache déclaré dans secondaryStorage, Redis par exemple.

TypeScript
export const auth = betterAuth({
  rateLimit: {
    enabled: true,
    window: 10,
    max: 100,
    storage: 'secondary-storage',
    customRules: {
      '/sign-in/email': { window: 60, max: 5 },
      '/request-password-reset': { window: 300, max: 3 }
    }
  },
  advanced: {
    ipAddress: {
      ipAddressHeaders: ['cf-connecting-ip', 'x-forwarded-for'],
      disableIpTracking: false
    }
  },
  emailAndPassword: {
    enabled: true,
    password: {
      hash: async (password) => customHash(password),
      verify: async ({ hash, password }) => customVerify(hash, password)
    }
  }
})

La gestion des sessions et des comptes liés est dans le cœur, sans plugin nécessaire. Les endpoints /list-sessions, /revoke-session, /revoke-other-sessions et /revoke-sessions suffisent pour construire un écran de liste des appareils et un bouton qui déconnecte l'utilisateur partout sauf dans le navigateur courant, ce que les gens attendent après un changement de mot de passe. Les liens avec des fournisseurs externes sont gérés par /link-social, /list-accounts et /unlink-account, tandis que les règles de rattachement de comptes par adresse e-mail vivent dans la section account.accountLinking. Cette dernière demande de l'attention : relier un compte à mot de passe à un compte social sur la seule base de l'adresse est pratique et peut tout autant ouvrir la voie à une prise de contrôle de compte, si le fournisseur ne vérifie pas l'adresse d'une manière à laquelle tu peux te fier.

La télémétrie est désactivée par défaut, le champ telemetry.enabled vaut false et ne change pas sans ta décision. C'est quelque chose qu'un auditeur vérifiera, donc une réponse claire aide.

Le reste de la responsabilité se trouve exactement là où le modèle de déploiement l'a placé. Suivre les versions, lire les avis de sécurité, configurer les en-têtes, détecter les attaques par dictionnaire contre des comptes précis, la procédure de récupération de compte, le stockage des sauvegardes de base de données qui contiennent des mots de passe. Rien de cela ne se fait tout seul et personne ne t'enverra une notification disant qu'une dépendance doit être mise à jour. Si personne dans l'équipe ne veut s'en charger, un service hébergé revient moins cher quelle que soit la facture.

Better Auth face aux alternatives

Les prix du tableau viennent des pages de tarifs des éditeurs consultées le 20 août 2026 et se rapportent aux offres en libre-service.

OutilModèle de déploiementOù vivent les comptesFacturationPrincipale limite
Better AuthDépendance dans ton processusTa base de donnéesCoût du serveur et de la base, pas de frais par utilisateurLa maintenance et la sécurité sont à ta charge
ClerkService hébergéInfrastructure de l'éditeurGratuit jusqu'à 50 000 utilisateurs conservés, Pro 25 USD par mois, dépassement à partir de 0,02 USD par utilisateurLa facture grandit avec la base de comptes
Auth0Service hébergéInfrastructure de l'éditeurOffre gratuite jusqu'à 25 000 actifs mensuels, Essentials à partir de 35 USD, Professional à partir de 240 USDLe prix de base des offres payantes couvre 500 utilisateurs
KindeService hébergéInfrastructure de l'éditeurOffre gratuite jusqu'à 10 500 actifs mensuels, Pro 25 USD, utilisateur supplémentaire 0,0175 USDDes frais de transaction de 0,7 pour cent avec le module de facturation
Supabase AuthService managé ou auto-hébergéUn projet Supabase, le tien ou hébergéOffre gratuite jusqu'à 50 000 actifs mensuels, Pro à partir de 25 USD avec 100 000 inclus, puis 0,00325 USD par utilisateurLie l'authentification au reste de la plateforme

Le tableau donne une répartition simple. Si tu as peu d'utilisateurs et peu de temps, un service hébergé est moins cher, car tu paies presque rien et tu ne maintiens rien. Si tu as beaucoup d'utilisateurs de faible valeur individuelle, des comptes gratuits dans un produit freemium par exemple, les frais par utilisateur actif deviennent un poste qui peut dépasser le coût de toute le reste de ton infrastructure. Si tu es lié par l'exigence de garder les données personnelles dans ta propre juridiction ou ton propre réseau, le choix se réduit aux deux dernières lignes du tableau.

Le tableau laisse de côté une autre variante qui ressemble à Better Auth sans l'être. SuperTokens te permet aussi de garder les comptes de ton côté, sauf que ce n'est pas une dépendance dans ton processus mais un service séparé : un core dans un conteneur, une bibliothèque dans le backend et une bibliothèque dans le frontend, avec des versions concordantes exigées entre eux. En échange de cette complexité, tu obtiens un tableau de bord prêt à l'emploi et un ensemble de fonctionnalités mature. Deux choses sont à savoir avant de décider : le répertoire ee du dépôt porte une licence propriétaire distincte, et huit fonctionnalités listées dans le code source du core comme payantes, dont la multi-location, l'authentification multifacteur et la connexion au tableau de bord, exigent une clé de licence même en auto-hébergement. Les comptes gratuits du tableau de bord sont plafonnés à trois.

Erreurs courantes

La première est un secret oublié lors du premier déploiement. En production, la bibliothèque ne démarrera pas, ce qui est la bonne nouvelle ; les ennuis arrivent quand quelqu'un copie le secret de développement en production pour faire une démo à temps. La clé qui signe les sessions se retrouve alors dans le dépôt avec le fichier de configuration.

La deuxième est d'essayer d'utiliser la commande migrate avec Prisma ou Drizzle. L'outil affiche un message qui indique la bonne voie, mais il est facile de le manquer quand la commande s'exécute dans un script de déploiement qui avale la sortie. Le bon ordre est generate, puis une migration via l'outil qui détient l'historique du schéma.

La troisième est de laisser la limitation de requêtes en mémoire de processus sur un déploiement multi-instances. Le symptôme est l'absence de symptômes, car le compteur fonctionne et bloque bien quelque chose, seulement à un seuil multiplié par le nombre d'instances. La vérification prend une minute : envoie une rafale de requêtes et compte combien sont passées avant l'apparition d'une réponse 429.

La quatrième est un plugin ajouté d'un seul côté. Un serveur sans le plugin renvoie 404 pour le chemin que le client appelle, et un client sans le plugin n'a simplement pas la méthode que tu veux invoquer. Le message d'erreur dans le second cas vient de TypeScript et se lit clairement ; dans le premier, il n'apparaît qu'en production.

La cinquième concerne Next.js et l'ordre du tableau plugins. Le plugin nextCookies doit se trouver en dernier, car il s'exécute dans un hook lancé après les autres et écrit les en-têtes qui posent les cookies. Placé plus tôt, il fait que la connexion réussit sur le serveur alors que le navigateur ne reçoit jamais de session.

La sixième est une entrée manquante dans trustedOrigins quand le frontend vit sur un autre domaine que le serveur d'authentification. Les requêtes sont alors rejetées lors de la vérification de l'origine, et le message ne mène pas toujours directement à la cause. Tu peux fournir la liste dans la configuration ou via la variable d'environnement BETTER_AUTH_TRUSTED_ORIGINS.

La septième est de traiter le résultat du hook useSession comme base d'une décision d'accès. C'est un état d'interface, pratique pour afficher un avatar ou masquer un bouton, et rien de plus. Chaque décision d'accès aux données doit être prise sur le serveur via auth.api.getSession. Par-dessus cela s'ajoute le cache de cookie : avec cookieCache activé, la révocation d'une session ne devient visible qu'à l'expiration du cache, cinq minutes par défaut.

FAQ

Better Auth exige-t-elle une base de données précise ?

Non. Les adaptateurs couvrent Drizzle, Prisma, MongoDB et Kysely, et Kysely gère à son tour PostgreSQL, MySQL et SQLite. Il existe aussi un adaptateur en mémoire pour les tests. Si tu utilises quelque chose en dehors de cette liste, tu écris l'adaptateur toi-même en implémentant l'interface des opérations sur les enregistrements.

Peut-on migrer des comptes existants depuis un autre système ?

Oui, à condition d'avoir accès aux hachages des mots de passe. Tu insères des lignes dans les tables user et account et tu remplaces l'algorithme de vérification via emailAndPassword.password pour qu'il accepte l'ancien format. Les comptes reposant uniquement sur la connexion sociale migrent plus facilement, car il suffit du lien entre l'identifiant du fournisseur et l'utilisateur.

La bibliothèque envoie-t-elle de la télémétrie ?

Pas par défaut. Le champ telemetry.enabled vaut false et exige une adhésion explicite. Un paquet de télémétrie séparé figure parmi les dépendances, mais sans ce consentement il n'envoie rien.

Better Auth convient-elle à un environnement serverless ?

Oui, bien que deux choses doivent alors quitter leurs valeurs par défaut. La limitation de requêtes doit passer de la mémoire de processus à la base de données ou à un cache, et avec la courte durée de vie des fonctions il vaut la peine d'envisager d'activer le cache de session dans un cookie pour réduire le nombre de requêtes en base à chaque requête.

Quelle charge de travail représente l'authentification auto-hébergée par rapport à un service hébergé ?

Le premier lancement prend un temps comparable dans les deux cas ; la différence apparaît plus tard. Avec un service hébergé, tu ne maintiens rien et tu reçois un rapport d'audit de sécurité tout fait. Avec ta propre installation, tu es responsable des mises à jour, de la surveillance et des procédures de récupération de compte, ce qui en pratique représente quelques heures par mois et une personne qui garde un œil dessus.

La documentation se trouve sur le site du projet, le code source dans le dépôt GitHub, et les métadonnées du paquet publié dans le registre npm.

À lire aussi