Clerk Free Tier 2026: The Complete Tutorial for Next.js Developers

Last updated: July 2026

Authentication is every developer’s least favorite problem. You either roll your own (hello, password hashing, session rotation, CSRF tokens, rate limiting, and that one security audit you keep putting off) or you pay a vendor. Clerk has been a popular choice since it launched, but its free tier just got a lot more interesting.

In February 2026, Clerk overhauled its pricing — bumping the free tier from 10,000 to 50,000 monthly retained users (MRUs), scrapping per-app pricing, and eliminating the Enhanced Authentication add-on fee. If you haven’t looked at Clerk since 2023, the numbers are now significantly better. Let’s dig into exactly what you get, how to set it up in Next.js, and how it stacks up against Auth0, Kinde, and Supabase Auth.

---

1. What Is Clerk and Why Use It?

Clerk is a managed authentication and user management platform built specifically for modern frontend frameworks — React, Next.js, Remix, and the broader “JAMstack” ecosystem. Instead of building login screens, password reset flows, email verification, session handling, and MFA yourself, Clerk gives you drop-in UI components that handle all of it.

Why developers choose Clerk over building auth from scratch:

• Pre-built UI components — <SignIn />, <SignUp />, <UserProfile />, <OrganizationSwitcher /> — that look good out of the box and are CSS-customizable.
• Social login — Google, GitHub, Discord, Apple, and 30+ OAuth providers with a single toggle in the dashboard.
• Server-side session management — Clerk handles JWTs, session tokens, and cookie rotation. You just read auth().
• Organizations & RBAC — Multi-tenancy built in, not bolted on.
• Webhook integrations — Sync user data to your own database whenever users sign up, update profiles, or delete accounts.

As one Reddit user put it on r/reactjs: “Clerk just works. You don’t have to think about auth and can focus on business logic. The generous free tier makes it a no-brainer for side projects.” (source)

---

2. Clerk Free Tier Features & Limits (2026)

Clerk’s free plan is now called Hobby. Here’s exactly what’s included as of July 2026:

Feature	Free (Hobby)	Pro ($25/mo)
Monthly Retained Users	50,000 MRU	50,000 MRU, then $0.02/MRU
Organizations	100	100 (B2B add-on: $100/mo for more)
Custom Domain	✅	✅
Social Login Providers	✅ (unlimited providers)	✅
MFA (TOTP)	✅	✅
Pre-built Auth UI	✅	✅
Webhooks	✅	✅
Dashboard Seats	3	Unlimited
Remove Clerk Branding	❌	✅
SAML / Enterprise SSO	❌	$75/connection/mo
SMS MFA / Phone Auth	❌	Pay-as-you-go
Audit Logs	❌	✅

Key detail: “Monthly Retained Users” vs “Monthly Active Users”. Clerk counts an MRU as a user who visits your app at least one day after their initial signup. Brand-new signups in their first month don’t count. This is slightly more generous than raw MAU counting because trial-period users are effectively free.

Source: Clerk Pricing Page | Source: SuperTokens Pricing Breakdown

What’s NOT in the free tier (watch out for these)

• B2B Organizations add-on — While you get 100 organizations on Hobby, advanced org features (SCIM, SAML SSO per org) require the $100/mo B2B add-on on Pro.
• Clerk branding — The <SignIn /> component shows “Powered by Clerk” unless you’re on Pro ($25/mo).
• SMS authentication — Not included in free; billed per SMS on paid plans.
• Enterprise SSO — SAML/OIDC connections cost $75/connection/month on Pro.

---

3. Best Use Cases (With Real Examples)

Side Project / MVP (Fits entirely on free)

Example: A community Q&A site for indie hackers. You need Google/GitHub login, user profiles, and maybe 500–5,000 users in year one. Clerk’s free tier gives you 50K MRU — you’ll never hit the limit. The pre-built <SignUp /> component means you ship auth in an afternoon instead of a week.

B2C SaaS Bootstrapping

Example: A habit-tracking app targeting 10,000 free users. Social login + MFA keep signups frictionless. The 100-organization limit doesn’t matter for a consumer app. At 50K MRU, you have enough room to reach meaningful traction before paying anything.

Developer Tool with Organization Needs

Example: A deployment platform handling teams. Clerk’s organization support (invite flows, role-based access, org switching) comes free for up to 100 orgs. The <OrganizationSwitcher /> component gives users a Slack-like org menu with zero code.

What DOESN’T fit the free tier

• Enterprise B2B apps needing SAML SSO (requires $75/connection).
• Apps with >50K retained monthly users on a hobby budget (Pro overage starts at $0.02/user).
• GovTech/regulated apps that need self-hosting (Clerk is fully managed — no self-host option).

---

4. Step-by-Step Setup: Clerk + Next.js (App Router)

Let’s build a working authentication system in Next.js 15 with Clerk. This takes about 15 minutes.

Step 1: Create a Clerk account and application

1. Go to clerk.com and sign up (no credit card required).
2. Click “Add application” in the dashboard.
3. Name your app (e.g., “My SaaS”).
4. Select which social login providers you want (Google and GitHub are good defaults).
5. Copy your Publishable Key (NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY) and Secret Key (CLERK_SECRET_KEY).

Step 2: Install the Clerk Next.js SDK

# Create a new Next.js project (if starting fresh)
npx create-next-app@latest my-app --typescript --tailwind --app
cd my-app

# Install Clerk
npm install @clerk/nextjs

Step 3: Set environment variables

Create a .env.local file:

NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_live_xxxxxxxxxxxx
CLERK_SECRET_KEY=sk_liv...xxxx

Step 4: Add Clerk middleware

Create middleware.ts at the root of your project:

import { clerkMiddleware } from '@clerk/nextjs/server'

export default clerkMiddleware()

export const config = {
  matcher: [
    // Skip Next.js internals and static files
    '/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)',
  ],
}

This protects all routes by default. Unauthenticated users are redirected to the sign-in page.

Step 5: Wrap your app with <ClerkProvider>

Edit app/layout.tsx:

import { ClerkProvider } from '@clerk/nextjs'
import type { Metadata } from 'next'
import './globals.css'

export const metadata: Metadata = {
  title: 'My App',
}

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <ClerkProvider>
      <html lang="en">
        <body>{children}</body>
      </html>
    </ClerkProvider>
  )
}

Step 6: Add sign-in and sign-up pages

Create app/sign-in/[[...sign-in]]/page.tsx:

import { SignIn } from '@clerk/nextjs'

export default function SignInPage() {
  return (
    <div className="flex min-h-screen items-center justify-center">
      <SignIn />
    </div>
  )
}

Create app/sign-up/[[...sign-up]]/page.tsx:

import { SignUp } from '@clerk/nextjs'

export default function SignUpPage() {
  return (
    <div className="flex min-h-screen items-center justify-center">
      <SignUp />
    </div>
  )
}

The [[...sign-in]] catch-all route pattern is intentional — Clerk uses route parameters to render different auth steps (forgot password, verify email, etc.) on the same page.

Step 7: Create a dashboard page (protected)

Create app/dashboard/page.tsx:

import { auth, currentUser } from '@clerk/nextjs/server'
import { redirect } from 'next/navigation'

export default async function DashboardPage() {
  const { userId } = auth()
  
  if (!userId) {
    redirect('/sign-in')
  }

  const user = await currentUser()

  return (
    <main className="p-8">
      <h1 className="text-2xl font-bold">Welcome, {user?.firstName}!</h1>
      <p className="mt-2 text-gray-600">
        Signed in as {user?.emailAddresses[0]?.emailAddress}
      </p>
    </main>
  )
}

Step 8: Add a user button in your navbar

Edit app/layout.tsx to include the <UserButton />:

import { ClerkProvider, UserButton, auth } from '@clerk/nextjs'
import Link from 'next/link'

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  const { userId } = auth()

  return (
    <ClerkProvider>
      <html lang="en">
        <body>
          <nav className="flex items-center justify-between border-b px-8 py-4">
            <Link href="/" className="font-bold">My App</Link>
            <div className="flex items-center gap-4">
              {userId ? (
                <UserButton afterSignOutUrl="/" />
              ) : (
                <Link href="/sign-in" className="text-blue-600 hover:underline">
                  Sign In
                </Link>
              )}
            </div>
          </nav>
          {children}
        </body>
      </html>
    </ClerkProvider>
  )
}

Step 9: Run it

npm run dev

Visit http://localhost:3000/sign-up, create an account, and you’ll be redirected to /dashboard. Full auth — email verification, session management, social login — working in under 15 minutes.

Source: Clerk Official Next.js Quickstart | Source: StackNotice Complete Guide

---

5. Comparison: Clerk vs Auth0 vs Kinde vs Supabase Auth

Here’s how the free tiers stack up side-by-side:

	Clerk (Hobby)	Auth0 (Free)	Kinde (Free)	Supabase Auth (Free)
Free User Limit	50,000 MRU	7,500 MAU	10,500 MAU	50,000 MAU
Organizations	100	5 (limited)	Unlimited	Via RLS policies
Social Login	✅ Unlimited	✅	✅	✅ (50K MAU)
MFA (TOTP)	✅	❌ (paid only)	✅	✅
Custom Domain	✅	❌	❌ (paid)	❌
Pre-built UI	✅ (React)	✅ (Universal Login)	✅ (React)	❌ (build your own)
SAML/SSO	❌ ($75/conn)	✅ (limited)	✅ (free)	❌
Remove Branding	❌ (Pro: $25/mo)	❌ (Essentials: $35/mo)	❌ (Pro: $35/mo)	N/A (no UI)
Price After Free	$25/mo (Pro)	$35/mo (Essentials)	$35/mo (Pro)	$25/mo (Pro)
Cost at 100K Users	~$1,000/mo	~$1,500/mo	~$1,250/mo	~$162/mo

When to pick each one

Clerk — Best if you’re building a Next.js or React app and want to ship auth in an hour with pre-built, good-looking UI components. The 50K MRU free tier is the most generous among dedicated auth providers (not counting Supabase, which isn’t auth-only).

Auth0 — Feels increasingly dated for new projects. The free tier dropped from 25K to 7,500 MAU, and the pricing at scale (starting at $1,725/mo for 7,500 MAU on Essentials) is notoriously unpredictable. Auth0 still wins for enterprise compliance requirements. (source)

Kinde — The dark horse. The free tier is smaller (10,500 MAU) but includes SAML SSO on the free plan — something Clerk charges $75/connection for. Kinde also bundles feature flags and basic billing. If you’re building a B2B SaaS that needs SSO from day one, Kinde’s free tier is actually stronger. (source)

Supabase Auth — The best option if you’re already using Supabase for your database. The 50K MAU free tier matches Clerk, and the per-MAU cost at scale ($0.00325) is roughly 6x cheaper than Clerk’s $0.02 overage. The catch: there are no pre-built UI components — you build your own login forms. (source)

---

6. Tips to Maximize the Free Tier

1. Use MRU to your advantage

Clerk counts retained users, not raw signups. New users in their first 30 days don’t count. If your app has a high churn rate or lots of trial users, your billable count stays lower than raw signups would suggest.

2. Leverage custom domains on the free plan

Unlike most competitors, Clerk includes custom domains (auth.yourdomain.com) on the Hobby plan. Set this up early — it improves login page trust and is a pain to migrate later. Configure it in Dashboard → Domains.

3. Use webhooks to sync users to your database

Even on the free plan, Clerk fires webhooks on user.created, user.updated, and user.deleted. Set up a route handler to sync user data to your own DB:

// app/api/webhooks/clerk/route.ts
import { Webhook } from 'svix'
import { headers } from 'next/headers'
import { WebhookEvent } from '@clerk/nextjs/server'

export async function POST(req: Request) {
  const SIGNING_SECRET = process.env.CLERK_WEBHOOK_SECRET
  
  if (!SIGNING_SECRET) throw new Error('Missing webhook secret')
  
  const wh = new Webhook(SIGNING_SECRET)
  const headerPayload = headers()
  const svixId = headerPayload.get('svix-id')
  const svixTimestamp = headerPayload.get('svix-timestamp')
  const svixSignature = headerPayload.get('svix-signature')
  
  const payload = await req.json()
  const body = JSON.stringify(payload)
  
  const evt = wh.verify(body, {
    'svix-id': svixId!,
    'svix-timestamp': svixTimestamp!,
    'svix-signature': svixSignature!,
  }) as WebhookEvent

  if (evt.type === 'user.created') {
    // Sync user to your database
    await db.user.upsert({
      where: { clerkId: evt.data.id },
      update: {},
      create: { clerkId: evt.data.id, email: evt.data.email_addresses[0].email_address }
    })
  }

  return new Response('OK', { status: 200 })
}

4. Use organizations as your tenant model

The free plan includes up to 100 organizations. If you’re building a B2B2C app, you can map each customer to an organization and use Clerk’s built-in org switching rather than building your own multi-tenancy.

5. Minimize SMS and phone auth usage

SMS verification is not included in the free tier and is billed per-message on paid plans. Default to TOTP MFA (which is free) and only fall back to SMS if users specifically need it.

6. Don’t worry about the “Powered by Clerk” badge on MVP

Removing Clerk branding costs $25/mo. If you’re pre-revenue, leave it. Users don’t care about auth badges nearly as much as developers do. Swap to a paid plan when you have revenue to justify the polish.

7. Monitor your MRU count

Clerk’s dashboard shows your MRU count in real-time. Set up a monthly reminder to check it — the jump from 49K to 51K MRU moves you from free to paying $0.02 per additional user. Plan your pricing tier upgrade before you hit the limit.

---

Final Verdict

Clerk’s free tier is currently the most developer-friendly auth option for Next.js and React apps — especially after the February 2026 pricing overhaul. The 50,000 MRU limit means most side projects, MVPs, and early-stage SaaS apps will never pay a cent. The pre-built UI components genuinely save days of development time.

The trade-offs — hosted UI lock-in, no SAML SSO on free, and the pricing jump at scale — are real but manageable. Know them going in, plan your upgrade path, and Clerk’s free tier will carry you from zero to product-market fit without an auth bill.

---

Sources: Clerk Pricing, Clerk Changelog (Feb 2026), Clerk Next.js Quickstart, SuperTokens Pricing Guide, StackNotice Next.js Auth Guide, Auth0 vs Clerk vs Supabase Comparison

References

[1] source [2] Source: Clerk Pricing Page [3] Source: SuperTokens Pricing Breakdown [4] clerk.com [5] Source: Clerk Official Next.js Quickstart [6] Source: StackNotice Complete Guide