# What is OpenID Connect?

> OpenID Connect is a thin identity layer on top of OAuth 2.0. An identity provider signs the user in and gives the app a signed ID token saying who the user is and which app the token is for.

Explainer by Boston Identity, 2026-10-26. 6 min read. https://insights.bostonidentity.com/glossary/oidc

- What it is: protocol
- Defined by: OpenID Foundation, Core 1.0 (final, errata set 2)
- Who it's for: Teams running sign-in for apps, APIs and agents

## What is OpenID Connect?

OAuth 2.0 lets an app get an access token to call an API on someone's behalf. By itself it has no standard way to tell the app who that someone is [S1 §1]. OpenID Connect (OIDC) fills that gap. The specification calls itself "a simple identity layer on top of the OAuth 2.0 protocol" that lets an app verify the user's identity from a sign-in done by the provider [S1 §1].

Two roles carry new names. The identity provider is the OpenID Provider (OP), and the app relying on its answer is the Relying Party (RP) [S1 §1]. An app turns OIDC on by adding the openid scope to an ordinary OAuth request [S1 §1]. The answer comes back as an ID token, a JSON Web Token (JWT), meaning a compact signed JSON document [S1 §2].

The ID token must carry the issuer (iss), the subject identifier for the user (sub), the audience (aud), an expiry (exp) and an issue time (iat) [S1 §2]. It may also say when the user signed in (auth_time) and which sign-in methods were used (amr) [S1 §2]. It must be signed, and it may also be encrypted [S1 §2]. Core 1.0 is a final specification; the copy we read incorporates errata set 2, dated 15 December 2023 [S1].

Think of it like this: Think of a front desk that phones a trusted office to confirm a visitor, and gets back a signed note naming the visitor, addressed to that desk, with a time limit. The analogy stops at the door: the note says who the visitor is, not what they may do inside.

Not the same as: Not the same as OAuth 2.0, which it is built on. OAuth defines how an app gets an access token for an API, and without a profile like this one it says nothing about how the user signed in [S1 §1].

## How does OpenID Connect work?

Three parties take part: the user with a browser, the app (the Relying Party), and the identity provider (the OpenID Provider) with its authorization, token and UserInfo endpoints. Core defines three flows; this is the Authorization Code Flow, where every token comes back from the token endpoint [S1 §3, §3.1].

[Figure: In the code flow the browser carries only a code; the app collects the ID token straight from the provider's token endpoint and checks it before trusting who signed in.]

1. **The app sends the user to the provider.** The app builds an authentication request and sends the browser to the provider's authorization endpoint over TLS (Transport Layer Security) [S1 §3.1.2]. The request must contain the openid scope, the response type code, the app's client_id and a redirect_uri that exactly matches one the app registered [S1 §3.1.2.1]. A state value is recommended against cross-site request forgery, and a nonce, a random value later echoed in the ID token, is optional in this flow [S1 §3.1.2.1].
2. **The provider signs the user in.** The provider authenticates the user, or checks that they are already signed in [S1 §3.1.2.3]. How it does that, by password or session cookie for example, is outside the specification. With prompt=login it must sign the user in again; with prompt=none it must not interact with the user, and must return an error if the user is not already signed in [S1 §3.1.2.3].
3. **The provider gets an authorization decision.** Before releasing anything about the user, the provider must obtain an authorization decision [S1 §3.1.2.4]. It may ask the user on a consent screen, or rely on other means such as earlier consent from an administrator [S1 §3.1.2.4].
4. **The provider sends the user back with a code.** The provider redirects the browser to the app's redirect_uri with an authorization code and the state value added as query parameters [S1 §3.1.2.5]. No token passes through the browser in this flow [S1 §3.1].
5. **The app trades the code for tokens.** The app posts the code to the provider's token endpoint over TLS, and a confidential client, one that can keep a secret, must authenticate itself there [S1 §3.1.3, §3.1.3.1]. The provider checks that the code is valid and was issued to this client, and that the redirect_uri matches the original request [S1 §3.1.3.2]. It answers with an ID token and an access token [S1 §3.1.3.3].
6. **The app validates the ID token.** The app must check that iss exactly matches the provider's issuer, that aud contains its own client_id, and that the token has not expired [S1 §3.1.3.7]. It must reject a token that lists other audiences it does not trust [S1 §3.1.3.7]. It must check the signature with the issuer's keys, though in this flow it may rely on the TLS connection to the token endpoint instead [S1 §3.1.3.7]. If it sent a nonce, the same nonce must be in the token [S1 §3.1.3.7]. The app then takes the user's subject identifier from the token [S1 §3.1.1].
7. **The app may ask for more about the user.** Optionally, the app sends the access token to the provider's UserInfo endpoint, which returns claims about the user such as name or email [S1 §1.3, §5.1]. The specification defines the UserInfo endpoint as a protected resource that must use https [S1 §1.2].

## Why does OpenID Connect matter now?

Vendors are still changing how they issue OIDC tokens this year. Okta made encryption of OIDC ID tokens generally available for custom app integrations, and Ping said that from 2 March 2027 PingOne will issue only opaque refresh tokens for OIDC apps [BI-FIND-2026-1173](https://insights.bostonidentity.com/ref/BI-FIND-2026-1173). Okta also made client ID metadata documents generally available in preview for OIDC apps on 16 September [BI-FIND-2026-0704](https://insights.bostonidentity.com/ref/BI-FIND-2026-0704).

OIDC has moved past the sign-in button, too. GitHub extended npm trusted publishing over OIDC, and AWS took outbound OIDC federation onto private networks [BI-FIND-2026-0707](https://insights.bostonidentity.com/ref/BI-FIND-2026-0707). After a worm spread on stolen developer credentials, Pandya named OIDC-based trusted publishing as the replacement for long-lived npm tokens [BI-FIND-2026-1533](https://insights.bostonidentity.com/ref/BI-FIND-2026-1533).

Agents are the open question. NIST's National Cybersecurity Center of Excellence lists OpenID Connect among the standards it is "currently considering" for agent identity [BI-FIND-2026-0686](https://insights.bostonidentity.com/ref/BI-FIND-2026-0686). Core has no claim saying what kind of subject sub names, and no claim for one party acting for another [BI-FIND-2023-0057](https://insights.bostonidentity.com/ref/BI-FIND-2023-0057). A draft OpenID profile adds a sub_type claim marking the subject as a user, an application or an agent [BI-FIND-2026-1397](https://insights.bostonidentity.com/ref/BI-FIND-2026-1397).

## Where does it fit?

- Compared with OAuth: OAuth 2.0 is the base: it gets an app an access token for an API. OpenID Connect adds the openid scope and the ID token so the app also learns who signed in and how [S1 §1].
- Compared with SAML: Small says most big clouds support both SAML and OpenID Connect, and that this alone is not enough to leave a cloud [BI-FIND-2026-1401](https://insights.bostonidentity.com/ref/BI-FIND-2026-1401). OpenID Connect carries its sign-in result as a signed JWT on top of OAuth 2.0 [S1 §1, §2].
- Compared with JWT: A JWT is a token format. An ID token is one particular JWT, with required claims for issuer, subject, audience, expiry and issue time [S1 §2].
- Compared with CIBA: CIBA is an OpenID flow in which the person approves on another device. Its provider must still obtain the person's decision as OpenID Connect Core describes it [BI-FIND-2021-0001](https://insights.bostonidentity.com/ref/BI-FIND-2021-0001).

## What goes wrong?

- Trusting the wrong identifier. Only iss and sub together identify a user; email, phone number and username must not be used as unique identifiers, because a provider may give one email address to different people over time [BI-FIND-2023-0054](https://insights.bostonidentity.com/ref/BI-FIND-2023-0054).
- Skipping validation. An app that does not check the issuer, audience, expiry and nonce can accept a token meant for someone else [S1 §3.1.3.7]. Core forbids the unsigned alg value none except in narrow cases the client asked for at registration [S1 §2].
- Choosing the Implicit Flow without weighing its limits. There the tokens come straight back through the browser, where the user and other apps with access to it can see them, and the client cannot be authenticated [S1 §3.2]. Core says the flow may be appropriate for a public client but never mentions PKCE (Proof Key for Code Exchange), and OAuth's later security guidance tells clients to avoid the implicit grant, with an exception [BI-FIND-2023-0060](https://insights.bostonidentity.com/ref/BI-FIND-2023-0060).
- Mixing up providers. A client that works with more than one authorization server is required to defend against mix-up attacks, for example by checking the ID token's iss claim [BI-FIND-2025-0353](https://insights.bostonidentity.com/ref/BI-FIND-2025-0353).
- Assuming logout is covered. Core does not say how a sign-in ends; logout lives in separate optional specifications [BI-FIND-2023-0059](https://insights.bostonidentity.com/ref/BI-FIND-2023-0059).

## What should a security leader ask?

1. Which of our apps match users by email address instead of by issuer and subject together?
2. Which of our apps still use the Implicit Flow, and which ones skip the nonce or ID token checks?
3. When someone is disabled at our identity provider, how does each app learn to end that session?
4. Which apps accept ID tokens from more than one provider, and do they check the issuer on every response?
5. When one of our agents signs in, what in its token tells a service that it is an agent and not a person?

## Sources

- [S1] [OpenID Connect Core 1.0 incorporating errata set 2](https://openid.net/specs/openid-connect-core-1_0.html) (OpenID Foundation, Final, errata set 2 (15 December 2023))

## Evidence

- [BI-FIND-2026-1173](https://insights.bostonidentity.com/ref/BI-FIND-2026-1173): Okta and Ping both changed token formats in January, and Ping's change comes with a deadline. Okta made JSON Web Encryption of OIDC ID tokens generally available for custom app integrations. PingOne began offering opaque refresh tokens for OIDC apps on January 27, and its note says that from March 2, 2027 PingOne will issue only opaque refresh tokens; apps not moved off JWT refresh tokens by March 1, 2027 may leave users unable to reach resources. We read both as limiting who can read a token's contents to the party meant to read it. (from "In January Okta's agent product was in early access; Auth0 and Microsoft made machine-to-machine features GA")
- [BI-FIND-2026-0704](https://insights.bostonidentity.com/ref/BI-FIND-2026-0704): Okta and Ping both shipped client ID metadata documents (CIMD), and CyberArk went the other way. With CIMD, an agent or app names itself with a URL that points to its own metadata, and needs no prior registration. Okta made CIMD a beta for AI agents and GA in preview for OIDC apps on September 16. Ping's Advanced Identity Cloud shipped it on September 29. CyberArk's September MCP feature relies on dynamic client registration (DCR) instead. Okta and Ping also changed their DCR support in the same releases, so neither has dropped it. (from "Three vendors now route MCP tool calls through an identity check, and only Cloudflare's is generally available")
- [BI-FIND-2026-0707](https://insights.bostonidentity.com/ref/BI-FIND-2026-0707): Most of September's non-human identity releases find and list credentials, and fewer remove them. SailPoint added thirteen connectors that list tokens, keys and service accounts. GitHub made credential inventory exports GA, and Cloudflare now cleans up inactive service tokens. Releases that replace stored secrets with a workload identity were fewer: CyberArk added workload attestation for AWS and Kubernetes, GitHub extended npm trusted publishing over OIDC, and AWS took outbound OIDC federation onto private networks. (from "Three vendors now route MCP tool calls through an identity check, and only Cloudflare's is generally available")
- [BI-FIND-2026-1533](https://insights.bostonidentity.com/ref/BI-FIND-2026-1533): The worm spreads on stolen developer credentials, tried one after another. With an npm publish token it first checks the token works and skips accounts protected by two-factor authentication, which Pandya says "cannot be quietly abused". It ranks the remaining packages by how widely they are used and how abandoned they look, then publishes a patch-version bump after a random delay. With a GitHub token it commits a carrier dependency and a CI workflow, and its last fallback is the SSH agent. To persist, it points the global git init template directory at infected hooks. For hardening he names OIDC-based trusted publishing in place of long-lived npm tokens, pinned GitHub Actions, and review of every workflow and dependency change. (from "Shai-Hulud v4 used an MCP tool description to tell AI assistants to read SSH keys and keep quiet about it")
- [BI-FIND-2026-0686](https://insights.bostonidentity.com/ref/BI-FIND-2026-0686): NIST's National Cybersecurity Center of Excellence framed agent identity in February as a question of applying what exists, not inventing something new. Its concept paper lists OAuth, OpenID Connect, SPIFFE, SCIM, the NGAC access-control standard and MCP as candidates it is "currently considering", and names none of the agent-specific IETF work, such as ID-JAG, the WIMSE drafts or token exchange for agents. It keeps human delegation and logging in scope and leaves agents from outside the enterprise for a later effort. The next steps are a possible project description and a lab-built practice guide, with no date; the comment period closed on 2 April. (from "NIST's agent identity work starts from OAuth, SPIFFE and SCIM and defers agents from outside the enterprise")
- [BI-FIND-2023-0057](https://insights.bostonidentity.com/ref/BI-FIND-2023-0057): Core writes the ID token as a statement about one person's sign-in, addressed to the client that asked for it. It defines the End-User as a "Human participant". The aud claim MUST contain the relying party's client_id and MAY name other audiences, and the client MUST reject a token that does not list it or lists audiences it does not trust. The azp claim, which names the party the token was issued to, is optional; the spec notes that "in practice, the azp Claim only occurs when extensions beyond the scope of this specification are used". Core's text defines no claim saying what kind of subject sub names and none for one party acting for another; the word agent appears only in "User Agent". We read that as the gap agent profiles fill: our briefing on Raza Sharif's OpenID agent-claims draft found it adding a sub_type claim that labels the subject a user, an application or an agent. (from "OpenID Connect Core says only issuer plus subject identify a user; email must never be the key")
- [BI-FIND-2026-1397](https://insights.bostonidentity.com/ref/BI-FIND-2026-1397): Revision -02 adds an eleventh claim, sub_type, that says whether the token's subject is a user, an application or an agent. The identity provider sets it from its own registration record, and it MUST NOT be suppliable or overridable by the client. Relying parties now MUST NOT infer an agent from agent_ claims, which reverses -00's line that the agent_ prefix lets them identify agent-specific assertions unambiguously. They MUST validate the issuer before relying on sub_type and MUST treat a missing value as unknown, failing closed where an authorization decision depends on the class. The claim sits outside the draft's own checks: none of the ten validation steps relying parties MUST run in Section 7.1 tests it. Section 5 requires it in an Agent ID Token, yet a provider MAY let an administrator omit it for a given client. When an agent acts for a user, the top-level sub_type describes the user and the act claim SHOULD carry the agent's own. The draft does not say whether such a token counts as an Agent ID Token, where sub_type is REQUIRED and the Section 5 example carries "agent". Sharif credits the design to three reviewers from WSO2's ThunderID project and says ThunderID shipped it in August 2026, but the draft links no release. (from "OpenID agent-claims draft adds a provider-set user, application or agent label; scores stay each provider's own")
- [BI-FIND-2026-1401](https://insights.bostonidentity.com/ref/BI-FIND-2026-1401): Small says most big clouds support SAML and OIDC, but that is not enough to leave one: moving clouds means moving every identity permission, so he suggests asking a provider whether those permissions can be exported. Vendors help customers in, he says, but not out, and standards help without being sufficient. (from "KuppingerCole's Mike Small blames most cloud incidents on customers' identity mistakes and sees CNAPP moving to cover AI")
- [BI-FIND-2021-0001](https://insights.bostonidentity.com/ref/BI-FIND-2021-0001): In CIBA, the one request parameter meant to be shown to the person is binding_message, and the spec designs it as a short code for matching two screens. It says the value SHOULD be relatively short, in a limited set of plain-text characters, and should let the user tell that the two devices belong to one transaction, "such as a random value of reasonable entropy (e.g. a transactional approval code)." Past that, the provider MUST obtain the person's authorization decision as OpenID Connect Core describes it. The spec defines no parameter for an action or an amount, though it lets extensions and profiles add parameters, and none of the tokens it defines carries the binding message back to the client. Several agent designs we have read cite CIBA for approving a specific action; we read that as needing a profile on top of the core spec. (from "CIBA's human-approval step carries a short matching code, not a description of the action")
- [BI-FIND-2023-0054](https://insights.bostonidentity.com/ref/BI-FIND-2023-0054): OpenID Connect Core gives an app one identifier it can rely on for a user: the iss and sub claims together. The sub value MUST be locally unique and never reassigned within the issuer, and it MUST NOT exceed 255 ASCII characters. Email, phone_number, preferred_username and name MUST NOT be used as unique identifiers, because an issuer may give one email address to different people over time and a person's address may change. When the app also calls the UserInfo endpoint, the sub returned there MUST exactly match the ID token's, or the response values MUST NOT be used. (from "OpenID Connect Core says only issuer plus subject identify a user; email must never be the key")
- [BI-FIND-2023-0060](https://insights.bostonidentity.com/ref/BI-FIND-2023-0060): Core's advice for browser and native apps sits apart from OAuth's later security guidance. Section 15.4 says the Implicit Flow "may be appropriate" for a public client, such as an app running in the browser or a statically registered native app. In that flow every token comes back from the authorization endpoint and the client cannot be authenticated; Core requires a nonce in that flow and defines an at_hash claim that ties a returned access token to the ID token. Core's text never mentions PKCE. Our briefing on RFC 9700, OAuth's security best current practice, found it telling clients to avoid the implicit grant, with an exception, and requiring public clients to use PKCE. (from "OpenID Connect Core says only issuer plus subject identify a user; email must never be the key")
- [BI-FIND-2025-0353](https://insights.bostonidentity.com/ref/BI-FIND-2025-0353): A client that can work with more than one authorization server is REQUIRED to defend against mix-up attacks. The attack assumes one of those servers is under the attacker's control, which the RFC says can happen, for example, when the attacker registers the client at their own server through dynamic registration, or when a server is compromised. In its walk-through the user picks the attacker's server, the attacker forwards the request to the honest server under the client's ID there, and the client, still believing the attacker's server answered, redeems the honest server's code at the attacker's token endpoint. Clients should check the iss parameter (RFC 9207) or an issuer value such as the ID Token's iss claim. Distinct redirect URIs per server also work, but the RFC says that defence "SHOULD therefore only be used if other options are not available". (from "RFC 9700 bans OAuth's password grant and loose redirect matching; binding access tokens stays a SHOULD")
- [BI-FIND-2023-0059](https://insights.bostonidentity.com/ref/BI-FIND-2023-0059): Core does not say how a sign-in ends. Its text mentions logout only in its references and in section 15.7's list of related optional specifications: RP-Initiated Logout, Session Management, Front-Channel Logout and Back-Channel Logout. Inside Core, the related rules are about token lifetime. Access tokens "might not be revocable by the Authorization Server", so their lifetimes SHOULD be kept to single use or very short. The provider MUST always obtain the user's consent before returning a refresh token for offline access, and an ID token issued on refresh keeps the original iss, sub and aud and, if present, the original auth_time. (from "OpenID Connect Core says only issuer plus subject identify a user; email must never be the key")

---

© 2026 Boston Identity LLC. All rights reserved. Published by Boston Identity LLC.
Quote up to 100 words with the credit "Boston Identity, IAM Insights" and a link to https://insights.bostonidentity.com/glossary/oidc. Claim numbers may be cited freely. Training, fine-tuning and text-and-data-mining use of this page is permitted.
Terms: https://insights.bostonidentity.com/terms · How to cite: https://insights.bostonidentity.com/cite
