Better Auth vs NextAuth (Authjs) vs Auth0

Authentication is one of those problems that every developer has to solve, yet it remains surprisingly complex to implement correctly. Better Auth, NextAuth (now Auth.js), and Auth0 represent three distinct approaches to this challenge, each with its own philosophy and strengths.

Better Auth is the newest player, designed from the ground up for TypeScript with a focus on developer experience and comprehensive features out of the box. It promises to solve the common pain points developers face with existing solutions.

NextAuth.js (now Auth.js) has been the go-to open-source authentication library for Next.js applications for years. It's framework-agnostic in its latest version and offers extensive provider support with a mature ecosystem.

Auth0 is the enterprise-grade managed service that takes care of authentication infrastructure for you. It provides a comprehensive identity platform with advanced features and enterprise support but comes with associated costs and vendor lock-in considerations.

This article will break down their differences, strengths, and ideal use cases to help you decide which authentication solution best suits your project.

What is Better Auth?

Better Auth is a comprehensive authentication framework for TypeScript that emerged in 2024 to address the limitations of existing solutions. Built by developers who were frustrated with the complexity and missing features in other libraries, Better Auth aims to provide everything you need for authentication without requiring extensive additional code.

It was created with the philosophy that authentication should be framework-agnostic while providing deep TypeScript integration. Unlike other solutions that started with specific frameworks and expanded outward, Better Auth was designed from day one to work seamlessly across different JavaScript frameworks while maintaining excellent type safety.

The library provides features like two-factor authentication, organization management, and advanced session handling out of the box. Its plugin ecosystem allows you to extend functionality without reinventing common authentication patterns, making it particularly appealing for developers who want comprehensive features without the complexity.

What is NextAuth (Auth.js)?

NextAuth.js, now rebranded as Auth.js, has been the dominant open-source authentication solution for Next.js since its creation. Originally focused specifically on Next.js applications, it has evolved into a framework-agnostic library that supports multiple JavaScript frameworks including SvelteKit, SolidStart, and Express.

The library was built by the community to solve the common authentication challenges developers face when building web applications. It emphasizes ease of setup, extensive provider support, and security best practices. Auth.js provides built-in support for dozens of OAuth providers, database adapters, and session management strategies.

With its recent version 5 release, Auth.js has undergone significant modernization while maintaining backward compatibility where possible. An active community continually maintains the library and features extensive documentation covering various use cases and deployment scenarios.

What is Auth0?

Auth0 is a cloud-based Identity-as-a-Service (IDaaS) platform that provides authentication and authorization services for applications. Founded in 2013, it has grown into one of the leading enterprise identity platforms, serving thousands of companies worldwide with comprehensive identity management solutions.

Unlike open-source libraries, Auth0 handles all the infrastructure, security updates, and compliance requirements for you. It provides a managed service that includes features like Universal Login, multi-factor authentication, user management dashboards, and extensive integration options with third-party systems.

Auth0's platform supports both B2C and B2B use cases with features like single sign-on, social connections, enterprise directory integration, and fine-grained authorization. The service is designed to scale from small applications to enterprise-level deployments with millions of users.

Better Auth vs NextAuth vs Auth0: A Quick Comparison

Choosing between these authentication solutions impacts both your development experience and long-term maintenance overhead. Each solution represents a different philosophy and approach to solving authentication challenges.

The following comparison highlights key differences to consider:

Installation and setup

The initial setup experience varies significantly between these three solutions, reflecting their different approaches to authentication.

Better Auth prioritizes simplicity with automatic schema generation and minimal configuration. Getting started requires installing the package, setting up environment variables, and creating a basic configuration file.

// Install: npm install better-auth
// Environment variables in .env:
// BETTER_AUTH_SECRET=your-secret-key
// BETTER_AUTH_URL=http://localhost:3000

// auth.ts
import { betterAuth } from "better-auth"

export const auth = betterAuth({
  database: {
    dialect: "sqlite",
    url: "./database.db"
  },
  emailAndPassword: {
    enabled: true
  },
  socialProviders: {
    github: {
      clientId: process.env.GITHUB_CLIENT_ID!,
      clientSecret: process.env.GITHUB_CLIENT_SECRET!
    }
  }
})

// Next.js API route: app/api/auth/[...all]/route.ts
export const { GET, POST } = auth.handler

// Generate database schema
// npx @better-auth/cli generate
// npx @better-auth/cli migrate

The database schema is automatically generated based on your configuration, and TypeScript types are inferred throughout your application. This approach eliminates much of the boilerplate code typically required for authentication setup.

NextAuth requires more configuration but offers extensive flexibility. The setup involves creating authentication configuration, handling API routes, and setting up session providers.

// Install: npm install next-auth@beta

// auth.config.ts
import GitHub from "next-auth/providers/github"
import type { NextAuthConfig } from "next-auth"

export default {
  providers: [
    GitHub({
      clientId: process.env.AUTH_GITHUB_ID,
      clientSecret: process.env.AUTH_GITHUB_SECRET
    })
  ]
} satisfies NextAuthConfig

// auth.ts
import NextAuth from "next-auth"
import { PrismaAdapter } from "@auth/prisma-adapter"
import { prisma } from "./lib/prisma"
import authConfig from "./auth.config"

export const { auth, handlers, signIn, signOut } = NextAuth({
  adapter: PrismaAdapter(prisma),
  session: { strategy: "jwt" },
  ...authConfig
})

// app/api/auth/[...nextauth]/route.ts
import { handlers } from "@/auth"
export const { GET, POST } = handlers

// Environment: AUTH_SECRET is mandatory
// Generate with: npx auth secret

NextAuth provides extensive configuration options but requires understanding concepts like adapters, providers, and session strategies. The setup is more involved but offers granular control over authentication behavior.

Auth0 offers the simplest initial setup since their managed service handles most complexity. You configure your application in the Auth0 dashboard and integrate using their SDKs.

// lib/auth0.ts
import { initAuth0 } from '@auth0/nextjs-auth0'

export default initAuth0({
  secret: process.env.AUTH0_SECRET,
  baseURL: process.env.AUTH0_BASE_URL,
  issuerBaseURL: process.env.AUTH0_ISSUER_BASE_URL,
  clientID: process.env.AUTH0_CLIENT_ID,
  clientSecret: process.env.AUTH0_CLIENT_SECRET
})

// pages/_app.tsx
import { UserProvider } from '@auth0/nextjs-auth0/client'

export default function App({ Component, pageProps }) {
  return (
    <UserProvider>
      <Component {...pageProps} />
    </UserProvider>
  )
}

// API routes are automatically handled by Auth0

The Auth0 approach requires minimal code but moves configuration to their web dashboard. This trade-off simplifies your codebase but creates a dependency on their platform for authentication management.

Authentication features

The feature sets of these solutions reflect their different target audiences and design philosophies.

Better Auth provides comprehensive authentication features out of the box without requiring additional plugins or configurations. It includes email/password authentication, social logins, two-factor authentication, and organization management as core features.

// Client-side authentication with Better Auth
import { authClient } from "./lib/auth-client"

// Sign up with email and password
const { data, error } = await authClient.signUp.email({
  email: "user@example.com",
  password: "securePassword123",
  name: "John Doe"
})

// Social sign-in
const { data, error } = await authClient.signIn.social({
  provider: "github"
})

// Enable 2FA
const { data, error } = await authClient.twoFactor.enable({
  password: "currentPassword"
})

// Organization management
const { data, error } = await authClient.organization.create({
  name: "Acme Corp",
  slug: "acme-corp"
})

The API is designed to be intuitive and type-safe, with comprehensive error handling and clear return types. Features like 2FA and organization management work seamlessly without additional configuration.

NextAuth provides extensive provider support and flexible authentication flows. Its strength lies in the breadth of OAuth providers and customization options through callbacks and custom pages.

// NextAuth authentication flows
import { signIn, signOut, useSession } from "next-auth/react"

// Social sign-in with various providers
await signIn("github")
await signIn("google")
await signIn("apple")

// Credentials authentication
await signIn("credentials", {
  username: "user@example.com",
  password: "password123",
  redirect: false
})

// Custom session handling
export const authOptions = {
  callbacks: {
    async session({ session, token }) {
      // Add custom properties to session
      session.user.id = token.sub
      return session
    },
    async jwt({ token, user }) {
      // Persist additional data in JWT
      if (user) {
        token.role = user.role
      }
      return token
    }
  }
}

NextAuth excels at handling complex authentication flows and integrating with various databases and external services. However, features like 2FA typically require additional packages or custom implementation.

Auth0 provides enterprise-grade features through its managed platform. The service includes advanced security features, compliance tools, and comprehensive user management capabilities.

// Auth0 authentication with enterprise features
import { useUser } from '@auth0/nextjs-auth0/client'

// Basic authentication
const LoginButton = () => (
  <a href="/api/auth/login">Log in</a>
)

// Access user information
const { user, error, isLoading } = useUser()

// Advanced features configured in Auth0 dashboard:
// - Multi-factor authentication
// - Social connections
// - Enterprise SSO (SAML, OIDC)
// - User management
// - Progressive profiling
// - Risk-based authentication

Auth0's strength lies in its comprehensive feature set and enterprise capabilities. However, most advanced features are configured through their dashboard rather than code, which can limit customization for specific use cases.

Session management and security

Session management approaches differ significantly between these solutions, impacting both security and user experience.

Better Auth provides flexible session management with sensible security defaults. It supports both JWT and database sessions with automatic token rotation and secure cookie handling.

// Better Auth session management
import { auth } from "./auth"

// Get current session
const session = await auth.api.getSession({
  headers: request.headers
})

// Session configuration
export const auth = betterAuth({
  session: {
    expiresIn: 60 * 60 * 24 * 7, // 7 days
    updateAge: 60 * 60 * 24, // 1 day
    cookieCache: {
      enabled: true,
      maxAge: 60 * 5 // 5 minutes
    }
  },
  trustedOrigins: ["http://localhost:3000"],
  plugins: [
    // Additional security plugins
    rateLimiter(),
    sessionTimeout()
  ]
})

// Server-side session validation
export async function middleware(request: NextRequest) {
  const session = await auth.api.getSession({
    headers: request.headers
  })

  if (!session) {
    return NextResponse.redirect(new URL('/login', request.url))
  }

  return NextResponse.next()
}

The session system automatically handles token refresh, secure cookie settings, and CSRF protection. The configuration is straightforward while providing enterprise-level security features.

NextAuth offers multiple session strategies with extensive customization options. You can choose between JWT tokens and database sessions based on your specific requirements.

// NextAuth session configuration
export const authOptions = {
  session: {
    strategy: "jwt", // or "database"
    maxAge: 30 * 24 * 60 * 60, // 30 days
    updateAge: 24 * 60 * 60, // 24 hours
  },
  jwt: {
    maxAge: 60 * 60 * 24 * 30, // 30 days
    encode: async ({ secret, token, maxAge }) => {
      // Custom JWT encoding
    },
    decode: async ({ secret, token, maxAge }) => {
      // Custom JWT decoding
    }
  },
  cookies: {
    sessionToken: {
      name: "next-auth.session-token",
      options: {
        httpOnly: true,
        sameSite: "lax",
        path: "/",
        secure: process.env.NODE_ENV === "production"
      }
    }
  }
}

// Server-side session access
import { auth } from "@/auth"

export default async function Page() {
  const session = await auth()

  if (!session?.user) {
    redirect('/login')
  }

  return <div>Hello {session.user.name}</div>
}

NextAuth provides granular control over session behavior but requires understanding multiple concepts and configuration options to implement properly.

Auth0 handles all session management through their managed infrastructure with enterprise-grade security features built-in.

// Auth0 session management
import { getSession, withApiAuthRequired } from '@auth0/nextjs-auth0'

// Automatic session handling in pages
export const getServerSideProps = withPageAuthRequired({
  async getServerSideProps(ctx) {
    const session = await getSession(ctx.req, ctx.res)

    return {
      props: {
        user: session?.user || null
      }
    }
  }
})

// API route protection
export default withApiAuthRequired(async function handler(req, res) {
  const session = await getSession(req, res)

  // Session is guaranteed to exist
  res.json({ message: `Hello ${session.user.name}` })
})

// Configuration handled in Auth0 dashboard:
// - Session lifetime
// - Token expiration
// - Refresh token rotation
// - Session management policies

Auth0 abstracts away session complexity but provides limited customization options. The managed approach ensures security best practices but may not fit all architectural requirements.

Database integration and user management

How these solutions handle user data and database integration reveals important architectural differences.

Better Auth provides native integration with popular TypeScript ORMs and automatically generates database schemas based on your configuration. Better Auth uses Kysely as its default database handler but also supports popular adapters like Prisma and Drizzle.

// Better Auth with Kysely (default)
import { betterAuth } from "better-auth"
import { Database } from "better-sqlite3"

export const auth = betterAuth({
  database: new Database("sqlite.db"),
  // Or with PostgreSQL/MySQL
  // database: {
  //   dialect: "postgresql",
  //   url: process.env.DATABASE_URL
  // }
})

// With Prisma adapter
import { prismaAdapter } from "better-auth/adapters/prisma"
import { PrismaClient } from "@prisma/client"

const prisma = new PrismaClient()

export const auth = betterAuth({
  database: prismaAdapter(prisma, {
    provider: "postgresql"
  }),
  plugins: [
    organization({
      allowUserToCreateOrganization: true
    })
  ]
})

// Schema is auto-generated with CLI
// npx @better-auth/cli generate
// npx @better-auth/cli migrate

The database integration provides type-safe queries and automatic migrations while allowing custom fields and relationships. You maintain full ownership of your user data with the convenience of managed schemas.

NextAuth requires manual adapter configuration but supports a wide range of databases through community-maintained adapters. The approach provides flexibility at the cost of additional setup complexity.

// NextAuth with Prisma adapter
import { PrismaAdapter } from "@auth/prisma-adapter"
import { PrismaClient } from "@prisma/client"

const prisma = new PrismaClient()

export const authOptions = {
  adapter: PrismaAdapter(prisma),
  // Database schema must be manually created
  // See NextAuth.js documentation for required tables
}

// Custom user data handling
export const authOptions = {
  callbacks: {
    async signIn({ user, account, profile }) {
      // Custom logic when user signs in
      await prisma.user.update({
        where: { id: user.id },
        data: { lastLogin: new Date() }
      })
      return true
    }
  }
}

// Manual user management
const users = await prisma.user.findMany({
  where: {
    email: {
      contains: "@company.com"
    }
  },
  include: {
    accounts: true,
    sessions: true
  }
})

NextAuth gives you complete control over database design but requires manual schema setup and maintenance. The adapter system provides good flexibility for different database choices.

Auth0 manages all user data in their cloud infrastructure with comprehensive user management tools available through their dashboard and APIs.

// Auth0 user management via Management API
import { ManagementClient } from 'auth0'

const management = new ManagementClient({
  domain: process.env.AUTH0_DOMAIN,
  clientId: process.env.AUTH0_CLIENT_ID,
  clientSecret: process.env.AUTH0_CLIENT_SECRET,
})

// Programmatic user management
const users = await management.getUsers({
  q: 'email:"*@company.com"',
  search_engine: 'v3'
})

// Update user metadata
await management.updateUser(
  { id: userId },
  {
    user_metadata: {
      preferences: { theme: 'dark' },
      role: 'admin'
    }
  }
)

// User data is stored in Auth0's cloud
// - User profiles
// - Authentication history
// - Application metadata
// - Custom user attributes

Auth0 provides powerful user management capabilities but stores all data in their infrastructure. This approach simplifies database management but creates vendor dependency for your user data.

Customization and extensibility

The extensibility options available in each solution determine how well they can adapt to unique business requirements.

Better Auth was designed with extensibility as a core principle, providing a plugin system that allows adding complex features without modifying core authentication logic.

// Better Auth plugin system
import { betterAuth } from "better-auth"
import { organization, twoFactor, magicLink } from "better-auth/plugins"

export const auth = betterAuth({
  plugins: [
    organization({
      allowUserToCreateOrganization: true,
      organizationLimit: 5
    }),
    twoFactor({
      issuer: "Your App Name",
      totpOptions: {
        period: 30,
        digits: 6
      }
    }),
    magicLink({
      sendMagicLink: async ({ email, token, url }) => {
        // Custom email sending logic
        await sendEmail({
          to: email,
          subject: "Sign in to Your App",
          html: `<a href="${url}">Click here to sign in</a>`
        })
      }
    })
  ],
  // Custom hooks for extending functionality
  hooks: {
    after: [
      {
        matcher: (context) => context.path === "/sign-up",
        handler: async (context) => {
          // Custom logic after user signs up
          await sendWelcomeEmail(context.user.email)
        }
      }
    ]
  }
})

// Creating custom plugins
export const customPlugin = () => ({
  id: "custom-plugin",
  endpoints: {
    "/custom-endpoint": {
      POST: async (context) => {
        // Custom endpoint logic
        return { success: true }
      }
    }
  },
  hooks: {
    // Plugin-specific hooks
  }
})

The plugin architecture allows adding complex features like organization management, audit logging, or custom authentication flows without touching core authentication code.

NextAuth provides extensive customization through callbacks, custom pages, and provider configurations. The approach offers flexibility but requires deeper understanding of authentication flows.

// NextAuth customization options
export const authOptions = {
  pages: {
    signIn: '/custom-signin',
    signUp: '/custom-signup',
    error: '/auth-error',
    verifyRequest: '/verify-email'
  },
  callbacks: {
    async signIn({ user, account, profile, email, credentials }) {
      // Custom sign-in logic
      if (account?.provider === "email") {
        return await verifyEmailDomain(user.email)
      }
      return true
    },
    async redirect({ url, baseUrl }) {
      // Custom redirect logic
      if (url.startsWith("/")) return `${baseUrl}${url}`
      else if (new URL(url).origin === baseUrl) return url
      return baseUrl
    },
    async session({ session, token }) {
      // Add custom data to session
      session.user.id = token.sub
      session.user.role = token.role
      return session
    },
    async jwt({ token, user, account, profile }) {
      // Customize JWT token
      if (user) {
        token.role = user.role
      }
      return token
    }
  },
  events: {
    async signIn(message) {
      // Custom event handling
      console.log('User signed in:', message.user.email)
    },
    async signOut(message) {
      // Custom cleanup logic
      await cleanupUserSessions(message.token.sub)
    }
  }
}

// Custom provider
const CustomProvider = {
  id: "custom",
  name: "Custom Auth",
  type: "oauth",
  authorization: "https://custom-auth.com/oauth/authorize",
  token: "https://custom-auth.com/oauth/token",
  userinfo: "https://custom-auth.com/oauth/userinfo",
  profile(profile) {
    return {
      id: profile.sub,
      name: profile.name,
      email: profile.email,
      image: profile.picture
    }
  }
}

NextAuth's callback system provides powerful customization capabilities but can become complex for advanced use cases. The flexibility comes with increased configuration overhead.

Auth0 provides customization primarily through their dashboard configuration and extensibility features like Rules, Hooks, and Actions.

// Auth0 customization through Actions
// (Configured in Auth0 dashboard)

// Login Action example
exports.onExecutePostLogin = async (event, api) => {
  // Custom logic during login flow
  if (event.user.email_verified === false) {
    api.access.deny('Please verify your email')
  }

  // Add custom claims to tokens
  api.idToken.setCustomClaim('https://myapp.com/roles', event.user.app_metadata.roles)
  api.accessToken.setCustomClaim('https://myapp.com/department', event.user.user_metadata.department)
}

// Pre User Registration Action
exports.onExecutePreUserRegistration = async (event, api) => {
  // Validate user data before registration
  const allowedDomains = ['company.com', 'partner.com']
  const emailDomain = event.user.email.split('@')[1]

  if (!allowedDomains.includes(emailDomain)) {
    api.access.deny('Registration not allowed for this domain')
  }
}

// Custom database connections
// (Configured through Auth0 dashboard)
const customDbConnection = {
  login: (email, password, callback) => {
    // Custom authentication logic
    validateUser(email, password)
      .then(user => callback(null, user))
      .catch(err => callback(err))
  },
  create: (user, callback) => {
    // Custom user creation logic
  },
  verify: (email, callback) => {
    // Custom email verification
  }
}

Auth0's customization model is powerful but requires working within their ecosystem. Advanced customizations may require upgrading to higher-tier plans with access to additional features.

Pricing and total cost of ownership

Understanding the true cost of each solution requires considering not just licensing fees but also development time, maintenance overhead, and infrastructure costs.

Better Auth is completely free and open-source with no usage limits or premium features locked behind paywalls. The total cost includes your development time, hosting infrastructure, and ongoing maintenance.

The cost structure includes your server hosting costs, database hosting, and engineering time for implementation and maintenance. Since Better Auth handles most authentication complexity automatically, the ongoing maintenance overhead is minimal. You'll need to handle security updates and monitor authentication-related issues yourself.

For a typical application, the monthly costs might include database hosting at around $10-30 per month, server resources for authentication handling, and occasional developer time for updates and maintenance. The absence of per-user pricing makes it predictable for scaling applications.

NextAuth follows a similar open-source model with no licensing costs but requires more development and maintenance effort compared to Better Auth.

The total cost includes your hosting infrastructure, potentially higher development time due to configuration complexity, and ongoing maintenance of authentication flows. NextAuth requires more manual setup and understanding of authentication concepts, which can increase initial development time.

Monthly costs typically include database hosting, server resources, and more frequent developer intervention for troubleshooting and customization. The extensive configuration options can lead to higher maintenance overhead but provide greater flexibility for complex requirements.

Auth0 uses a usage-based pricing model that starts free but can become expensive as your user base grows. The pricing structure differs between B2C and B2B use cases.

The free tier includes up to 25,000 monthly active users for B2C applications and 500 for B2B applications. Essential plans start at $35/month for B2C and $150/month for B2B with 500 monthly active users. Professional plans begin at $240/month for B2C and $800/month for B2B with 1,000 monthly active users.

Enterprise pricing can reach $30,000+ annually and includes advanced features like SAML integration, advanced analytics, and dedicated support. While Auth0 eliminates infrastructure management costs, the usage-based pricing can become significant for applications with large user bases.

The managed service approach reduces development time and eliminates infrastructure maintenance, but creates ongoing operational expenses that scale with your success. For applications expecting rapid user growth, the pricing trajectory should be carefully evaluated.

Migration and integration paths

Understanding migration complexity helps evaluate long-term flexibility and vendor lock-in risks.

Better Auth provides tools for migrating from other authentication solutions with database schema migration utilities and import/export functionality.

// Migration from NextAuth to Better Auth
import { migrateFromNextAuth } from "better-auth/migrations"

await migrateFromNextAuth({
  database: db,
  nextAuthTables: {
    users: "users",
    accounts: "accounts", 
    sessions: "sessions"
  }
})

// Migration utilities for user data
const migratedUsers = await auth.api.importUsers({
  users: existingUsers.map(user => ({
    email: user.email,
    name: user.name,
    emailVerified: user.emailVerified,
    // Map other fields as needed
  }))
})

The migration process preserves user data and authentication state while upgrading to Better Auth's enhanced feature set. The schema generation tools help map existing user data to Better Auth's format.

NextAuth provides migration guides for upgrading between versions but limited tools for migrating from other solutions.

// Migrating from NextAuth v4 to v5
// Requires updating configuration format and API calls

// v4 configuration
export default NextAuth({
  providers: [GitHubProvider({...})],
  callbacks: {...}
})

// v5 configuration
export const { handlers, auth } = NextAuth({
  providers: [GitHub],
  callbacks: {...}
})

// API usage changes
// v4: getServerSession(req, res, authOptions)
// v5: auth()

Migration between authentication solutions typically requires custom scripting to preserve user data and sessions. The extensive configuration options can make migrations complex but provide flexibility during the transition.

Auth0 provides import/export tools and migration services for moving user data to and from their platform.

// Auth0 bulk user import
import { ManagementClient } from 'auth0'

const management = new ManagementClient({...})

// Export users for migration
const users = await management.getUsers({
  per_page: 100,
  include_totals: true
})

// Import users from external source  
await management.importUsers({
  connection_id: 'con_...',
  users: usersToImport.map(user => ({
    email: user.email,
    password: user.hashedPassword, // or trigger password reset
    user_metadata: user.profile
  }))
})

Moving away from Auth0 requires exporting user data and rebuilding authentication infrastructure. The managed service approach can create migration complexity when changing solutions, but Auth0 provides professional services to assist with transitions.

Final Thoughts

This article compares Better Auth, NextAuth, and Auth0 to help you choose the right tool for your app.

Better Auth is the top choice for modern TypeScript apps. It’s powerful, type-safe, easy to set up, and offers a great developer experience.

NextAuth is flexible and supports many providers but requires more configuration.

Auth0 is suited for enterprises that need full features and support, but it’s more expensive.

If you want a strong, simple, and modern solution, Better Auth is the best fit for most projects.

Got an article suggestion? Let us know

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.