Getting the JWT

caution

Using JWTs is optional and is only required if you want to integrate with another service that relies on JWTs or if you want to integrate with a backend framework that we do not support yet

On the backend

Method 1) After session verification

NodeJS

Express

import express from "express";import { verifySession } from "supertokens-node/recipe/session/framework/express";
let app = express();
app.get("/getJWT", verifySession(), async (req, res) => {
    let session = req.session;
    let jwt = session.getAccessTokenPayload()["jwt"];
    res.json({ token: jwt })});

Hapi

import Hapi from "@hapi/hapi";import { verifySession } from "supertokens-node/recipe/session/framework/hapi";import { SessionRequest } from "supertokens-node/framework/hapi";
let server = Hapi.server({ port: 8000 });
server.route({    path: "/getJWT",    method: "get",    options: {        pre: [            {                method: verifySession()            },        ],    },    handler: async (req: SessionRequest, res) => {        let session = req.session;
        let jwt = session!.getAccessTokenPayload()["jwt"];        return res.response({ token: jwt }).code(200);    }})

Fastify

import Fastify from "fastify";import { verifySession } from "supertokens-node/recipe/session/framework/fastify";
let fastify = Fastify();
fastify.get("/getJWT", {    preHandler: verifySession(),}, (req, res) => {    let session = req.session;
    let jwt = session.getAccessTokenPayload()["jwt"];    res.send({ token: jwt });});

Koa

import { verifySession } from "supertokens-node/recipe/session/framework/awsLambda";import { SessionEvent } from "supertokens-node/framework/awsLambda";
async function getJWT(awsEvent: SessionEvent) {    let session = awsEvent.session;
    let jwt = session!.getAccessTokenPayload()["jwt"];
    return {        body: JSON.stringify({ token: jwt }),        statusCode: 200,    };};
exports.handler = verifySession(getJWT);

Loopback

import KoaRouter from "koa-router";import { verifySession } from "supertokens-node/recipe/session/framework/koa";import { SessionContext } from "supertokens-node/framework/koa";
let router = new KoaRouter();
router.get("/getJWT", verifySession(), (ctx: SessionContext, next) => {    let session = ctx.session;
    let jwt = session!.getAccessTokenPayload()["jwt"];    ctx.body = { token: jwt };});

AWS Lambda / Netlify

import { inject, intercept } from "@loopback/core";import { RestBindings, get, response } from "@loopback/rest";import { verifySession } from "supertokens-node/recipe/session/framework/loopback";import { SessionContext } from "supertokens-node/framework/loopback";
class GetJWT {    constructor(@inject(RestBindings.Http.CONTEXT) private ctx: SessionContext) { }    @get("/getJWT")    @intercept(verifySession())    @response(200)    handler() {        let session = this.ctx.session;
        let jwt = session!.getAccessTokenPayload()["jwt"];        return { token: jwt };    }}

Next.js

import { superTokensNextWrapper } from 'supertokens-node/nextjs'import { verifySession } from "supertokens-node/recipe/session/framework/express";import { SessionRequest } from "supertokens-node/framework/express";
export default async function getJWT(req: SessionRequest, res: any) {    await superTokensNextWrapper(        async (next) => {            await verifySession()(req, res, next);        },        req,        res    )    let session = req.session;
    let jwt = session!.getAccessTokenPayload()["jwt"];    res.json({ token: jwt })}

NestJS

import { Controller, Get, UseGuards, Session } from "@nestjs/common";import { SessionContainer } from "supertokens-node/recipe/session";import { AuthGuard } from './auth/auth.guard';
@Controller()export class ExampleController {  @Get('example')  @UseGuards(AuthGuard)  async postExample(@Session() session: SessionContainer): Promise<{ token: any }> {    const currAccessTokenPayload = session.getAccessTokenPayload();
    // For more information about "AuthGuard" and the "Session" decorator please read our NestJS guide.    let jwt = session.getAccessTokenPayload()["jwt"];    return { token: jwt };  }}

GoLang

import (    "fmt"    "net/http"
    "github.com/supertokens/supertokens-golang/recipe/session")
// We assume that you have wrapped this handler with session.VerifySessionfunc getJWT(w http.ResponseWriter, r *http.Request) {    // retrieve the session object as shown below    sessionContainer := session.GetSessionFromRequestContext(r.Context())
    currAccessTokenPayload := sessionContainer.GetAccessTokenPayload()
    jwt := currAccessTokenPayload["jwt"]
    fmt.Println(jwt)}

Python

FastAPI

from supertokens_python.recipe.session.framework.fastapi import verify_sessionfrom fastapi import Dependsfrom supertokens_python.recipe.session import SessionContainer
@app.get('/getJWT') async def get_jwt(session: SessionContainer = Depends(verify_session())):    current_jwt = session.get_access_token_payload()['jwt']
    print(current_jwt) # TODO...

Flask

from supertokens_python.recipe.session.framework.flask import verify_sessionfrom supertokens_python.recipe.session import SessionContainerfrom flask import g
@app.route('/getJWT', methods=['GET']) @verify_session()def get_jwt():    session: SessionContainer = g.supertokens 
    current_jwt = session.get_access_token_payload()['jwt']
    print(current_jwt) # TODO...

Django

from supertokens_python.recipe.session.framework.django.asyncio import verify_sessionfrom django.http import HttpRequestfrom supertokens_python.recipe.session import SessionContainer
@verify_session()async def get_jwt(request: HttpRequest):    session: SessionContainer = request.supertokens 
    current_jwt = session.get_access_token_payload()['jwt']
    print(current_jwt) # TODO...

Method 2) Without session verification

NodeJS

import Session from "supertokens-node/recipe/session";
async function getJWT() {      let userId = "...";      // we first get all the sessionHandles (string[]) for a user      let sessionHandles = await Session.getAllSessionHandlesForUser(userId);
      sessionHandles.forEach(async (handle) => {            let currentJWT = (await Session.getSessionInformation(handle)).accessTokenPayload["jwt"];      })}

GoLang

import (    "fmt"
    "github.com/supertokens/supertokens-golang/recipe/session")
func main() {    // we first get all the sessionHandles (string[]) for a user    sessionHandles, err := session.GetAllSessionHandlesForUser("userId")    if err != nil {        // TODO: handle error        return    }
    // we update all the session's access token payloads for this user    for _, handle := range sessionHandles {        sessionInfo, err := session.GetSessionInformation(handle)        if err != nil {            // TODO: handle error            return        }
        currJWT := sessionInfo.AccessTokenPayload["jwt"]
        fmt.Println(currJWT)    }}

Python

Asyncio

from supertokens_python.recipe.session.asyncio import get_all_session_handles_for_user, get_session_information
async def some_func():    # we first get all the session_handles (List[string]) for a user    session_handles = await get_all_session_handles_for_user("userId")
    for handle in session_handles:        current_session_info = await get_session_information(handle)
        current_access_token_payload = current_session_info.access_token_payload        current_jwt = current_access_token_payload['jwt']        print(current_jwt) # TODO..

Syncio

from supertokens_python.recipe.session.syncio import get_all_session_handles_for_user, get_session_information
# we first get all the session_handles (List[string]) for a usersession_handles = get_all_session_handles_for_user("userId")
for handle in session_handles:    current_session_info = get_session_information(handle)
    current_access_token_payload = current_session_info.access_token_payload    current_jwt = current_access_token_payload['jwt']

On the frontend

ReactJS

With React Context

Step 1: Wrap the component in which you want to get the info with PasswordlessAuth

import React from "react";import { PasswordlessAuth } from 'supertokens-auth-react/recipe/passwordless';import Dashboard from "./dashboard";
function ProtectedDashboard(props: any) {      return (            <PasswordlessAuth>                  <Dashboard />            </PasswordlessAuth>      );}

Step 2: This is how to use the session context in a component:

import React from "react";import { useSessionContext } from 'supertokens-auth-react/recipe/session'; 
// Your dashboard componentfunction Dashboard(props: any) {    let {userId, accessTokenPayload} = useSessionContext();
    let jwt = accessTokenPayload.jwt;}

Without React Context

import Session from 'supertokens-auth-react/recipe/session';
async function getJWT() {      if (await Session.doesSessionExist()) {            let userId = await Session.getUserId();            let jwt = (await Session.getAccessTokenPayloadSecurely()).jwt;      }}

Plain JavaScript

Via NPM

import SuperTokens from 'supertokens-website';
async function getJWT() {      if (await SuperTokens.doesSessionExist()) {            let userId = await SuperTokens.getUserId();            let jwt = (await SuperTokens.getAccessTokenPayloadSecurely()).jwt;      }}

Via Script Tag

async function getJWT() {      if (await supertokens.doesSessionExist()) {            let userId = await supertokens.getUserId();            let jwt = (await supertokens.getAccessTokenPayloadSecurely()).jwt;      }}

React Native

import SuperTokens from 'supertokens-react-native';
async function getJWT() {      if (await SuperTokens.doesSessionExist()) {            let userId = await SuperTokens.getUserId();            let jwt = (await SuperTokens.getAccessTokenPayloadSecurely()).jwt;      }}