What is @auth0/auth0-react?
@auth0/auth0-react is a library that provides React hooks and components to integrate Auth0 authentication and authorization into React applications. It simplifies the process of adding authentication, handling user sessions, and securing routes.
What are @auth0/auth0-react's main functionalities?
Authentication
This feature allows you to integrate Auth0 authentication into your React application. The Auth0Provider component wraps your application and provides authentication context. The useAuth0 hook is used to access authentication methods like loginWithRedirect and logout.
import { Auth0Provider, useAuth0 } from '@auth0/auth0-react';
const App = () => (
<Auth0Provider
domain="YOUR_DOMAIN"
clientId="YOUR_CLIENT_ID"
redirectUri={window.location.origin}
>
<YourComponent />
</Auth0Provider>
);
const YourComponent = () => {
const { loginWithRedirect, logout, isAuthenticated } = useAuth0();
return (
<div>
{!isAuthenticated && (
<button onClick={() => loginWithRedirect()}>Log in</button>
)}
{isAuthenticated && (
<button onClick={() => logout({ returnTo: window.location.origin })}>Log out</button>
)}
</div>
);
};
User Profile
This feature allows you to access and display the authenticated user's profile information. The useAuth0 hook provides the user object, which contains details like name, email, and profile picture.
import { useAuth0 } from '@auth0/auth0-react';
const UserProfile = () => {
const { user, isAuthenticated } = useAuth0();
if (!isAuthenticated) {
return <div>Please log in to see your profile.</div>;
}
return (
<div>
<img src={user.picture} alt={user.name} />
<h2>{user.name}</h2>
<p>{user.email}</p>
</div>
);
};
Securing Routes
This feature allows you to secure specific routes in your React application. The withAuthenticationRequired higher-order component ensures that only authenticated users can access the protected routes. If a user is not authenticated, they will be redirected to the login page.
import { useAuth0, withAuthenticationRequired } from '@auth0/auth0-react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
const ProtectedRoute = ({ component, ...args }) => (
<Route
component={withAuthenticationRequired(component, {
onRedirecting: () => <div>Loading...</div>,
})}
{...args}
/>
);
const App = () => (
<Router>
<Switch>
<Route path="/public" component={PublicComponent} />
<ProtectedRoute path="/protected" component={ProtectedComponent} />
</Switch>
</Router>
);
Other packages similar to @auth0/auth0-react
react-oauth
react-oauth is a library that provides OAuth2 authentication for React applications. It supports multiple OAuth providers and offers hooks and components for integrating authentication. Compared to @auth0/auth0-react, react-oauth is more generic and can be used with various OAuth providers, whereas @auth0/auth0-react is specifically designed for Auth0.
react-aad-msal
react-aad-msal is a library for integrating Microsoft Azure Active Directory (AAD) authentication into React applications. It provides hooks and components for handling authentication and user sessions. Compared to @auth0/auth0-react, react-aad-msal is tailored for Microsoft AAD, while @auth0/auth0-react is focused on Auth0.
react-firebase-auth
react-firebase-auth is a library that simplifies Firebase authentication in React applications. It provides hooks and components for managing user authentication and sessions with Firebase. Compared to @auth0/auth0-react, react-firebase-auth is specific to Firebase, whereas @auth0/auth0-react is specific to Auth0.
@auth0/auth0-react
Auth0 SDK for React Single Page Applications (SPA).
Table of Contents
Documentation
Installation
Using npm
npm install @auth0/auth0-react
Using yarn
yarn add @auth0/auth0-react
Getting Started
Configure the SDK by wrapping your application in Auth0Provider
:
import React from 'react';
import ReactDOM from 'react-dom';
import { Auth0Provider } from '@auth0/auth0-react';
import App from './App';
ReactDOM.render(
<Auth0Provider
domain="YOUR_AUTH0_DOMAIN"
clientId="YOUR_AUTH0_CLIENT_ID"
redirectUri={window.location.origin}
>
<App />
</Auth0Provider>,
document.getElementById('app')
);
Use the useAuth0
hook in your components to access authentication state (isLoading
, isAuthenticated
and user
) and authentication methods (loginWithRedirect
and logout
):
import React from 'react';
import { useAuth0 } from '@auth0/auth0-react';
function App() {
const {
isLoading,
isAuthenticated,
error,
user,
loginWithRedirect,
logout,
} = useAuth0();
if (isLoading) {
return <div>Loading...</div>;
}
if (error) {
return <div>Oops... {error.message}</div>;
}
if (isAuthenticated) {
return (
<div>
Hello {user.name}{' '}
<button onClick={() => logout({ returnTo: window.location.origin })}>
Log out
</button>
</div>
);
} else {
return <button onClick={loginWithRedirect}>Log in</button>;
}
}
export default App;
If you're using TypeScript, you can pass a type parameter to useAuth0
to specify the type of user
:
const { user } = useAuth0<{ name: string }>();
user.name;
Use with a Class Component
Use the withAuth0
higher order component to add the auth0
property to Class components:
import React, { Component } from 'react';
import { withAuth0 } from '@auth0/auth0-react';
class Profile extends Component {
render() {
const { user } = this.props.auth0;
return <div>Hello {user.name}</div>;
}
}
export default withAuth0(Profile);
Protect a Route
Protect a route component using the withAuthenticationRequired
higher order component. Visits to this route when unauthenticated will redirect the user to the login page and back to this page after login:
import React from 'react';
import { withAuthenticationRequired } from '@auth0/auth0-react';
const PrivateRoute = () => <div>Private</div>;
export default withAuthenticationRequired(PrivateRoute, {
onRedirecting: () => <div>Redirecting you to the login page...</div>,
});
Note If you are using a custom router, you will need to supply the Auth0Provider
with a custom onRedirectCallback
method to perform the action that returns the user to the protected page. See examples for react-router, Gatsby and Next.js.
Call an API
Call a protected API with an Access Token:
import React, { useEffect, useState } from 'react';
import { useAuth0 } from '@auth0/auth0-react';
const Posts = () => {
const { getAccessTokenSilently } = useAuth0();
const [posts, setPosts] = useState(null);
useEffect(() => {
(async () => {
try {
const token = await getAccessTokenSilently({
audience: 'https://api.example.com/',
scope: 'read:posts',
});
const response = await fetch('https://api.example.com/posts', {
headers: {
Authorization: `Bearer ${token}`,
},
});
setPosts(await response.json());
} catch (e) {
console.error(e);
}
})();
}, [getAccessTokenSilently]);
if (!posts) {
return <div>Loading...</div>;
}
return (
<ul>
{posts.map((post, index) => {
return <li key={index}>{post}</li>;
})}
</ul>
);
};
export default Posts;
For a more detailed example see how to create a useApi
hook for accessing protected APIs with an access token.
Contributing
We appreciate feedback and contribution to this repo! Before you get started, please see the following:
Support + Feedback
For support or to provide feedback, please raise an issue on our issue tracker.
Troubleshooting
For information on how to solve common problems, check out the Troubleshooting guide
Frequently Asked Questions
For a rundown of common issues you might encounter when using the SDK, please check out the FAQ.
Vulnerability Reporting
Please do not report security vulnerabilities on the public GitHub issue tracker. The Responsible Disclosure Program details the procedure for disclosing security issues.
What is Auth0?
Auth0 helps you to easily:
- Implement authentication with multiple identity providers, including social (e.g., Google, Facebook, Microsoft, LinkedIn, GitHub, Twitter, etc), or enterprise (e.g., Windows Azure AD, Google Apps, Active Directory, ADFS, SAML, etc.)
- Log in users with username/password databases, passwordless, or multi-factor authentication
- Link multiple user accounts together
- Generate signed JSON Web Tokens to authorize your API calls and flow the user identity securely
- Access demographics and analytics detailing how, when, and where users are logging in
- Enrich user profiles from other data sources using customizable JavaScript rules
Why Auth0?
License
This project is licensed under the MIT license. See the LICENSE file for more info.