Building a Custom User Profile with Clerk

This week, the team has been improving the DX of Clerk and introducing some important features. 

Clerk now has full support for Expo 48 with this change we introduced a brand new hook called 

 this hook dramatically improves the developer experience. Here are two examples of the code to handle Discord OAuth, both handle account transfers.

At this point we believe that our authentication offering is better than Expo's direct offer! If you are ready to get started with Expo and Clerk, check out our 

Many of our users offer email,username and phone as a way for their users to authenticate. In the past we would have a single input for all of the options and the user would have to type in their phone number including the country code which made it difficult 

We now offer a way to switch the input allow the user to see a familiar phone input.


We can now support keys at runtime for users who may have multiple projects under a single monorepo or want fine grain usage of keys.

The <CreateOrganization/>  component now exposes the slug field for you to input the slug you want when an organization is created. It is still optional and by default will use the name of the organization.

We now have support for localization in Dutch thanks to a Clerk user who translated our components. 

Changelog April 7, 2023

This week we rolled out major changes to how Clerk's Javascript bundle is split and downloaded.  Chances are you didn't notice anything, but your production application should be seeing ~10 points higher performance on 

Use Clerk and React to building a Chrome extension.  We've launched  

 on GitHub to help kick off your next extension project.

With Clerk, your application can now serve as an Open ID Connect (OIDC) provider. Please reach out through 

OIDC is a subset of OAuth2. In the future, Clerk will also enable your application to serve as a OAuth2 provider, including supporting grant flows with custom scopes.

Cross-Origin Embedder Policy Support for Profile Images

Clerk profile images are now served with the 

 header to enable embeds in applications with cross-origin embedder policies.

Changelog March 31, 2023

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 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.

Guide

Guide

Building a Custom User Profile with Clerk

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!

Guide

Guide

Building a Custom User Profile with Clerk

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