​
Create a Nuxt application

First, create a new Nuxt.js application using the official Nuxt starter template. This command sets up a complete Nuxt project with TypeScript support and all necessary dependencies. Run the following command to create a new Nuxt application: 
npm create nuxt project-name

​
Install @nuxtjs/hanko

Use the @nuxtjs/hanko module to integrate Hanko authentication. It provides pre-built components (hanko-auth, hanko-events, hanko-profile), server middleware for route protection, and Vue composables for easy authentication management. Install the module as a development dependency: 
cd project-name
npm install -D @nuxtjs/hanko

​
Setup your Hanko project

Before integrating Hanko into your application, you need to create a Hanko project in the cloud console. This project will provide you with an API URL and manage your authentication settings. Go to the Hanko console and create a project for this application.
During project creation, make sure to set the APP URL to your development URL (typically http://localhost:3000/). This ensures proper CORS configuration and redirect handling.

​
Add the Hanko API URL

After creating your Hanko project, you’ll receive a unique API URL. This URL is used to communicate with Hanko’s authentication services. The NUXT_PUBLIC_ prefix makes this environment variable accessible in both server and client-side code. Retrieve the API URL from the Hanko console and add it to your environment file:
.env
NUXT_PUBLIC_HANKO_API_URL=https://f4****-4802-49ad-8e0b-3d3****ab32.hanko.io
If you are self-hosting you need to provide the URL of your running Hanko backend.

​
Configure Nuxt module

Next, register the Hanko module in your Nuxt configuration and set up authentication behavior. This configuration defines where users should be redirected after login/logout and sets up the module with your API URL. Add the @nuxtjs/hanko module to your nuxt.config.ts file:
nuxt.config.ts
export default defineNuxtConfig({
  modules: ["@nuxtjs/hanko"],
  hanko: {
    apiURL: process.env.NUXT_PUBLIC_HANKO_API_URL,
    cookieName: 'hanko',
    redirects:{
      login: '/',//Path to redirect to when unauthenticated / logged out
      success: '/dashboard',//Path to redirect to once logged in
    }
  },
})
While the module comes pre-configured with the options for most common use cases, you have the flexibility to override them by adding a hanko section to your nuxt.config.ts file. For all overrides please refer to module’s repository.
Using Hanko ComponentsYou can now use the components anywhere in your app (<hanko-auth>, <hanko-events>, <hanko-profile>). These will render only on client-side and all the props you can pass are strongly typed.If you prefer not to auto-register these components, especially if you plan to use Hanko exclusively on the server side or wish to handle component registration programmatically, you can disable this feature. To do so, set the registerComponents option to false in your nuxt.config.ts file:
nuxt.config.ts
hanko: {
  registerComponents: false;
}

​
Setup Nuxt pages

Nuxt uses file-based routing, where each file in the pages/ directory becomes a route. To enable this routing system, add the NuxtPage component to your main application template. Update your app.vue file to use the Nuxt Page Router:
app.vue
<template>
  <div>
    <NuxtPage />
  </div>
</template>
After that lets create a folder called /pages and in there we will create index.vue and dashboard.vue.

​
Add <hanko-auth> component

The <hanko-auth> web component provides a complete login and registration interface with passwordless authentication. The hanko-logged-out middleware ensures that already authenticated users are automatically redirected to the dashboard. Create your login page at pages/index.vue:
pages/index.vue
<script setup lang="ts">
definePageMeta({
  middleware: ['hanko-logged-out']
})
</script>
<template>
  <hanko-auth />
</template>

​
Alternative: Custom redirect handling

If you need more control over post-login behavior, you can use the <hanko-events> component to listen for authentication events and implement custom logic. Here’s an alternative approach with custom redirect handling:
pages/index.vue
<script setup lang="ts">
function afterLogin() {
 navigateTo("/user");
}
</script>
<template>
  <hanko-auth />
  <hanko-events @onSessionCreated="afterLogin()" />
</template>

​
Define event callbacks

Hanko emits various authentication events that you can listen to for custom application logic. These events include session creation, updates, and destruction. Add the <hanko-events> component to subscribe to authentication events:
pages/index.vue
<script setup lang="ts">
function updateSession() {
 // do something
}
</script>
<template>
  <hanko-events @onSessionCreated="updateSession()" />
</template>
By now, your sign-up and sign-in features should be working. You should see an interface similar to this 👇
sign up

​
Add <hanko-profile>

The <hanko-profile> component provides a user-friendly interface for managing authentication credentials. Users can add/remove email addresses, register new passkeys, and manage their authentication methods. Create a dashboard page at pages/dashboard.vue:
pages/dashboard.vue
<template>
  <hanko-profile />
</template>
It should look like this 👇
profile page

​
Implement logout functionality

To log users out, use the @nuxtjs/hanko module’s built-in composable useHanko and call the logout method.
pages/dashboard.vue
<script setup lang="ts">
const hanko = useHanko()
  function logout() {
    hanko?.logout();
  }
  definePageMeta({
    middleware: ["hanko-logged-in"],
  });
</script>
<template>
  <hanko-profile />
  <button @click="logout">
      Log me out
  </button>
</template>
useHanko() composableThe useHanko composable provides access to the Hanko SDK which in turn allows access to the Hanko API, e.g. for accessing the current user info. The composable is auto-imported across the app and can simply be used with useHanko() anywhere in your code.

​
Customize component styles

You can customize the appearance of hanko-auth and hanko-profile components using CSS variables and parts. Refer to our customization guide. The styles can be scoped to the login/profile page to ensure they dont affect other parts to the app.

​
Securing routes with Middleware

Use the hanko-logged-in middleware to secure any route and force unauthenticated users to redirect back to the login redirect we set in the nuxt.config.ts. 
<script setup lang="ts">
  definePageMeta({
    middleware: ["hanko-logged-in"],
  });
</script>
A global server middleware is added by @nuxtjs/hanko. After decoding and validating the session token for the request, a new hanko property is added to the event context. You can check the value of event.context.hanko to see if the request was authenticated. The user’s id is accessible though the sub claim/property.
/server/api/endpoint.ts
export default defineEventHandler(async (event) => {
  const hanko = event.context.hanko;
  if (!hanko || !hanko.sub) {
    return {
      status: 401,
      body: {
        message: "Unauthorized",
      },
    };
  }
  // Do something with the Hanko user
  return {
    hanko: event.context.hanko,
  };
});

​
Try it yourself

Nuxt example

Full source code available on our GitHub