We've upgraded our `@clerk/nextjs` package to support Next.js 12.2,  Make sure you're on version 3.7.1 or greater.

Peter Perlepes

We're testing out a new email flow.  Our core verification emails are sent through Sendgrid, from 

. Even though we follow all of the best practices, there are a few things we can't account for that still causes some verification/sign-in emails to go to spam.  

For people having trouble, this new email flow should solve your problems:

Emails are sent from `verifications@clerk.dev`

Will only send OTP verifications, since these have historically had less deliverability issues.

If you're having issues, send us an email at `support@clerk.dev` to enable.

Agis Anastasopoulos

Haris Chaniotakis

 - Clerk automatically keeps session tokens alive, now you can customize what data goes into these tokens.  Previously, this was only possible by creating a custom JWT template, and sending it to your backend manually.

Giannis Katsanos

Changelog July 8, 2022

Today, we're thrilled to announce $6.2m in new funding led by Martin Casado at Andreessen Horowitz, with continued participation from S28 Capital, Fathom Capital, and South Park Commons. The formal press release is available below.

This funding marks a major milestone for Clerk. For the first time, we've raised based on the traction of our customers, who are simply blowing us away with their continued success. Here's a chart showing cumulative sign ups across all customer applications since we launched:

Our key insight at Clerk is that the Component is the new API. In fact, over 95% of our customers use 

 components! Of the few who implement our APIs directly, most will build a custom sign-up flow with our APIs, but still use our 

This outcome is obvious in hindsight. Components combine the power of backend APIs with beautiful, prebuilt frontends, so they inherently deliver more value than APIs alone. We believe component-based integrations have set a new standard for developer tools, and we're excited for the massive improvement in developer productivity they enable.

With this new funding, Clerk will reinforce and expand on our foundation, including:

Continued, emphatic support for cutting-edge frameworks like Next.js, Remix, Redwood, and more on the way

Additional authentication strategies like passkeys and SAML SSO

Clerk, the drop-in authentication and user management solution for React, announced today that it has closed a $6.2m seed round led by Andreessen Horowitz. Existing investors S28 Capital, Fathom Capital, and South Park Commons also joined the round. This new funding will allow Clerk to expand its suite of authentication and user management tools, and create new tools to help B2B SaaS companies manage both user accounts and business accounts.

Clerk empowers React developers to build sign-up and sign-in flows as well as user profiles without the assistance of backend developers. The solution comes complete with security essentials like multi-factor authentication and active device management. The beautifully designed React components can be customized to match any company's branding. By providing a full stack solution, Clerk minimizes the time engineers need to spend on authentication, freeing up development resources to focus on the core of their business.

The vast majority of authentication solutions on the market today are still managed in-house and are often incomplete and fail to meet security best practices. Many of these solutions are dated, as web development technologies have evolved to component-based frontend technologies like React. With Clerk’s solution, developers are getting what they prefer—components—because they help them move faster. Components are especially appealing in authentication and user management where businesses do not get much benefit from reinventing the wheel of self-serve 2FA or avatar-uploading. Clerk includes both in their 

"Our key insight is that React Components have replaced REST APIs as the premier developer experience,"

"Since components have a built-in backend and presentation layer, they're an order-of-magnitude faster to implement than APIs."

While Clerk is intended for React frontends, the authentication solution works with any framework, programming language, or API gateway on the backend. This approach has been especially helpful for legacy web applications that are transitioning to React on the frontend, but do not want to change their backend technology.

"There's a growing preference for React among businesses of all sizes, and devtools must evolve to cater to this new architecture. Clerk is hands-down the easiest and most-complete approach to auth and user management in React today,"

"We are excited to help accelerate Clerk's growth and reach more businesses, founders and startups who are looking for easy authentication and user management."

Clerk's vision is to build a truly complete customer management solution for developers, helping facilitate authentication, authorization, communications, billing, and more. Clerk believes these essential services can all be bundled together, and presented cohesively in simple React components.

Notable startups using Clerk include database company Grafbase, women's shapewear company Honeylove, and apartment rental company Blueground. Clerk's React-optimized solution has led the company to be included in Netlify's Jamstack Innovation Fund, and named one of the 

Clerk raises $6.2m led by Andreessen Horowitz

This week Clerk has been focusing on improvements to our documentation, bug fixes, and iterating on our Organization components. 

Our organization components were released just last week, and we received a lot of great feedback from our users. We fixed some bugs and made improvements to the 

Clerk has been working hard on our app directory beta. One of the most significant changes this week is it is now rolled into the latest production package. We also updated our documentation to reflect this, which you can read 

We introduced documentation for alternative backends, starting with TRPC. I am a massive fan of TRPC and its end-to-end type safety. 

If you are thinking about checking out Clerk and love TRPC, we now have 

 on how to integrate them. 

If you want to see everything in action, check out the 

A special thanks to Molo Tech Lab for their amazing project 

 that allowed the team to translate our components into French and German. This project is open source, free, and under the MIT license. 

Thanks to our customer Finary for showing us this cool project.

Changelog November 18, 2022

Clerk is launching our first Web3 authentication factor - Sign in with Metamask!

This launch is the result of dozens of developer interviews, focused on understanding if and how Clerk can contribute to the Web3 ecosystem.

It didn't take long before we discovered three common challenges that we can help Web3 developers with immediately: securing sessions, multifactor authentication, and profile enrichment.

First and foremost - we found a near ubiquitous challenge around securing sessions. It's a two-part problem: 

How do you verify a user is owns of a Web3 account?

How do you safely create a session to persist the users account information?

 determine the Web3 account address of a user visiting your website with Metamask connected, just run the following Javascript:

Verifying that the returned address is accurate, however, is significantly more challenging. Developers must ask users to sign a transaction, which is a process that undergone several protocol revisions and is hard to keep up with.

This is where Clerk steps in - all the work of signing a transaction and verifying the signature is abstracted away, and wrapped in a `<SignInWithMetamask/>` button.

Let's be honest - persisting a session isn't a Web3 challenge at all, but it is one that Web3 developers must endure by virtue of operating in Web2 browsers.

We know Web3 developers don't want to think about things like httpOnly cookies, XSS attacks, and session revocation. Web2 developers don't either, and that's why built-in 

 is the foundation of every authentication product at Clerk. We use stateless JWTs that enable authentication in under 1 millisecond, and revocation in under 1 minute. We follow all the best practices so you can focus on building your application.

Sign in with Metamask uses the same abstraction as our other authentication factors like passwords or magic links.

 works with Metamask users out-of-the-box.  Users simply need to navigate to their user profile and opt-in to multifactor authentication. There's no extra work for the developer beyond mounting a 

 component, or redirecting to the Clerk-hosted component.

Off-chain profile enrichment is a topic of much debate in the Web3 community. Ideally, data like email addresses and phone numbers could be retrieved on-chain following the principles of 

But as of today, there are no standard protocols for retrieving this data. As a result, top Web3 companies like OpenSea still collect and verify email addresses off-chain.

Clerk enables developers to easily do the same. We provide simple helpers for collecting and verifying phone numbers, email addresses, and even OAuth accounts. Beyond that, we accept structured data likes names and profile photos, as well as provide a generic metadata field for bespoke profile enrichment.

In the future, we look forward to enriching profiles in a more decentralized manner. Today, we hope this mechanism can help bridge the gap from Web2 to Web3.

Try out our guide for installing Web3 authentication.

  The guide will get you started with a new Next.js application with Metamask authentication.

This launch is the first of many upcoming Web3 launches. Our rough roadmap ahead includes:

 - we know that Metamask alone is a little limiting and will add generic Ethereum support soon

- In the Web2 realm, our team is actively building authorization via Roles and Permissions. We see many corollaries to Web3 authorization via token gating are approaching the primitives in a way that will support both.

 - Because we fully anticipate a multi-chain future

Need something we didn't mention? Please reach out through any of our 

 - we're still defining this roadmap and very interested to hear how we can better meet your needs.

Introducing Web3 Authentication

In this article, we are going to explore how we can use Next.js, Clerk, and Supabase to build a very basic todo app. Thanks to Clerk’s simple and powerful authentication options we're also going to add a complete User Profile, and even Multi-factor authentication (MFA).  

Why would you add MFA to a simple todo app? Because even todos deserve to be protected with the best security. And... Clerk makes it insanely easy to do so with 

Configuring Clerk for authentication by setting up Social SSO, password-based authentication, email magic links, and multi-factor authentication via SMS passcodes.

Configuring Supabase as a backend for a Postgres database, row-level security (RLS) and authorization policies

The source code for the final version can be found 

 is a lightweight react framework that’s optimized for developer experience, and gives you all the features you need to build powerful interactive applications.

 is a powerful authentication solution specifically built for the Modern Web. Clerk lets you choose how you want your users to sign in, and makes it really easy to get started with a suite of pre-built components including <SignIn />, SignUp />, <UserButton />, and <UserProfile />. Clerk also provides complete control with intuitive SDKs and APIs.

 is an open source Firebase alternative. It lets you easily create a backend with a Postgres database, storage, APIs and more. It also has an authentication module, however, for this tutorial we will only be using the database.

The quickest way to get started with Next.js is with the official create-next-app template.

In your terminal, create your app with the following command:

Let’s start with a simpler base by removing most of the Next.js template, and adding a basic nav bar, with a content area for our home page.

Since this is not a CSS tutorial, we'll use some very basic styling and add it all up front.  

As promised, our basic home page will include a simple nav bar and body.

It's going to be beautiful... Let's run our app, and see where we're starting!  

In your terminal, start your application with the following command:

It's easiest to start an app like this with our user object in place, and with a complete authentication foundation.  Then, we can build everything else on top.  Clerk gives us very simple and complete building blocks that makes this whole process very easy.

 to Clerk. Once you verify your email address, you'll be greeted with a way to create your first application:

I'm choosing the default settings, which will collect an email and password, or have users sign in with google.  You can choose whatever you'd like, and once your application is created, you can fine-tune them a lot more in the Clerk dashboard.

When you create a new application, a new development instance is automatically created for you, which is optimized for local development.

Instances in Clerk take a few minutes to be completely ready. Behind the scenes resources are being spun up, DNS records are being set, and certificates are being created.  These take time to fully propagate across the internet, so if you see any errors, give it a minute and refresh.

Now you're going to add sign up and sign in forms, and build a "protected" page, that only signed in users can see.

 to your project. Clerk brings a ton of authentication capabilities to 

, but for this tutorial we'll just set up the basics of sign-up and sign-in.  In your terminal, at the root directory of your project, install the 

this tutorial will be using the latest alpha release, so make sure you're on at least version >=3.0

Now you need an environment variables to link your local development with your Clerk instance.

You can find your API keys on the home page, in the "Connect your application" section.

In your project’s root directory, create a file named 

 . Next.js will automatically load all environment variables set here, into your application.  Because we're not using a custom backend at all, you only need your Frontend API key

Get the values from the dashboard, add the following to your 

 Keys prepended with NEXT_PUBLIC are exposed to your javascript, so do not put 

Any time you add or change your environment variables, you'll need to restart your application, so go to your terminal and kill the running application with 

 and relaunch it with the following command:

Great! although nothing changed, your application can now properly see these environment variables.

Now you can use Clerk's helper components to build a "gated" page.  In order to use these helpers, you should expose the Clerk context to your entire application, by wrapping the top level component with a 

 is the top level of your application. By wrapping the 

 here, every part of your application will have access to the Clerk context.

, add a sign in button and some basic gated content.  We'll use the following Clerk-provided hooks and components:

 - hook to easily access the current user, and it's state

 - displays a "UserButton" for the current user

The header now shows either sign in/up buttons or a 

, depending on your state.  The content section of this page follows similar logic.  Go ahead and sign up, if you sign up with Google, it will pull your profile image, and you will be able to see your 

Clerk provides a lot of hooks, components, and helpers -- you can explore all of them 

There's even more to explore with this application.  The 

You can do a lot from this page, including:

See what devices your logged into, (and log out of unrecognized devices) 

That's right, you don't need to write any more code to add MFA to your application.  Clerk handles it out of the box.  Just go to the 

 tab in your user profile, and follow the steps to add your phone number as a second factor!

This sample app is leveraging Clerk-hosted UIs, which is the simplest implementation path.  There are other ways you can add build this features, including 

 on a page you control, or by building it with a completely custom UI, using the 

Now that your user management foundation is in place it's time to connect to a database and create some todos!

This tutorial is using Supabase as a backend.  Supabase is a very powerful, open-source, postgres-based, database platform.  It will be great for easily storing your todos, and even work as your API.

The first thing you'll need is a Supabase account, which can be created 

. Once you have an account, create a new project.  

And choose the region closest to you, or your users.

Supabase takes a little while to spin up, but once it’s ready, go to the Table editor and press the "Create a new table" button

 and, add 2 new columns to the table named:

For each of the new columns, press the cog and deselect 

With Row Level Security enabled, postgres (and thus Supabase) will deny access to every row by default. So, you will need to setup up some "Policies" that will allow the 

 to access their own rows, and that will let them create new rows for themselves.

Before creating your "RLS Policies", Supabase will need a way to figure out which user is making the current request. You normally would be able to use Supabase's built-in 

currently an issue that we're working to resolve

! Upvote it so the issue can get more attention :) 

The workaround is easy enough though - you will create your own 

function named that accomplishes the same thing as 

NextJS + Supabase + Clerk: Build a simple todo app with multifactor authentication

In short: HttpOnly cookies do not prevent 

 attacks, but they do lessen the impact and prevent the need to sign out users after the XSS is patched. HttpOnly cookies are not a substitute for XSS prevention measures.

Our very first architecture decision at Clerk was to use HttpOnly cookies for session management. It has long been understood that HttpOnly cookies help mitigate cross-site scripting (XSS) attacks, and we felt it was important to include this best-practice directly in our product.

But while there's strong consensus that using HttpOnly cookies is a best practice, we've found many developers are unsure of how they help with XSS. We think this stems from the guidance, which often just says what to do rather than explaining why:

A cookie with the HttpOnly attribute is inaccessible to the JavaScript

 API; it is sent only to the server. For example, cookies that persist server-side sessions don't need to be available to JavaScript, and should have the HttpOnly attribute. This precaution helps mitigate cross-site scripting (

Cookies [...] SHOULD be tagged to be inaccessible via JavaScript (HttpOnly).


After reading this guidance, you might be surprised to learn that HttpOnly cookies do not prevent XSS attacks.

Instead, HttpOnly cookies are helpful when you assume an XSS attack will happen and want to 

. Ultimately, they mitigate XSS attacks by making it easier for organizations to respond.

The specific threat HttpOnly cookies protect against is called 

, which is a fancy way of saying that the attacker is able to steal a user's session token.

When a session token is stored in a cookie 

 the HttpOnly flag, the token can be stolen during an XSS attack with 

. This is problematic because session tokens are the primary mechanism used by backends to authenticate a user.

Once an attacker has access to a session token, they can often act on behalf of a user until that token expires or is revoked. 

Actions can be taken remotely - even if the user is no longer visiting the page with the XSS vulnerability - which can serve to dramatically increase the surface area of the attack.

Conversely, when a session token is stored in a cookie 

 the HttpOnly flag, that token cannot be directly exfiltrated during an XSS attack. This minimizes the surface area of the XSS attack and makes it easier for organizations to respond.

Responding to XSS attacks - without HttpOnly cookies

When an organization is responding to an XSS attack, the first step is always patching the XSS vulnerability.

If HttpOnly cookies were not used, organizations should then assume that session tokens were exfiltrated. This means that - even with the XSS vulnerability patched - the attacker may still have the ability to act on behalf of users.

The next step is revoking the session of any user who may have been subjected to the XSS vulnerability, since those are the users who may have had their session tokens exfiltrated. These users will need to sign in again next time they visit the website.

Lastly, the organization will need to reverse any actions the attacker took on behalf of their users, from the time the vulnerability began to the time session tokens were revoked.

Responding to XSS attacks - with HttpOnly cookies

With HttpOnly cookies, organizations still need to patch the XSS vulnerability and reverse any actions taken on behalf of their users, but they do not need to revoke sessions and ask users to sign in again.

What about localStorage and sessionStorage?

 are newer client-side storage APIs, they function like cookies 

 the HttpOnly flag. HttpOnly cookies are still the only standard mechanism for persisting session tokens that cannot be exfiltrated during an XSS attack.

Company

Company

Changelog July 8, 2022

Next.js 12.2

Emails w/ High Deliverability

Backend API updates

Suggested reading

Engineering

Introducing Web3 Authentication

Guide

NextJS + Supabase + Clerk: Build a simple todo app with multifactor authentication

Start Now,
No Strings Attached

Pricing built for

businesses of all sizes.

Newsletter!

Company

Company

Changelog July 8, 2022

Emails w/ High Deliverability

Sign in with Line

Backend API updates

Suggested reading

Engineering

Introducing Web3 Authentication

Guide

NextJS + Supabase + Clerk: Build a simple todo app with multifactor authentication

Start Now,No Strings Attached

Pricing built for

businesses of all sizes.

Newsletter!

Start Now,
No Strings Attached