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 currSessionInfo = await Session.getSessionInformation(handle)            if (currSessionInfo === undefined) {                  return;            }            let currentJWT = currSessionInfo.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:        session_information = await get_session_information(handle)        if session_information is None:            continue
        current_access_token_payload = session_information.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:    session_information = get_session_information(handle)    if session_information is None:        continue
    current_access_token_payload = session_information.access_token_payload    current_jwt = current_access_token_payload['jwt']

On the frontend

ReactJS

With React Context

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

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;      }}

Angular

Via NPM

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

Via Script Tag

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

Plain JavaScript

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

React Native

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