IBRAVRA Media Network
Software Reviews • 12 min read

OAuth 2.0 vs SAML vs OIDC: The Enterprise SSO Playbook — Protocols, the PKCE Fix, and the Per-User Bill

Every enterprise login runs on one of three protocols, and the wrong choice costs more than the licence: SAML is the legacy of the browser, OAuth 2.0 is authorisation without identity, and OIDC is OAuth with an identity token bolted on. This playbook compares the three on the wire, prices Okta, Auth0 and Microsoft Entra at 25, 100 and 500 users, and shows why the meter — per user, per MAU, or per bundle — decides the bill before the first login.

By Enow A. Jovial • Published 2026-11-16

Every enterprise login is a bet on a protocol, and most teams place the bet without reading the spec. A SaaS product that needs to connect to a customer's identity provider has three options: SAML 2.0, the XML federation standard from 2005; OAuth 2.0, the authorisation framework from 2012 that everyone mistakes for a login protocol; and OpenID Connect, which is OAuth 2.0 with an identity token added in 2014. The protocols do different jobs, they fail in different ways, and the vendors charge on different meters — per user, per monthly active user, or inside a bundle you may already own. Choose the protocol first and the vendor second: a vendor can be swapped in a quarter, but a protocol choice lives in every integration your customers build. Figures as read on November 16, 2026.

OAuth 2.0 authorises; it does not authenticate. OIDC adds the ID Token that proves who the user is, and SAML is the XML federation the enterprise installed base already runs. On price, the meter decides everything: Okta Starter at $6 per user per month is $600 a month at 100 users, Entra P1 at $7 is $700, and Auth0's published ladder is a flat $35 or $240 a month for up to 500 monthly active users — a different unit entirely. A buyer who compares the headline numbers without converting the units is comparing a taxi fare with a bus pass.

OAuth 2.0: authorisation, not identity

RFC 6749 defines four grant types, and the table of contents of the spec is the clearest statement of what OAuth does. The authorisation code grant (§ 4.1) is the web flow: the user authorises at the provider, the client receives a code, and the client exchanges the code for a token. The implicit grant (§ 4.2) returns the token directly in the redirect, which is why it is now deprecated in practice — the token travels through the browser. The resource owner password credentials grant (§ 4.3) has the client collect the user's password, which defeats the purpose of delegation. The client credentials grant (§ 4.4) is machine-to-machine, with no user at all. Section 1.4 defines the access token, which authorises the request, and § 1.5 defines the refresh token, which obtains a new access token when the old one expires.

Grant typeRFC 6749Who holds the passwordWhere the token goes
Authorisation code§ 4.1The provider onlyBack-channel exchange, never in the browser
Implicit§ 4.2The provider onlyIn the redirect fragment — visible to the browser
Resource owner password§ 4.3The client collects itBack-channel, but the client saw it
Client credentials§ 4.4Nobody — machine to machineBack-channel

None of these grants issues an identity assertion. An access token is an opaque string that says "the bearer may call this API". It does not say who the bearer is, when they authenticated, or how strongly. A product that accepts an access token as a login has confused a hall pass with an ID card, and the confusion is not theoretical: it is the single most common identity design error in production software, and it survives because the login appears to work right up until the failure: someone else's token replayed.

PKCE: the fix that should have been there from the start

The authorisation code grant has a hole on public clients — a mobile app or a single-page app that cannot keep a client secret. The code travels through the browser redirect, and anything that intercepts the redirect can redeem the code. RFC 7636 closes the hole with a proof key. The client creates a code_verifier, a high-entropy random string using the unreserved characters A–Z, a–z, 0–9, hyphen, period, underscore and tilde, with a minimum length of 43 characters and a maximum length of 128 characters, and sends a code_challenge derived from it with the authorisation request. With the S256 method, the challenge is:

extcodechallenge=extBASE64URL(extSHA256(extcodeverifier))ext{code_challenge} = ext{BASE64URL}( ext{SHA256}( ext{code_verifier}))

A stolen code is useless without the verifier, and the verifier never travels in the redirect. There is no honest reason to run the authorisation code flow without PKCE in 2026, on any client, public or confidential — and the vendors in the pricing section below all support it, so a product that ships without it has chosen to ship the hole.

OIDC: OAuth with an identity token

OpenID Connect Core 1.0 adds exactly one artefact to OAuth 2.0, and it is the artefact that makes login possible: the ID Token. It is a JSON Web Token that carries claims about the authentication event. The issuer identifier (iss) is a case-sensitive URL using the https scheme, with no query or fragment components. The subject (sub) identifies the user, the audience (aud) names the client the token was issued for, and expiry (exp) and issued-at (iat) bound the token in time. The nonce — a string value used to associate a client session with an ID Token and to mitigate replay attacks — is passed through unmodified from the Authentication Request to the ID Token, and clients MUST verify it when present. OIDC defines three flows in § 3: the authorisation code flow, the implicit flow, and the hybrid flow. The practical rule is the same as the PKCE rule: use the authorisation code flow with PKCE, and treat the implicit and hybrid flows as legacy compatibility, not as design choices for new work.

OpenID Connect Core 1.0: the table of contents — § 2 ID Token, § 3.1 authorisation code flow, § 3.2 implicit flow, and § 3.3 hybrid flow
OpenID Connect Core 1.0: the table of contents — § 2 ID Token, § 3.1 authorisation code flow, § 3.2 implicit flow, and § 3.3 hybrid flow

SAML: the XML federation the enterprise already runs

SAML 2.0 is older, heavier, and still unavoidable. The OASIS SAML V2.0 Core specification defines the structure of SAML assertions, the associated protocols, and the processing rules for managing a SAML system. Assertions and protocol messages are encoded in XML and use XML namespaces; they are typically embedded in other structures for transport, such as HTTP POST requests or XML-encoded SOAP messages. The service provider sends an AuthnRequest (§ 3.4.1), with a NameIDPolicy (§ 3.4.1.1) and Scoping (§ 3.4.1.2); the identity provider returns an assertion carrying a NameID (§ 2.2.3), optionally encrypted as an EncryptedID (§ 2.2.4). The whole exchange is XML, signed, and verbose — a single assertion can run to kilobytes where an OIDC ID Token runs to hundreds of bytes. That verbosity is the price of a standard designed for federations of universities, governments and banks, where the trust model is a signed document exchanged between institutions, not a token passed through a browser. SAML is the right answer exactly when the other side only speaks SAML, and the wrong answer whenever you get to choose.

AttributeOAuth 2.0OIDCSAML 2.0
JobAuthorisationAuthentication + authorisationFederated authentication
EncodingJSON / form-encodedJSON (JWT)XML, signed assertions
Identity artefactNoneID Token with iss, sub, aud, exp, iat, nonceAssertion with NameID
Mobile fitGood with PKCEGood with PKCEPoor — browser POST bindings
StandardRFC 6749 (IETF)OpenID Connect Core 1.0SAML V2.0 Core (OASIS)
Where it winsAPI delegationNew product loginLegacy enterprise federation

Our 1Password versus Bitwarden versus Dashlane password-manager playbook covers the credential storage underneath every SSO deployment; our Sentry versus Datadog error-tracking playbook covers the observability you need when the login flow breaks at 3 a.m.

Founder & CEO Insight — Enow A. Jovial

"The protocol decision is the one you cannot undo cheaply. A vendor can be replaced in a quarter — you export the users, you re-point the DNS, you move on. A protocol lives in every customer's integration guide, every support ticket, and every security review your enterprise buyers run. Pick OIDC with the authorisation code flow and PKCE, and SAML becomes a compatibility adapter you add for the one customer who demands it. Pick SAML first and you have chosen the most expensive integration surface in the building for every customer who comes after."
— Enow A. Jovial, Founder & Chief Executive Officer

The bill: three vendors, three meters

The protocol choice is technical. The vendor choice is arithmetic, and the arithmetic is treacherous because the three vendors meter different things. Okta meters per user per month. Auth0 meters per monthly active user, on a flat rate. Microsoft meters per user per month, but inside bundles most buyers already own. All figures below are from the vendors' own pricing pages, read on November 16, 2026.

Okta Workforce Identity publishes two prices. Starter is $6 per user per month and includes single sign-on, multi-factor authentication, Universal Directory, and 5 workflows. Essentials is $17 per user per month. Professional and Enterprise carry no price on the page at all — they are quote-only, and this article prints no estimate for them, because an invented Professional price would be worse than no price. Microsoft Entra ID P1 is $7.00 per user per month, paid yearly on an annual commitment, and P2 is $10.00 per user per month on the same terms; the Entra Suite is $12.00 per user per month and requires P1 underneath. P1 is included in Microsoft 365 E3 and Business Premium, and P2 is included in Microsoft 365 E5 — for a buyer already on E3 or E5, the incremental SSO cost is zero, and the standalone price is the wrong number to compare. Auth0's published ladder is different in kind: Free is $0 a month for up to 25,000 monthly active users, Essentials is $35 a month for up to 500 monthly active users, and Professional is $240 a month for up to 500 monthly active users. The plan table shows 1 enterprise connection on the lower tiers, and self-service SSO is listed as a new B2B feature — B2B SSO pricing itself is quoted, not published, so it is flagged quote-only here.

The monthly cost formula is the same for both per-user vendors:

extMonthlycost=extUsersimesextPriceperuserpermonthext{Monthly cost} = ext{Users} imes ext{Price per user per month}
UsersOkta Starter $6Okta Essentials $17Entra P1 $7Entra P2 $10
25$150/mo$425/mo$175/mo$250/mo
100$600/mo$1,700/mo$700/mo$1,000/mo
500$3,000/mo$8,500/mo$3,500/mo$5,000/mo
Annual at 100 users$7,200$20,400$8,400$12,000

The gap that matters most is inside a single vendor. At 100 users, the step from Okta Starter to Essentials costs:

ext{Annual gap} = ($17 - $6) 	imes 100 	imes 12 = $13,200

Thirteen thousand two hundred dollars a year for the automation tier — and the buyer who does not use the automation is paying it for nothing. Auth0's flat rate inverts the comparison: Essentials at $35 a month is $420 a year for up to 500 monthly active users, and Professional at $240 a month is $2,880 a year:

ext{Auth0 effective rate} = rac{$35}{500 	ext{MAU}} = $0.07 	ext{per MAU per month}

Seven cents per monthly active user per month — absurdly cheap next to $6 per user, until you remember the units differ. A monthly active user is a customer who logged in this month; a workforce user is an employee with an account whether they logged in or not. Auth0's ladder is customer identity pricing. Comparing it with Okta's workforce pricing without converting the units is the error this article exists to prevent. Run your own volumes through our pricing calculator before the first sales call, and get the quote in writing with the meter named in the contract.

Operator boundaries

Three limits bind this playbook. First, the Okta Professional and Enterprise prices are unpublished, so no total that includes them is printed anywhere here — a comparison that needs Professional is a sales conversation, not a calculation. Second, the Auth0 figures are the published B2C ladder; workforce B2B SSO is quoted separately, so the Auth0 column is a customer-identity comparison, not a workforce one, and the article says so rather than pretending the meters match. Third, the Entra figures are the displayed US list prices on an annual commitment; a monthly commitment, a nonprofit agreement, a government cloud, or a reseller channel can produce a different amount, and a buyer already on Microsoft 365 E3 or E5 already owns P1 or P2 — for them the incremental cost of SSO is zero.

Never use an OAuth 2.0 access token as proof of identity. The access token authorises API calls; it carries no identity assertion, no authentication timestamp, and no audience binding you can rely on for login. A system that treats the access token as a login token will accept any token minted for any purpose, and the breach will look like a legitimate login in every log you keep. If your login flow has no ID Token and no SAML assertion, it has no authentication — it has a hall pass.

Execution checklist

  • [x] Step 1: Name the protocol per customer: OIDC with the authorisation code flow and PKCE for every new integration; SAML only where the customer's identity provider is SAML-only.
  • [x] Step 2: Enforce PKCE on every authorisation code flow: code_verifier of 43 to 128 unreserved characters, S256 challenge, verifier presented at the token exchange. No PKCE, no ship.
  • [x] Step 3: Verify the ID Token, not just the access token: check iss, aud, exp, and the nonce against the request. A token that fails any of those checks is rejected.
  • [x] Step 4: Convert the meters before you compare prices: per-user for Okta and Entra, per-MAU for Auth0's published ladder, zero incremental for a buyer already on Microsoft 365 E3 or E5. Run the 25, 100 and 500-user totals for your own headcount.
  • [x] Check the bundle before you buy the standalone: Entra P1 rides inside E3 and Business Premium, P2 inside E5. Paying $7 a user for a licence you already own is the most common SSO overpayment.
  • [x] Put the enterprise-connection count in the contract: Auth0's lower tiers include 1 enterprise connection. The second SAML or OIDC connection is where the quote starts.
  • [x] Plan the SAML adapter as a separate workstream: one adapter, one test tenant, one customer at a time.