GoTrueClient

Exchange Auth Code

supabase.auth.exchangeCodeForSession('34e770dd-9ff9-416c-87fa-43b31d7ef225')

An optional specific JWT you wish to verify, not the one you can obtain from {@link #getSession}.

Various additional options that allow you to customize the behavior of this method.

Get JWT claims, header and signature

const { data, error } = await supabase.auth.getClaims()

Get the session data

const { data, error } = await supabase.auth.getSession()

Takes in an optional access token JWT. If no JWT is provided, the JWT from the current session is used.

Get the logged in user with the current existing session

const { data: { user } } = await supabase.auth.getUser()

Get the logged in user with a custom access token jwt

const { data: { user } } = await supabase.auth.getUser(jwt)

Returns a list of identities linked to the user

const { data, error } = await supabase.auth.getUserIdentities()

A callback function to be invoked when an auth event happens.

A callback function to be invoked when an auth event happens.

Due to the possibility of deadlocks with async functions as callbacks, use the version without an async function.

Send reauthentication nonce

const { error } = await supabase.auth.reauthenticate()

The current session. If passed in, it must contain a refresh token.

Refresh session using the current session

const { data, error } = await supabase.auth.refreshSession()
const { session, user } = data

Refresh session using a refresh token

const { data, error } = await supabase.auth.refreshSession({ refresh_token })
const { session, user } = data

Resend an email signup confirmation

const { error } = await supabase.auth.resend({
  type: 'signup',
  email: 'email@example.com',
  options: {
    emailRedirectTo: 'https://example.com/welcome'
  }
})

Resend a phone signup confirmation

const { error } = await supabase.auth.resend({
  type: 'sms',
  phone: '1234567890'
})

Resend email change email

const { error } = await supabase.auth.resend({
  type: 'email_change',
  email: 'email@example.com'
})

Resend phone change OTP

const { error } = await supabase.auth.resend({
  type: 'phone_change',
  phone: '1234567890'
})

The email address of the user.

The URL to send the user to after they click the password reset link.

Verification token received when the user completes the captcha on the site.

Reset password

const { data, error } = await supabase.auth.resetPasswordForEmail(email, {
  redirectTo: 'https://example.com/update-password',
})

Reset password (React)

/**
 * Step 1: Send the user an email to get a password reset token.
 * This email contains a link which sends the user back to your application.
 *\/
const { data, error } = await supabase.auth
  .resetPasswordForEmail('user@email.com')

/**
 * Step 2: Once the user is redirected back to your application,
 * ask the user to reset their password.
 *\/
 useEffect(() => {
   supabase.auth.onAuthStateChange(async (event, session) => {
     if (event == "PASSWORD_RECOVERY") {
       const newPassword = prompt("What would you like your new password to be?");
       const { data, error } = await supabase.auth
         .updateUser({ password: newPassword })

       if (data) alert("Password updated successfully!")
       if (error) alert("There was an error updating your password.")
     }
   })
 }, [])

The current session that minimally contains an access token and refresh token.

Set the session

  const { data, error } = await supabase.auth.setSession({
    access_token,
    refresh_token
  })

A session where the is_anonymous claim in the access token JWT set to true

Create an anonymous user

const { data, error } = await supabase.auth.signInAnonymously({
  options: {
    captchaToken
  }
});

Create an anonymous user with custom user metadata

const { data, error } = await supabase.auth.signInAnonymously({
  options: {
    data
  }
})

Sign In using ID Token

const { data, error } = await supabase.auth.signInWithIdToken({
  provider: 'google',
  token: 'your-id-token'
})

Sign in using a third-party provider

const { data, error } = await supabase.auth.signInWithOAuth({
  provider: 'github'
})

Sign in using a third-party provider with redirect

const { data, error } = await supabase.auth.signInWithOAuth({
  provider: 'github',
  options: {
    redirectTo: 'https://example.com/welcome'
  }
})

Sign in with scopes and access provider tokens

// Register this immediately after calling createClient!
// Because signInWithOAuth causes a redirect, you need to fetch the
// provider tokens from the callback.
supabase.auth.onAuthStateChange((event, session) => {
  if (session && session.provider_token) {
    window.localStorage.setItem('oauth_provider_token', session.provider_token)
  }

  if (session && session.provider_refresh_token) {
    window.localStorage.setItem('oauth_provider_refresh_token', session.provider_refresh_token)
  }

  if (event === 'SIGNED_OUT') {
    window.localStorage.removeItem('oauth_provider_token')
    window.localStorage.removeItem('oauth_provider_refresh_token')
  }
})

// Call this on your Sign in with GitHub button to initiate OAuth
// with GitHub with the requested elevated scopes.
await supabase.auth.signInWithOAuth({
  provider: 'github',
  options: {
    scopes: 'repo gist notifications'
  }
})

Sign in with email

const { data, error } = await supabase.auth.signInWithOtp({
  email: 'example@email.com',
  options: {
    emailRedirectTo: 'https://example.com/welcome'
  }
})

Sign in with SMS OTP

const { data, error } = await supabase.auth.signInWithOtp({
  phone: '+13334445555',
})

Sign in with WhatsApp OTP

const { data, error } = await supabase.auth.signInWithOtp({
  phone: '+13334445555',
  options: {
    channel:'whatsapp',
  }
})

Sign in with email and password

const { data, error } = await supabase.auth.signInWithPassword({
  email: 'example@email.com',
  password: 'example-password',
})

Sign in with phone and password

const { data, error } = await supabase.auth.signInWithPassword({
  phone: '+13334445555',
  password: 'some-password',
})

Sign in with email domain

  // You can extract the user's email domain and use it to trigger the
  // authentication flow with the correct identity provider.

  const { data, error } = await supabase.auth.signInWithSSO({
    domain: 'company.com'
  })

  if (data?.url) {
    // redirect the user to the identity provider's authentication flow
    window.location.href = data.url
  }

Sign in with provider UUID

  // Useful when you need to map a user's sign in request according
  // to different rules that can't use email domains.

  const { data, error } = await supabase.auth.signInWithSSO({
    providerId: '21648a9d-8d5a-4555-a9d1-d6375dc14e92'
  })

  if (data?.url) {
    // redirect the user to the identity provider's authentication flow
    window.location.href = data.url
  }

Sign in with Solana or Ethereum (Window API)

  // uses window.ethereum for the wallet
  const { data, error } = await supabase.auth.signInWithWeb3({
    chain: 'ethereum',
    statement: 'I accept the Terms of Service at https://example.com/tos'
  })

  // uses window.solana for the wallet
  const { data, error } = await supabase.auth.signInWithWeb3({
    chain: 'solana',
    statement: 'I accept the Terms of Service at https://example.com/tos'
  })

Sign in with Ethereum (Message and Signature)

  const { data, error } = await supabase.auth.signInWithWeb3({
    chain: 'ethereum',
    message: '<sign in with ethereum message>',
    signature: '<hex of the ethereum signature over the message>',
  })

Sign in with Solana (Brave)

  const { data, error } = await supabase.auth.signInWithWeb3({
    chain: 'solana',
    statement: 'I accept the Terms of Service at https://example.com/tos',
    wallet: window.braveSolana
  })

Sign in with Solana (Wallet Adapter)

  function SignInButton() {
  const wallet = useWallet()

  return (
    <>
      {wallet.connected ? (
        <button
          onClick={() => {
            supabase.auth.signInWithWeb3({
              chain: 'solana',
              statement: 'I accept the Terms of Service at https://example.com/tos',
              wallet,
            })
          }}
        >
          Sign in with Solana
        </button>
      ) : (
        <WalletMultiButton />
      )}
    </>
  )
}

function App() {
  const endpoint = clusterApiUrl('devnet')
  const wallets = useMemo(() => [], [])

  return (
    <ConnectionProvider endpoint={endpoint}>
      <WalletProvider wallets={wallets}>
        <WalletModalProvider>
          <SignInButton />
        </WalletModalProvider>
      </WalletProvider>
    </ConnectionProvider>
  )
}

Sign out (all sessions)

const { error } = await supabase.auth.signOut()

Sign out (current session)

const { error } = await supabase.auth.signOut({ scope: 'local' })

Sign out (other sessions)

const { error } = await supabase.auth.signOut({ scope: 'others' })

A logged-in session if the server has "autoconfirm" ON

A user if the server has "autoconfirm" OFF

Sign up with an email and password

const { data, error } = await supabase.auth.signUp({
  email: 'example@email.com',
  password: 'example-password',
})

Sign up with a phone number and password (SMS)

const { data, error } = await supabase.auth.signUp({
  phone: '123456789',
  password: 'example-password',
  options: {
    channel: 'sms'
  }
})

Sign up with a phone number and password (whatsapp)

const { data, error } = await supabase.auth.signUp({
  phone: '123456789',
  password: 'example-password',
  options: {
    channel: 'whatsapp'
  }
})

Sign up with additional user metadata

const { data, error } = await supabase.auth.signUp(
  {
    email: 'example@email.com',
    password: 'example-password',
    options: {
      data: {
        first_name: 'John',
        age: 27,
      }
    }
  }
)

Sign up with a redirect URL

const { data, error } = await supabase.auth.signUp(
  {
    email: 'example@email.com',
    password: 'example-password',
    options: {
      emailRedirectTo: 'https://example.com/welcome'
    }
  }
)

Start and stop auto refresh in React Native

import { AppState } from 'react-native'

// make sure you register this only once!
AppState.addEventListener('change', (state) => {
  if (state === 'active') {
    supabase.auth.startAutoRefresh()
  } else {
    supabase.auth.stopAutoRefresh()
  }
})

Start and stop auto refresh in React Native

import { AppState } from 'react-native'

// make sure you register this only once!
AppState.addEventListener('change', (state) => {
  if (state === 'active') {
    supabase.auth.startAutoRefresh()
  } else {
    supabase.auth.stopAutoRefresh()
  }
})

Unlink an identity

// retrieve all identities linked to a user
const identities = await supabase.auth.getUserIdentities()

// find the google identity
const googleIdentity = identities.find(
  identity => identity.provider === 'google'
)

// unlink the google identity
const { error } = await supabase.auth.unlinkIdentity(googleIdentity)

Update the email for an authenticated user

const { data, error } = await supabase.auth.updateUser({
  email: 'new@email.com'
})

Update the phone number for an authenticated user

const { data, error } = await supabase.auth.updateUser({
  phone: '123456789'
})

Update the password for an authenticated user

const { data, error } = await supabase.auth.updateUser({
  password: 'new password'
})

Update the user's metadata

const { data, error } = await supabase.auth.updateUser({
  data: { hello: 'world' }
})

Update the user's password with a nonce

const { data, error } = await supabase.auth.updateUser({
  password: 'new password',
  nonce: '123456'
})

Verify Signup One-Time Password (OTP)

const { data, error } = await supabase.auth.verifyOtp({ email, token, type: 'email'})

Verify SMS One-Time Password (OTP)

const { data, error } = await supabase.auth.verifyOtp({ phone, token, type: 'sms'})

Verify Email Auth (Token Hash)

const { data, error } = await supabase.auth.verifyOtp({ token_hash: tokenHash, type: 'email'})