Let’s be honest: setting up authentication is usually the part of a project we dread most. Between handling session cookies, managing OAuth callbacks, and keeping your database schemas in sync, it’s easy to lose days to "auth hell."

Recently, Better Auth has emerged as a breath of fresh air. It’s type-safe, plays incredibly well with the Next.js App Router, and, when paired with MongoDB's flexibility, it creates a stack that’s both easy to build and ready to scale.

In this guide, I’m going to walk you through exactly how to wire these three together.

Why this specific stack?

If you’re building a modern web app (like a tool ecosystem or a technical blog), you need three things:

Speed: You don't want to reinvent the wheel for a "Forgot Password" flow.
Safety: TypeScript shouldn't just be an afterthought; it should protect your auth data.
Flexibility: MongoDB lets your user profiles grow without the headache of rigid SQL migrations.

Step 1: The Essentials

First, let's grab the tools we need. We're using the native MongoDB driver for Better Auth's internals and Mongoose for our application logic.

npm install better-auth mongodb mongoose

npm install @types/node --save-dev

Step 2: Environment Setup

Your .env.local is the "brain" of your auth. Make sure your BETTER_AUTH_URL is set correctly, or your cookies will fail to save.

# MongoDB Connection

MONGODB_URI=mongodb+srv://...

# Better Auth

BETTER_AUTH_SECRET=...

BETTER_AUTH_URL=http://localhost:3000 # Base URL of your app

# OAuth (Get these from Google/GitHub Dev Consoles)

GOOGLE_CLIENT_ID=...

GOOGLE_CLIENT_SECRET=...

# Email (We'll use Resend for this guide)

RESEND_API_KEY=...

Step 3: Handling the "Double Connection"

Here is a common point of confusion: Better Auth needs a Native MongoDB Client, while your app likely uses Mongoose. We’ll set up both to coexist peacefully.

3.1 The Native Driver (For Better Auth)

Create lib/db.ts. This is lightweight and stays out of your way.

import { MongoClient } from "mongodb";

const client = new MongoClient(process.env.MONGODB_URI!);

export const db = client.db();

export { client };

3.2 The Mongoose Connection (For Your App)

Create lib/mongoose.ts. We use a "singleton" pattern here to prevent your server from opening a hundred connections every time you save a file during development.

import mongoose from "mongoose";

let initialized = false;

export const connectToDB = async () => {

if (initialized && mongoose.connection.readyState === 1) return;

try {

await mongoose.connect(process.env.MONGODB_URI!);

initialized = true;

console.log("✅ Database Handshake Complete");

} catch (error) {

console.error("❌ Database Connection Failed:", error);

}

};

Step 4: The Heart of the System (Server Config)

This is where the magic happens. In lib/auth.ts, we’re telling Better Auth how to behave, including requiring email verification before anyone can log in.

import { betterAuth } from "better-auth";

import { mongodbAdapter } from "better-auth/adapters/mongodb";

import { db, client } from "./db";

import { Resend } from "resend";

import { admin } from "better-auth/plugins";

import { nextCookies } from "better-auth/next-js";

const resend = new Resend(process.env.RESEND_API_KEY);

export const auth = betterAuth({

database: mongodbAdapter(db, { client }),

emailAndPassword: {

enabled: true,

requireEmailVerification: true, // Safety first!

},

socialProviders: {

google: {

clientId: process.env.GOOGLE_CLIENT_ID!,

clientSecret: process.env.GOOGLE_CLIENT_SECRET!,

},

},

plugins: [

admin(), // Adds admin functionality

nextCookies(), // Next.js cookie handling

],

// Better Auth will call this when a user needs to verify their email

emailVerification: {

sendVerificationEmail: async ({ user, url }) => {

await resend.emails.send({

from: "YourApp <onboarding@yourdomain.com>",

to: user.email,

subject: "Verify your account",

html: `<p>Welcome aboard! Click <a href="${url}">here</a> to verify.</p>`,

});

},

},

});

Understanding the Configuration

MongoDB Adapter: The mongodbAdapter(db, { client }) tells Better Auth to use MongoDB as its storage backend. It automatically creates the necessary collections for users, sessions, accounts, and verification tokens.
Email Verification: Setting requireEmailVerification: true ensures users must verify their email before accessing protected routes, a critical security feature.
OAuth Providers: Better Auth handles the OAuth flow automatically. You just need to provide the client credentials.
Plugins: - admin(): Adds role-based access control. - nextCookies(): Optimizes cookie handling for Next.js

Step 5: Bridging the Gap (API Routes)

In the App Router, we handle all auth requests with a single catch-all route. Create app/api/auth/[...all]/route.ts.

import { auth } from "@/lib/auth";

import { toNextJsHandler } from "better-auth/next-js";

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

Step 6: Client-Side Auth Configuration

Create lib/auth-client.ts:

import { createAuthClient } from "better-auth/react";

export const authClient = createAuthClient({

baseURL: process.env.NEXT_PUBLIC_APP_URL,

});

This client provides React hooks for authentication in your components.

Step 7: Using Auth in your Components

Better Auth provides a really clean useSession hook. Here’s how you’d use it on a client-side "Profile" page:

"use client";

import { authClient } from "@/lib/auth-client";

export default function Profile() {

const { data: session, isPending } = authClient.useSession();

if (isPending) return <p>Checking credentials...</p>;

if (!session) return <p>Please sign in to view this page.</p>;

return (

<div>

<h1>Hey, {session.user.name}!</h1>

<button onClick={() => authClient.signOut()}>Log Out</button>

</div>

);

}

Step 8: What’s happening in MongoDB?

Once a user signs up, Better Auth automatically populates your database. You don't need to manually create these, but it’s good to know they’re there:

Collection	Purpose
user	The source of truth for your users.
session	Tracks who is currently logged in (and from where).
account	Maps a user to their OAuth (Google/GitHub) details.
verification	Stores those temporary tokens for email verification.

Step 9: Mongoose Schemas for Extended User Data

While Better Auth manages core authentication, you can extend user data with Mongoose schemas.

import mongoose from "mongoose";

const userSchema = new mongoose.Schema(

{

name: String,

email: {

type: String,

unique: true,

},

emailVerified: Boolean,

image: String,

role: {

type: String,

default: "user",

},

banned: {

type: Boolean,

default: false,

},

},

{

timestamps: true,

strict: false, // Allow Better Auth to add additional fields

collection: "user", // Must match Better Auth's collection name

}

);

const User = mongoose.models.User || mongoose.model("User", userSchema);

export default User;

Pro Tips for Production

Strictly False: If you extend the User model using Mongoose, set strict: false in your schema. This ensures Mongoose doesn't strip out fields that Better Auth adds automatically.
Edge Runtime: Better Auth is designed to be fast. If you're on Vercel, it works beautifully with the Edge runtime, though you'll need to ensure your MongoDB connection string is compatible.
Indexing: Once you hit your first 1,000 users, make sure to add an index on the email field in your MongoDB collection to keep logins snappy.

Wrapping Up

That’s it! You now have a type-safe, flexible, and fully featured authentication system. No more wrestling with low-level cookie logic, just a clean API that lets you get back to building the actual features of your app.