Skip to content

Blog

What is OIDC (OpenID Connect)?

OIDC (OpenID Connect) is the login layer on top of OAuth 2.0. What it is, what an ID token holds, how a login runs, and where you already use it.

· 11 min read

OIDC, short for OpenID Connect, is a login standard built on top of OAuth 2.0. It lets an app send you to an identity provider such as Google or Microsoft, and get back a signed ID token that says who you are. Every "Sign in with Google" and "Sign in with Microsoft" button you have clicked runs on it.

The OpenID Foundation published OpenID Connect Core 1.0 in February 2014. The current text is OpenID Connect Core 1.0 incorporating errata set 2, dated 15 December 2023, and the same specifications were published as ISO/IEC standards in 2024 (Core is ISO/IEC 26131:2024). Below: how it relates to OAuth, what is inside an ID token, how a login runs, and what OIDC does not do for a company.

OIDC in one paragraph

An app (the spec calls it the relying party, because it relies on someone else's word) wants to know who you are without storing your password. It sends your browser to an OpenID provider, the service that holds your account: Google, Microsoft Entra ID, Okta, Apple. You sign in there. The provider sends the app an ID token, a small signed JSON document with your identity in it, and optionally an access token the app can use to fetch more profile details. The app checks the token's signature and logs you in. Your password never reaches it.

That is single sign-on: one account at the provider, accepted by every app that trusts it. What SSO is covers the idea in general, and what an identity provider is covers the provider's side, including whether you already have one.

OAuth vs OIDC

The two are constantly mixed up because OIDC is OAuth, plus one thing.

OAuth 2.0 (RFC 6749, 2012) is an authorization framework. It answers "may this app do X with this account?" When Zoom asks to read your Google Calendar, OAuth is what gives Zoom a scoped, revocable access token. The token says what Zoom may do. It does not, by itself, say who you are; for the app, the access token is meant to be opaque.

People used OAuth for login anyway, each provider in its own way, and that caused real security holes: an access token issued to one app could be replayed at another app that treated "I hold a token" as "I am this person". OpenID Connect fixed that by adding an identity layer to OAuth, made of three things.

The first is the openid scope. A request that includes it is an OIDC request; the spec says that without it, the behavior is entirely unspecified, which in practice means plain OAuth. The second is the ID token, a standard, signed statement of who the user is and which app it is for. The third is the UserInfo endpoint, a standard address where the app can ask for profile details such as name and email.

So OAuth is about access, OIDC is about identity, and OIDC uses OAuth's machinery to deliver it. Our SAML vs OAuth post covers the access side in more detail.

One more name trap: OpenID 2.0, from the late 2000s, is an older and unrelated protocol. If a guide talks about typing a URL as your identity, it means that one. OpenID Connect replaced it.

The ID token

The ID token is the heart of OIDC. It is a JSON Web Token (JWT, RFC 7519): three chunks of base64url-encoded text separated by dots, a header, a payload and a signature. Decoded, the payload looks like this:

{
  "iss": "https://accounts.google.com",
  "sub": "110169484474386276334",
  "aud": "1234987819200.apps.googleusercontent.com",
  "exp": 1793116800,
  "iat": 1793113200,
  "nonce": "n-0S6_WzA2Mj",
  "email": "[email protected]",
  "email_verified": true,
  "name": "Sam Lee"
}

The values are made up; the field names are real. Each field is called a claim. Five are required in every ID token:

ClaimMeansWhat the app must check
issIssuer: which provider made the token, as an https URLIt is the provider the app expects
subSubject: the user's ID at that provider, never reassignedUse it, with iss, as the stable user key
audAudience: which app the token is for (its client ID)It includes the app's own client ID
expExpiry timeIt has not passed
iatIssued-at timeIt is recent enough

Others are common: nonce, a random value the app sent with its request and expects back, which stops an attacker replaying an old token; auth_time, when the user actually signed in; acr and amr, how they signed in (for example with a password and a one-time code). Profile claims such as email and name appear when the app asks for the standard scopes email and profile; the other standard scopes are address and phone.

Two practical points trip up real apps. The signature has to be checked. The provider signs with a private key and publishes the matching public keys at its jwks_uri (a JSON Web Key Set). An app that decodes the payload without verifying the signature can be fooled by a forged token. And email is not an identity key. The spec says iss and sub together are the only claims an app can rely on as a stable identifier. Emails change and get reassigned. Apps that match users by email alone can end up handing an old account to a new person, which is a real risk in a small company that recycles addresses like sales@ or a departed employee's name.

How an OIDC login works

OIDC Core defines three flows. Which one an app uses is set by the response_type it asks for.

Authorization code flow

The authorization code flow (response_type=code) is the one to use, and the one most apps do use. It runs in six moves.

First, the app redirects your browser to the provider's authorization endpoint with its client ID, scope=openid email profile, a return address, a state value and a nonce. You sign in at the provider, with MFA if your account requires it, and approve the app if asked. The provider redirects your browser back to the app with a short-lived authorization code.

Then the app's server sends that code, with its client secret, straight to the provider's token endpoint, server to server. The provider replies with the ID token, an access token, and sometimes a refresh token. Finally, the app validates the ID token and starts its own session.

The tokens never pass through the browser's address bar, which is the point. Apps that cannot keep a secret, such as phone apps and single-page web apps, add PKCE (Proof Key for Code Exchange, RFC 7636): the app sends a hashed one-off value in the first redirect and proves it holds the original when it swaps the code, so a stolen code is useless.

The request can also say how fresh the login must be. The prompt parameter can ask the provider to show no login screen at all (none), to make the user sign in again (login), to ask for consent again (consent) or to let them pick an account (select_account). The max_age parameter sets how many seconds may have passed since the user last actively signed in; the spec notes that max_age=0 is the same as prompt=login. That is how a tool can demand a fresh login before something sensitive, such as changing billing details.

Implicit and hybrid flows

The implicit flow (response_type=id_token or id_token token) returns tokens directly in the browser redirect, with no code exchange. It was designed for browser-only apps before PKCE existed. The IETF's current OAuth security guidance, RFC 9700, says clients should not use the implicit grant for access tokens and that public clients must use PKCE. Treat implicit as legacy.

The hybrid flow (code id_token, code token or code id_token token) returns a code and some tokens at once. It is rare outside specific integrations.

Discovery: how apps find the provider

Setting up OIDC used to mean copying half a dozen URLs and keys. OpenID Connect Discovery 1.0 reduced it to one address. Every provider publishes a JSON document at its issuer URL plus /.well-known/openid-configuration.

Google's is at https://accounts.google.com/.well-known/openid-configuration. When we read it on 27 October 2026, it gave the issuer as https://accounts.google.com, the authorization endpoint as https://accounts.google.com/o/oauth2/v2/auth and the token endpoint as https://oauth2.googleapis.com/token. The UserInfo endpoint was https://openidconnect.googleapis.com/v1/userinfo, the signing keys were published at https://www.googleapis.com/oauth2/v3/certs, and the supported scopes included openid, email and profile.

That is why a tool's OIDC settings screen usually asks for just three things: the issuer (or discovery URL), a client ID and a client secret. The tool reads the rest. When the provider rotates its signing keys, the tool picks up the new ones from jwks_uri without anyone touching it, which is one of OIDC's quiet advantages over SAML's certificate swaps. What SAML is shows what the SAML version of that screen asks for.

Where you already use it

You probably use OIDC several times a week. "Sign in with Google" on Figma, Notion, Slack, Zoom and most newer software is OIDC. So is "Sign in with Microsoft" on tools aimed at Microsoft 365 companies, and "Sign in with Apple" in phone apps.

It also runs where you do not see a button. Developer and cloud tools log in through your company's identity provider with it, and CI systems swap OIDC tokens with cloud providers instead of storing long-lived keys.

Each time, the app gets an ID token about you from the provider, not your password. How SSO works follows one of those logins from click to session.

OIDC for workplace SSO

For a company, OIDC can do the same job as SAML: your identity provider becomes the single login for a tool, with your MFA rules and your list of people. Google Workspace, Microsoft Entra ID, Okta and JumpCloud all act as OpenID providers. SAML vs OIDC compares the two protocols side by side, and types of SSO puts both among the other things called SSO.

There is a difference between OIDC as a convenience and OIDC as enforced single sign-on.

As a convenience, the tool offers "Sign in with Google" to everyone. Your people can use it, and get Google's MFA, but they can also create a password account, and nothing stops a leaver who still has a session or a password.

Enforced means the tool requires everyone at your domain to log in through your identity provider. That is usually a setting on the tool's Business or Enterprise plan, whether the protocol behind it is OIDC or SAML. That upgrade is the SSO tax.

Free "Sign in with Google" plus strong MFA in Google Workspace gets a small team most of the everyday benefit. It does not get you a guarantee. Google Workspace SSO covers how far Google alone can take you.

Is OIDC secure?

Yes, when apps implement it properly. That means the authorization code flow with PKCE, verifying the token's signature, issuer, audience, expiry and nonce, and identifying users by iss and sub rather than email. Most real-world problems come from apps that skip one of those checks.

The other half is the login behind the token. An ID token only says that the provider checked someone. If the provider account has a weak password and no second factor, a perfectly valid token can name the wrong person's account. SSO vs MFA explains why the two belong together.

What it does not do

OIDC is a login protocol, and only that.

It does not create or remove accounts. A token says who someone is at the moment they log in. When someone leaves, nothing in OIDC tells the tool to delete their account or free their seat. That is provisioning, usually via SCIM (what SCIM is).

It does not end open sessions by itself. After login, the tool runs its own session. Logout signals between provider and app exist as separate OpenID specifications (front-channel and back-channel logout), and support for them varies from tool to tool.

It does not decide what someone can do inside the tool. Roles and permissions stay in each tool. And it does not make a weak account strong. The token is only as trustworthy as the login behind it.

Do small businesses need to care about OIDC?

Only a little. You will not write OIDC code or read the spec. What matters is the practical part: turn on "Sign in with Google" or "Sign in with Microsoft" wherever your tools offer it, enforce MFA on the work accounts behind it, and know that convenience login is not enforced login. If a customer contract names SSO, the question is which plan each tool needs, not which protocol.

Where SmashSSO fits

SmashSSO is not an OpenID provider and does not touch how people sign in. It does the account work OIDC leaves out: it reads your people from Google Workspace with read-only access, shows who has an account in each tool and with what role, adds new people by role through access bundles, and, when someone is suspended in Google Workspace, alerts you and shows where they still have access.

Changes run through a tool's member API where you have added a token, otherwise through an agent in your own Chrome, in tabs where you are already signed in as an admin. That browser has to be open, agent runs are slower than an API and can fail when a tool changes its screens, and some tools' terms restrict automated use. Any step that would add a paid seat waits for your approval, and every change is logged. It costs a flat fee from $199 a month, billed annually (pricing). If a contract needs enforced login through an identity provider, set up OIDC or SAML SSO for those tools; SmashSSO is for the access work around them.

FAQ

Is OIDC the same as OAuth?
No. OAuth 2.0 grants an app permission to access data, and does not say who the user is. OpenID Connect is built on top of OAuth and adds identity: the openid scope, a signed ID token and a standard UserInfo endpoint, so an app can log someone in.
What is an ID token?
A signed JSON Web Token that the identity provider gives the app after a login. It always includes the issuer, the user's ID at that issuer, the app it is meant for, an expiry time and an issue time, and often the user's email and name. The app must check its signature before trusting it.
Is OIDC secure?
Yes, when apps implement it properly: use the authorization code flow with PKCE, verify the token's signature, issuer, audience, expiry and nonce, and identify users by issuer and subject rather than email. Most problems come from apps that skip those checks, or from weak logins at the identity provider.
Do small businesses need to care about OIDC?
Only a little. Every "Sign in with Google" or "Sign in with Microsoft" button is OIDC, and using it with MFA on your work accounts is a free, useful step. Whether a tool lets you enforce it for everyone usually depends on its plan, not the protocol.

Keep reading

Stop paying for a login button.

Sign in with Google Workspace, connect your tools, and see who has access to what in minutes.

Sign up with Google