# Quickstarts

Connect your own application for sign-in over OpenID Connect, with copy-paste guides for the generic flow, Node, Python, and React.

These guides get an application signing users in through the platform over **OpenID Connect (OIDC)**. Start with the generic flow to understand the moving parts, then jump to the guide that matches your stack.

| Guide | Use it for |
|---|---|
| [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/docs/quickstarts/oidc-authorization-code.md) | The protocol itself, with plain HTTP and curl. Read this first; the others build on it. |
| [Node / Express backend](https://dts-identity.com/docs/quickstarts/node-express.md) | A server-rendered or API-backed web app in Node.js. |
| [Python / Flask backend](https://dts-identity.com/docs/quickstarts/python-flask.md) | A server-rendered web app in Python. |
| [React single-page app](https://dts-identity.com/docs/quickstarts/react-spa.md) | A browser app with no backend of its own. |
| [Financial-grade API (FAPI 2.0) client](https://dts-identity.com/docs/quickstarts/fapi-2.md) | An application on a FAPI 2.0 security profile: private key JWT, pushed authorization requests, DPoP. |
| [Protect an API](https://dts-identity.com/docs/quickstarts/protect-an-api.md) | The other side: validating the platform's access tokens in your own API and enforcing scopes. |

To call the platform's **management REST API** from a backend service (not user sign-in), see the machine-to-machine quickstart in [APIs](https://dts-identity.com/docs/integrations/apis.md#call-the-management-api-machine-to-machine-quickstart) instead.

## Before you start

1. **Register your application.** In the Admin Console, add an application and choose the OIDC type that matches your deployment: a **confidential** client for anything with a backend that can keep a secret (Node/Express, Python/Flask), or a **public** client for a single-page or native app that cannot. See [Applications](https://dts-identity.com/docs/integrations/applications.md#choosing-an-oidc-type-by-deployment-shape).
2. **Note the credentials.** A confidential client has a **client ID** and **client secret**; a public client has a **client ID** only and relies on PKCE. Keep the secret on the server, never in browser code.
3. **Add your redirect URI.** Register the exact URL the platform returns the user to after sign-in (for example `https://app.example.com/callback`). Redirect URIs are compared character by character: scheme, host, port, path, and trailing slash must be identical; wildcards are not supported.
4. **Know your endpoints.** Everything below is discoverable at your instance's OpenID configuration document:

   ```
   https://<your-domain>/.well-known/openid-configuration
   ```

   Replace `<your-domain>` with your instance's login domain (your [custom domain](https://dts-identity.com/docs/branding/custom-domains.md) if you have one, otherwise the platform host). This document lists the `authorization_endpoint`, `token_endpoint`, `userinfo_endpoint`, `jwks_uri`, and `end_session_endpoint`. **Treat the discovery document as the source of truth** and let your library read it, rather than hard-coding paths.

## The endpoints at a glance

For orientation, the standard paths are:

| Purpose | Path |
|---|---|
| Discovery | `/.well-known/openid-configuration` |
| Authorization | `/authorize` |
| Token | `/oauth/token` |
| UserInfo | `/userinfo` |
| Signing keys (JWKS) | `/.well-known/jwks` |
| Logout (end session) | `/logout` |

**PKCE** is required for public clients and for applications on a Financial-grade API security profile, and S256 is the only challenge method accepted. Always use Authorization Code with PKCE; the implicit flow is not recommended.
