Which UI do you use?

Custom UI

Pre built UI

Getting provider's access token

You can get the Third Party Provider's access token to query their APIs with the following method:

NodeJS

Important

For other backend frameworks, you can follow our guide on how to spin up a separate server configured with the SuperTokens backend SDK to authenticate requests and issue session tokens.

GoLang

import SuperTokens from "supertokens-node";
import ThirdParty from "supertokens-node/recipe/thirdparty";
import Session from "supertokens-node/recipe/session";

SuperTokens.init({
    appInfo: {
        apiDomain: "...",
        appName: "...",
        websiteDomain: "..."
    },
    supertokens: {
        connectionURI: "...",
    },
    recipeList: [
        ThirdParty.init({
            signInAndUpFeature: {
                providers: [/* ... */]
            },
            override: {
                apis: (originalImplementation) => {
                    return {
                        ...originalImplementation,

                        signInUpPOST: async function (input) {

                            if (originalImplementation.signInUpPOST === undefined) {
                                throw Error("Should never come here");
                            }

                            let response = await originalImplementation.signInUpPOST(input)

                            if (response.status === "OK") {

                                // In this example we are using Google as our provider
                                let accessToken = response.oAuthTokens["access_token"]

                                // TODO: ...

                            }

                            return response;
                        },
                    }
                }
            },
        }),
        Session.init()
    ]
});

Python

import (
    "fmt"

    "github.com/supertokens/supertokens-golang/recipe/thirdparty"
    "github.com/supertokens/supertokens-golang/recipe/thirdparty/tpmodels"
    "github.com/supertokens/supertokens-golang/supertokens"
)

func main() {
    supertokens.Init(supertokens.TypeInput{
        RecipeList: []supertokens.Recipe{
            thirdparty.Init(&tpmodels.TypeInput{
                Override: &tpmodels.OverrideStruct{
                    APIs: func(originalImplementation tpmodels.APIInterface) tpmodels.APIInterface {
                        // First we copy the original implementation
                        originalSignInUpPOST := *originalImplementation.SignInUpPOST

                        (*originalImplementation.SignInUpPOST) = func(provider *tpmodels.TypeProvider, input tpmodels.TypeSignInUpInput, tenantId string, options tpmodels.APIOptions, userContext *map[string]interface{}) (tpmodels.SignInUpPOSTResponse, error) {
                            resp, err := originalSignInUpPOST(provider, input, tenantId, options, userContext)
                            if err != nil {
                                return tpmodels.SignInUpPOSTResponse{}, err
                            }

                            if resp.OK != nil {
                                // the user logged in / signed up successfully

                                // In this example we are using Google as our provider
                                authCodeResponse := resp.OK.OAuthTokens

                                accessToken := authCodeResponse["access_token"].(string)

                                fmt.Println(accessToken)

                            }

                            return resp, err
                        }

                        return originalImplementation
                    },
                },
            }),
        },
    })
}

Other Frameworks

from supertokens_python import init, InputAppInfo
from supertokens_python.recipe import thirdparty
from supertokens_python.recipe.thirdparty.interfaces import APIInterface, APIOptions, SignInUpPostOkResult
from typing import Optional, Dict, Any
from supertokens_python.recipe.thirdparty.provider import Provider, RedirectUriInfo

def override_thirdparty_apis(original_implementation: APIInterface):
    
    original_sign_in_up_post = original_implementation.sign_in_up_post
    
    async def sign_in_up_post(
        provider: Provider,
        redirect_uri_info: Optional[RedirectUriInfo],
        oauth_tokens: Optional[Dict[str, Any]],
        tenant_id: str,
        api_options: APIOptions,
        user_context: Dict[str, Any]
    ):
        # First we call the original implementation of signInPOST.
        response = await original_sign_in_up_post(provider, redirect_uri_info, oauth_tokens, tenant_id, api_options, user_context)
        
        # Post sign up response, we check if it was successful
        if isinstance(response, SignInUpPostOkResult):
            _ = response.user.user_id
            __ = response.user.email

            # In this example we are using Google as our provider
            thirdparty_auth_response = response.oauth_tokens

            access_token = thirdparty_auth_response["access_token"]
            print(access_token)
            # TODO

        return response
        
    original_implementation.sign_in_up_post = sign_in_up_post
    return original_implementation

init(
    app_info=InputAppInfo(api_domain="...", app_name="...", website_domain="..."),
    framework='...', 
    recipe_list=[
        thirdparty.init(
            override=thirdparty.InputOverrideConfig(
                apis=override_thirdparty_apis
            ),
            sign_in_and_up_feature=thirdparty.SignInAndUpFeature(providers=[
                #...
            ])
        )
    ]
)