Auth0Client

import { Auth0Client } from '@auth0/nextjs-auth0/server';

const auth0 = new Auth0Client(options?: Auth0ClientOptions);

middleware(req: Request | NextRequest): Promise<NextResponse>

// App Router: Server Components, Server Actions, Route Handlers
getSession(): Promise<SessionData | null>

// Pages Router: middleware, getServerSideProps, API routes
getSession(req: PagesRouterRequest | NextRequest): Promise<SessionData | null>

// App Router: Server Components, Server Actions, Route Handlers
getAccessToken(options?: GetAccessTokenOptions): Promise<{
  token: string;
  expiresAt: number;
  scope?: string;
  token_type?: string;
  audience?: string;
}>

// Pages Router: middleware, getServerSideProps, API routes
getAccessToken(
  req: PagesRouterRequest | NextRequest,
  res: PagesRouterResponse | NextResponse,
  options?: GetAccessTokenOptions
): Promise<{
  token: string;
  expiresAt: number;
  scope?: string;
  token_type?: string;
  audience?: string;
}>

// App Router
getAccessTokenForConnection(
  options: AccessTokenForConnectionOptions
): Promise<{ token: string; expiresAt: number }>

// Pages Router
getAccessTokenForConnection(
  options: AccessTokenForConnectionOptions,
  req: PagesRouterRequest | NextRequest | Request | undefined,
  res: PagesRouterResponse | NextResponse | undefined
): Promise<{ token: string; expiresAt: number }>

customTokenExchange(
  options: CustomTokenExchangeOptions
): Promise<CustomTokenExchangeResponse>

// App Router: Server Actions, Route Handlers
updateSession(session: SessionData): Promise<void>

// Pages Router: middleware, getServerSideProps, API routes
updateSession(
  req: PagesRouterRequest | NextRequest | Request,
  res: PagesRouterResponse | NextResponse | Response,
  session: SessionData
): Promise<void>

startInteractiveLogin(
  options?: StartInteractiveLoginOptions
): Promise<NextResponse>

getTokenByBackchannelAuth(
  options: BackchannelAuthenticationOptions
): Promise<BackchannelAuthenticationResponse>

connectAccount(
  options: ConnectAccountOptions
): Promise<NextResponse>

createFetcher<TOutput extends Response = Response>(
  req: PagesRouterRequest | NextRequest | Request | undefined,
  options: {
    useDPoP?: boolean;
    getAccessToken?: AccessTokenFactory;
    baseUrl?: string;
    fetch?: CustomFetchImpl<TOutput>;
  }
): Promise<Fetcher<TOutput>>

// App Router
withPageAuthRequired(
  Component: AppRouterPageRoute,
  opts?: WithPageAuthRequiredAppRouterOptions
): AppRouterPageRoute

// Pages Router
withPageAuthRequired(
  opts?: WithPageAuthRequiredPageRouterOptions
): PageRoute

withApiAuthRequired(
  apiRoute: AppRouteHandlerFn | NextApiHandler
): (req, res) => Promise<Response>

get mfa(): ServerMfaClient

import { Auth0Client } from '@auth0/nextjs-auth0/server';

// Create an instance
export const auth0 = new Auth0Client({
  domain: process.env.AUTH0_DOMAIN,
  clientId: process.env.AUTH0_CLIENT_ID,
  clientSecret: process.env.AUTH0_CLIENT_SECRET,
  secret: process.env.AUTH0_SECRET,
  appBaseUrl: process.env.APP_BASE_URL,
  session: {
    rolling: true,
    absoluteDuration: 60 * 60 * 24 * 7, // 7 days
    inactivityDuration: 60 * 60 * 24 // 1 day
  }
});

// Use in middleware
export async function middleware(request: NextRequest) {
  return await auth0.middleware(request);
}

// Get session in App Router
export default async function Page() {
  const session = await auth0.getSession();
  
  if (!session) {
    return <div>Not authenticated</div>;
  }
  
  return <div>Welcome, {session.user.name}!</div>;
}

// Get access token in API route
export async function GET(request: NextRequest) {
  try {
    const { token } = await auth0.getAccessToken();
    
    // Use the token to call an API
    const response = await fetch('https://api.example.com/data', {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    
    return Response.json(await response.json());
  } catch (error) {
    if (error instanceof MfaRequiredError) {
      // Handle MFA required scenario
      return Response.json({ error: 'MFA required' }, { status: 401 });
    }
    throw error;
  }
}