Integrations
Connect the stack
you already run.
ID Check Globe connects through published standards, so an integration is a protocol you can read rather than a connector you have to wait for. This page sets out the paths by platform category: your application stacks, the enterprise identity providers your customers bring, directories, cloud and machine platforms, credential wallets and verifiers, agent platforms, and the security layers next door that deliberately belong somewhere else.
How to read this
Integration paths, not a partner directory.
Everything below is a route into the platform described by the standard it runs on and the kind of system at the other end. That is deliberate, and it is the only version of this page a reader can check for themselves.
A protocol, not a partnership
Every path below is described by the standard it runs on. Nothing on this page states or implies a commercial relationship, a joint product or a vendor endorsement, in either direction.
Categories, not a connector catalogue
A platform category tells you how the connection is made and what you will be configuring. It is honest about work you still own, which a shipped-connector list tends to hide.
The same standards everywhere
Connections are built on the standards listed on the developer portal — OpenID Connect, OAuth 2.0, SAML 2.0, SCIM, JWT and the credential specifications. There is no proprietary connection protocol here to learn.
What this page does not claim
Naming a technology is not the same as claiming a relationship with its vendor.
- No partnerships. Naming a technology here says a developer can integrate with it over a published standard. It says nothing about a commercial agreement, a reseller arrangement or a joint roadmap.
- No certification or conformance. Building on a specification and being audited against it are different things, and only the second would be worth claiming. We build on these standards; we do not claim to be certified against them.
- No turnkey connector list. Where a connection needs configuration, mapping decisions or a profile agreed between two implementations, this page says so instead of describing it as switched on.
There are no third-party logos on this page for the same reason. What we will do is walk a specific connection with you: tell us what you need to connect and we will tell you which protocol it uses, what we have built against it, and which part would be new work.
Category one
Frontend and backend stacks.
The first integration is always in your own codebase. Every stack below connects the same way: an OpenID Connect authorization code flow with PKCE for interactive sign-in, and signed-token verification on the server against a published key set. The framework changes where the code goes, not what the protocol does.
7 integration paths
Next.js
A route handler for the callback, middleware for the session check, and server components that read an already-verified session rather than re-parsing a token on every render. Static marketing routes stay static; only the authenticated surface needs a request.
React and single-page apps
Authorization code with PKCE in the browser and no client secret anywhere in the bundle. Where you would rather not own the login screen at all, the hosted experience takes the flow and hands your app a verified session back.
Node.js and TypeScript
Verify ID and access tokens against the JWKS endpoint, cache the key set, and keep your own session record on your side of the boundary. Typed token claims make a mapping mistake a build error rather than a production surprise.
Python
Server-side flows for web applications and background services, token verification in the request path, and webhook receivers that check the signature before they trust the payload. Suited to data and workflow services that authenticate as themselves.
Java and the JVM
Confidential-client flows with a client secret or a signed client assertion, JWKS-based validation in a filter or interceptor, and key rollover handled by refetching the key set rather than by a redeploy.
.NET
Standard OpenID Connect middleware against the discovery document, cookie or token-based sessions as your architecture prefers, and the same per-environment client registration as every other stack.
iOS, Android and cross-platform mobile
Native flows run in the system browser rather than an embedded web view, so platform passkeys and the device credential store are available to the user. Refresh handling and logout are explicit, because a mobile session outlives the screen it started on.
Protocols and interfaces
OpenID ConnectOAuth 2.0 + PKCEJWT / JWKS verificationWebAuthn / FIDO2Signed webhooksAn honest note
Nothing in this flow is framework-specific. If a library in your language implements OpenID Connect and can verify a JWT against a published key set, it can complete these flows — including languages not named above. The developer portal sets out the shape of each flow, the discovery endpoints and how tokens are verified.
Category two
Enterprise identity providers.
Your business customers already have an identity provider and will not change it for you. A connection is configured per tenant and per customer organization, over the two protocols enterprise federation actually runs on — so each new customer is configuration rather than an integration project.
6 integration paths
OpenID Connect connections
Point the connection at the provider discovery document, agree the claims you need, and let metadata refresh pick up their key rotations. The connection belongs to an organization, so two customers using the same provider stay separate.
SAML 2.0 connections
Exchange metadata, agree the signing certificate and the attribute names, and keep the assertion consumer configuration in one place rather than in every application. Still how a large share of enterprise SSO reaches a vendor.
Organization-aware routing
Discovery by verified email domain or an explicit organization choice, so a sign-in lands on the right enterprise connection without each application knowing the full provider list.
Claims mapping and identity linking
Map provider attributes onto the identity record deliberately. Accounts are linked on purpose, with evidence, rather than merged silently because two records happened to share an address.
Metadata and key rollover
Signing certificates expire, usually at an inconvenient moment. Federation metadata and key rollover are scheduled operations here, with the overlap window that makes them uneventful.
Social and consumer providers
External OpenID Connect providers for consumer sign-in sit on the same federation machinery, with account linking and a first-party profile that survives a user switching provider.
Protocols and interfaces
OpenID Connect discoverySAML 2.0 metadataSigned SAML assertionsJWT / JOSE / JWKAn honest note
This category is described by protocol rather than by vendor name on purpose. Connecting any provider that publishes OpenID Connect discovery metadata or exchanges SAML 2.0 metadata is the same piece of configuration work; listing vendors would imply a tested and supported connector for each one, which is a different promise. Tell us which provider a customer runs and we will walk the specific connection with you.
Category three
Directories and provisioning, over SCIM.
Federation gets a person in at sign-in. Provisioning keeps the records aligned in between — which is the half that decides whether a leaver still has an account next month. SCIM 2.0 is the interface in both directions.
6 integration paths
SCIM 2.0 as the server
A customer directory creates, updates and deactivates users and groups against a SCIM endpoint scoped to their organization. Their IT team drives it with the tooling they already use.
SCIM 2.0 as the client
Push lifecycle changes out to downstream applications that expose a SCIM endpoint of their own, so an account closed in one place closes everywhere it was propagated.
Import and reconciliation
A first import is rarely clean. Reconciliation reports what matched, what did not and what was ambiguous, instead of resolving it quietly and leaving you to find out later.
Attribute transformation
Two systems will disagree about what a field is called and what belongs in it. Mapping and transformation are explicit configuration, visible at the point where the disagreement actually lives.
Lifecycle events
Joiner, mover and leaver events are published as signed webhooks as they happen, so your own systems can act on them rather than polling for a change they already missed.
Deprovisioning that propagates
Removal is the operation everyone tests least and needs most. Deprovisioning records where it reached and what it could not reach, which is the only version of that report worth having.
Protocols and interfaces
SCIM 2.0Signed lifecycle webhooksREST APIsCategory four
Cloud and machine platforms.
A workload that can already obtain a signed token from the platform it runs on does not need a shared secret from you. Exchange that platform token for a short-lived credential bound to a tenant, an environment and a deployment, and the static key in a repository stops being necessary.
6 integration paths
Workload identity federation
A cloud platform whose workloads can request a signed OIDC token from the platform itself becomes a trusted issuer for a token exchange. The workload proves where it is running; it carries no long-lived secret to be leaked.
Containers and orchestrators
Kubernetes projected service account tokens, or an equivalent orchestrator-issued credential, exchanged at startup for a workload identity scoped to the namespace and environment the pod actually belongs to.
CI/CD pipelines
A pipeline that can mint an OIDC token for a job authenticates as that job rather than as a long-lived deploy key. Credentials expire with the run, so a leaked log line stops being a standing risk.
Serverless and scheduled jobs
Short-lived functions and cron workloads authenticate per invocation with client credentials or a signed client assertion, which suits a principal that exists for a few hundred milliseconds.
Service-to-service calls
Signed JWT client assertions and mTLS-compatible approaches for internal and partner APIs, so the receiving service can establish which caller it is talking to before it does any work.
Connected devices and fleets
Enrollment with identity certificates, hardware-backed keys where the device provides them, and a credential lifecycle that reaches retirement — the stage device fleets usually leave unfinished.
Protocols and interfaces
OAuth 2.0 client credentialsOAuth 2.0 token exchangeSigned JWT client assertionsmTLSX.509 certificatesAn honest note
Cloud platforms are described by capability here rather than by name: what matters is whether the platform can issue a workload a signed, verifiable token about its own identity. If it can, the exchange works the same way. If it cannot, the fallback is a registered key pair and a signed challenge, and we would rather say that in a conversation than imply a one-click integration.
Category five
Credential wallets and verifiers.
A credential is only useful if somebody else can check it. The issuance and presentation protocols below are what let a holder carry a signed claim away from the system that issued it, and let a verifier validate it without calling you.
6 integration paths
Issuance to a wallet
OpenID4VCI takes a verified fact and issues it as a signed credential a holder can keep. The issuer identity, the schema and the validity period are part of the credential, not a note in a database.
Presentation and verification
OpenID4VP carries a presentation request to the holder and the response back to a verifier, which checks the signature, the issuer, the key state and the status before relying on anything.
Credential formats and schemas
W3C Verifiable Credentials data model with defined credential types, so two parties agree in advance what a field means rather than inferring it from its name.
Status and revocation
A credential that was valid last year proves nothing about today. Status checking is part of the verification path, with revocation that a verifier can confirm independently.
Decentralized identifiers
DID resolution for issuer and holder keys across the methods we support, with controller verification, so a key can be checked without a central directory in the middle.
Trust registries and issuer discovery
Verification is only as good as the answer to who you trust to issue. Issuer trust lists and registry lookups make that decision explicit configuration rather than an assumption in code.
Protocols and interfaces
OpenID4VCIOpenID4VPW3C Verifiable CredentialsDID CoreCredential status listsAn honest note
Interoperability in this area is real but uneven: two implementations of the same specification can still disagree about an optional profile, a signature suite or a disclosure format. So a wallet is never described here as supported. We will tell you which profiles a given exchange depends on, and test the pair you actually need rather than publish a compatibility badge.
Category six
Agent platforms, via adapters.
An AI agent authenticates much as a workload does: a registered public key, a signed challenge, a short-lived credential. What is different is that the interesting question is usually about the operator — which organization stands behind this agent, and can another company check that independently.
6 integration paths
Agent frameworks and runtimes
An agent built in any framework registers a public key against an identity record and proves possession when it calls. No framework integration is required for that, which is the point of keeping identity outside the runtime.
Agent registries and directories
Publish a verifiable identity record — identifier, keys, operator relationship, credential status — so a platform that discovers your agent can check who operates it rather than reading a name.
Agent-to-agent calls
Mutual identity verification before either side relies on the other, with both presenting credentials that the receiving system can validate against an issuer it already trusts.
Delegation evidence in transit
Signed, scoped, time-limited delegation travels with the call, so a receiving system can verify that an agent represents the organization it claims to represent — instead of accepting an assertion made in a prompt.
Operator and key lifecycle
Rotation, suspension and revocation of agent keys, published so the platforms that were relying on an agent can find out that they should stop.
Evidence for review afterwards
Agent enrollment, key changes, credential presentations and revocations land in the identity event trail, which is what an investigation needs when an agent did something surprising.
Protocols and interfaces
OAuth 2.0 token exchangeSigned JWT client assertionsW3C Verifiable CredentialsDID CoreProof of key possessionAn honest note
Adapters, and the word is deliberate. Agent identity specifications are still being written, and registries in this space are emerging rather than settled. Where one exists we build an adapter and say which version it follows; we do not claim conformance to a specification that has not stabilised, and we do not list agent platforms as partners. Running, orchestrating and distributing agents belongs to an agent platform. What belongs here is the identity another organization has to be able to verify.
Category seven
Security and infrastructure layers.
These are the neighbours. Each one is written as a capability rather than a product name, because your architecture may put two of them in one system or spread one across three — and because naming a product would turn an honest boundary into an advertisement.
6 integration paths
An authorization layer
Identity leaves here as a verified principal with the claims you asked for. Whether that principal may perform a particular action is decided by your application or by a dedicated authorization layer that holds the policy. The integration is the token and its claims; the decision is not ours to make.
An API gateway or edge layer
A gateway can verify tokens at the edge against the published key set, with no call back to us. Rate limiting, quotas, schema validation and threat detection on that request stay with the gateway, where the traffic is.
A secrets management platform
The credentials that establish identity have their lifecycle here. Database passwords, encryption material and third-party API keys belong in a secrets manager — a distinction worth keeping, because the two have different blast radii.
A log, SIEM or event pipeline
Identity events leave as signed webhooks and as exports, so your detection and retention tooling stays the system of record for correlation across everything else your estate emits.
A fraud or bot-detection layer
Risk signals can inform one decision on our side: whether to ask for more evidence before accepting that this is the principal it claims to be. Scoring a transaction or blocking traffic is a different job, done elsewhere.
A device management layer
Device posture, patch state and compliance come from your endpoint management. What this platform holds is the device identity and its credentials, which is the part another system needs to be able to check.
Protocols and interfaces
JWKS token verificationSigned webhooksREST APIsEvent exportAn honest note
Every item above is a capability you own somewhere else, and that is the correct arrangement rather than a gap. The integration point is the same in each case: a verified identity with claims, a signed event stream, and a published key set that anything can validate a token against.
In practice
How a connection is actually built.
Four steps, in this order, whichever category you came from. They are the same four whether the thing at the other end is a mobile app, a customer identity provider, a Kubernetes workload or a wallet.
01
Start from the standard
Find the flow your case needs and read the specification behind it. The developer portal lists the standards each flow uses, so the first hour is spent on a protocol rather than on reverse-engineering a connector.
02
Register the connection
An application client, an enterprise connection, a SCIM endpoint or a workload principal, created in one environment. Development, staging and production hold their own, so nothing you test can mint a token production will accept.
03
Verify on your side
Fetch the key set from the discovery endpoint, cache it, and validate signature, issuer, audience and expiry in your own code or at your gateway. Verification that depends on calling us is verification that fails when a network does.
04
Watch what it emits
Subscribe to the events the connection produces, check the webhook signature before trusting a payload, and send the stream to the tooling where the rest of your estate is already correlated.
What a connection carries
Identity, not permission.
Every integration on this page ends in the same place: a verified statement about who or what made a request, with the claims you asked for and a signature anything can check. That is authentication.
Whether that principal may then perform a particular action is an authorization decision, made by the consuming application or by a dedicated authorization layer that holds your policy. No connector here changes that, and no claim on this site suggests otherwise. The platform page sets out all three boundaries.
Before you commit to an architecture.
Most integration pain is decided in the first week: which system owns the session, where tokens are verified, how an environment is separated, who rotates what. Those are cheap conversations now and expensive migrations later.
Pricing follows the same honest structure as this page — packages for the platform services and metered usage for verification and credential work, with the numbers set against what you actually need.
One set of standards
Every connection is built on these.
There is no proprietary connection protocol to learn. The standards listed on the developer portal are the whole surface, with a link to each specification so you can read what we are building against rather than take our word for the behaviour.
Standards this platform builds on
- OpenID Connect
- OAuth 2.0
- WebAuthn / FIDO2
- SAML 2.0
- SCIM 2.0
- JWT / JOSE / JWK
- mTLS and client assertions
- W3C Verifiable Credentials
- DID Core
- OpenID4VCI / OpenID4VP
- FAPI 2.0
- NIST SP 800-63-4
Building on a specification is not the same as being certified against it. These are the standards the platform is designed around, not accreditations, and nothing on this page should be read as a conformance claim.
Tell us what you need to connect.
Bring the stack, the identity provider your largest customer insists on, the workload that still holds a shared key, or the credential nobody outside your company can check. We will tell you the protocol, the work involved and the part that belongs in your application.
Identity for everyone. Trust for everything.