# React single-page app

Add sign-in to a React browser app as a public client, using react-oidc-context and the Authorization Code flow with PKCE.

This guide adds OIDC sign-in to a React app with no backend of its own, using [`react-oidc-context`](https://www.npmjs.com/package/react-oidc-context) (built on `oidc-client-ts`). A browser app is a **public** client: it has a client ID but no secret, and relies on PKCE.

Register the application as a **public / single-page** OIDC client and add your redirect URI first; see [Before you start](https://dts-identity.com/docs/quickstarts.md#before-you-start). For the underlying protocol, see [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/docs/quickstarts/oidc-authorization-code.md).

## 1. Install

```bash
npm install react-oidc-context oidc-client-ts
```

## 2. Configure the provider

Wrap your app in `AuthProvider`. The `authority` is your instance's login domain; the library discovers the endpoints and uses Authorization Code with PKCE by default.

```jsx
// main.jsx
import { createRoot } from 'react-dom/client';
import { AuthProvider } from 'react-oidc-context';
import App from './App';

const oidcConfig = {
  authority: 'https://<your-domain>',
  client_id: '<your-client-id>',
  redirect_uri: 'https://app.example.com/callback',
  post_logout_redirect_uri: 'https://app.example.com/',
  scope: 'openid profile email',
  // Clean the code/state params out of the URL after the redirect back.
  onSigninCallback: () =>
    window.history.replaceState({}, document.title, window.location.pathname),
};

createRoot(document.getElementById('root')).render(
  <AuthProvider {...oidcConfig}>
    <App />
  </AuthProvider>
);
```

Do not put a client secret in browser code. A public client has none.

## 3. Sign in and read the user

Use the `useAuth` hook to trigger sign-in and read the result.

```jsx
// App.jsx
import { useAuth } from 'react-oidc-context';

export default function App() {
  const auth = useAuth();

  if (auth.isLoading) return <p>Loading...</p>;
  if (auth.error) return <p>Sign-in error: {auth.error.message}</p>;

  if (auth.isAuthenticated) {
    return (
      <div>
        <p>Signed in as {auth.user?.profile.email}</p>
        <button onClick={() => auth.signoutRedirect()}>Log out</button>
      </div>
    );
  }

  return <button onClick={() => auth.signinRedirect()}>Log in</button>;
}
```

`auth.user.profile` holds the ID-token claims (such as `sub`, `name`, `email`). `auth.user.access_token` is the token you send to your own APIs as `Authorization: Bearer <token>`.

## 4. Handle the redirect

`react-oidc-context` processes the callback automatically when the app loads at the `redirect_uri`, as long as the `AuthProvider` wraps the component tree. Point your redirect URI at a route your app serves (for example `/callback`), and make sure that route renders the same provider-wrapped app.

## Troubleshooting

- **The redirect loops or the URL keeps the `code` parameter.** Add the `onSigninCallback` handler shown above so the one-time parameters are cleared after processing.
- **`redirect_uri` mismatch.** The `redirect_uri` must match a value registered on the application exactly, including the path. Register the SPA callback URL you use.
- **Tokens vanish on refresh.** By default tokens are held in memory and are lost on a full reload. Configure a user store (for example `WebStorageStateStore` with `localStorage`) if you need them to persist, and weigh the security trade-off of storing tokens in the browser.
- **`invalid_client`.** The application must be registered as a public (PKCE) client. A confidential client expects a secret the browser cannot provide.

## Next

- [Node / Express backend](https://dts-identity.com/docs/quickstarts/node-express.md) if you add a server component.
- [APIs](https://dts-identity.com/docs/integrations/apis.md) to protect your own API with the access token.
