Skip to content

Trust centre

Detail you can check,
instead of badges.

This page describes how ID Check Globe is built, what we commit to, and where the platform stops. It carries no certification logos, no uptime figure, no audit opinion and no customer names, because each of those would claim more than we can show — and a trust page that overstates the easy things is not worth reading on the hard ones.

What follows is architecture, commitments, and the limits of each. Where the honest answer is that we do not publish something, the page says so in the same words we would use to your security team.

Ground rules

What this page carries instead.

Six things a trust centre in this category normally shows, what each would be worth here, and what sits in its place. Every substitute is something you can read, test or ask us for today.

A certification badge

The standards the platform is designed around, each with a note on what it is used for. Designing against a specification and being audited against it are different things, and we never print the first as though it were the second.

The standards list
An uptime percentage

The resilience architecture, described below, and a plain statement that published operational status follows measured service levels rather than preceding them.

Availability and resilience
Customer logos and case studies

The architecture, the boundaries and the commitments — all of which you can test against the APIs, the documentation and the agreement, none of which depend on taking our word for who else is here.

The architecture
An audit opinion

The records that would make an audit possible, held in a form a reviewer can export and check, and an honest note that this page is not a substitute for one.

Auditability
A penetration-test summary

A responsible-disclosure route that is open now, and a statement of which properties — tenant isolation first among them — we most want to be challenged on.

Reporting a vulnerability
A compliance claim

The data-protection roles taken in a normal deployment, the privacy notice that binds us, and a current subprocessor list on request. No adjective in front of the word compliant.

Privacy notice

Architecture

Secure authentication, by construction.

The properties below hold because of where they sit in the architecture, not because a checklist was completed once. Each is a decision a reviewer can interrogate, and several of them are visible from outside the platform.

What is stored cannot be used to sign in

A passkey leaves a public key with us and nothing else. Where a password still exists it is stored as a salted, memory-hard one-way derivation, so the stored value is not something an attacker can present back to us as a login. Credential material is never written to logs, events or exports.

Phishing resistance comes from the protocol

WebAuthn assertions are bound by the browser to the origin that requested them, so a passkey registered for your domain does not sign anything for a look-alike one. That property belongs to the specification rather than to a heuristic we maintain, which is exactly why it is the default we steer customers towards.

Tokens are signed, scoped and short-lived

ID tokens and access tokens are signed with keys published at a discovery endpoint, so a service verifies one locally by checking the signature, the issuer, the audience and the key identifier. Lifetimes, refresh behaviour and rotation are set per issuance profile rather than per application by hand.

Secure defaults, not secure options

Authorization code with PKCE for interactive flows. Exact-match redirect URIs, with no wildcard host patterns. Separate client credentials per environment. A security property that depends on someone remembering to switch it on is not a property of the system; it is a property of that person's afternoon.

Encryption in transit and at rest

Current TLS for every connection to the APIs and hosted flows, and encryption at rest for identity records, verification evidence and key material. Evidence is stored separately from the outcomes derived from it, which matters for retention as much as for security.

Reauthentication is treated as evidence, not friction

Risk signals — a new device, an unfamiliar pattern — feed one decision: whether the existing session is still sufficient evidence that this is the principal it claims to be. Asking for another factor is an authentication decision. Deciding what the principal may then do is not ours to make.

The line we hold

What the handover actually contains.

At the end of a flow your application receives a verified principal and the claims you asked for, signed, with a record of how that principal proved itself. That is the whole of what we assert.

We will never tell you that a request is allowed. Whether this principal may perform this action is decided by the consuming application or by a separate authorization layer holding your policy, using our output as one input. A platform that claimed both halves would have to be vague about each, and the vagueness always surfaces in the incident rather than in the brochure.

Where the platform stops

What this website is, and is not.

The site you are reading is statically rendered. It holds no credentials, stores no identity record, issues no token and calls no control plane. It cannot grant or revoke access for anyone, and it keeps serving when every product host is unavailable — which is why the instructions for reporting a problem stay readable during an incident.

The identity service is a separate system reached at https://api.idcheckglobe.com and https://app.idcheckglobe.com. Treating the two as one thing would be the most misleading simplification this site could make, so the legal pages state the separation as well.

Privacy

Minimization is a data-model decision.

Privacy that lives only in a policy document is a promise about intentions. The lists below are the version that holds: what the platform keeps because a purpose requires it, and what it does not take in the first place.

Held, because the purpose requires it

  • Identifiers and the attributes an application asked for, per tenant
  • Registered factors and keys, with their enrolment and revocation state
  • Authentication, session and credential events, with their outcome
  • Verification outcomes, with the method and the time they were produced
  • Configuration and administrative changes, with the account that made them

Retention is configured per tenant against the purpose the data serves. Keeping identity evidence longer than a purpose justifies is not thoroughness; it is an unpriced liability sitting in a database.

Not taken, or not kept

  • Source documents and biometric samples kept beyond the purpose that justified capturing them
  • Identity records used to build advertising or behavioural profiles
  • Attributes an application never asked for, collected in case they become useful later
  • Anything personal written to a public ledger — the anchoring design publishes cryptographic commitments only
  • Customer identity records sold, shared for another party's purposes, or used to train models

Stated as commitments, because that is what they are. The privacy notice is the document that binds us, and where it differs in detail from this page, the notice is the one to read.

Who controls what, in a normal deployment.

In most deployments the customer decides what identity data is collected and why, and we process it under instructions from that customer — which means a request from one of your end users to see, correct or delete their data is answered by you, with our APIs and our support behind you. Where we hold data for our own purposes, such as the account of an administrator who signed up directly, we are responsible for it and the privacy notice says so.

Evidence has a shorter life than the outcome.

A verification session produces two different things: the evidence it examined, and the signed outcome a relying party consumes. The platform stores them separately so the evidence can be discarded on its own schedule while the outcome stays checkable. It is the single most useful structural decision on this page, and the reason a verifiable credential does not have to carry a copy of a passport around your systems.

Isolation

One tenant cannot reach another.

Isolation is the property that multi-tenant identity stands or falls on, so it is enforced by the shape of the data rather than by the discipline of each endpoint. These are the four mechanisms that make the claim mean something.

The tenant is the outermost boundary

Every identity record, application, connection, signing key and event belongs to exactly one tenant and inherits that boundary rather than carrying its own. Scoping happens at the data layer, so an endpoint cannot leak across a tenant edge by forgetting a filter.

Environments are separate inside a tenant

Development, staging and production hold their own clients, secrets, signing keys, connections and webhook endpoints. A token minted in a test environment does not verify against the production issuer, which is the only version of that promise worth making.

Crossing an edge is a configured, recorded act

Federation connections, organization links and delegation relationships are the only paths between boundaries, each one explicitly configured. The configuration change itself is an event with an actor and a timestamp, so the question of when a boundary was opened has an answer.

Administrative access is scoped and recorded

Customer administrators act within one tenant. Internal access to production identity data is designed around named accounts, least privilege and a recorded reason, rather than standing access that nobody has to justify.

Tenant isolation is also the property we most want to be challenged on, which is the practical purpose of the disclosure route below. The architecture is described in full on the platform page, and the tenancy model itself is a service in the catalogue.

Keys

Every key has a beginning, a rotation and an end.

Signing keys are what make a token worth trusting, so their lifecycle is run as an ordinary scheduled operation rather than as an incident. The stages are in order because the order is itself the control.

01

Generate

Keys are generated inside the managed boundary that will use them. Private material is not displayed after creation, not exported, and not recoverable by support — a key you can be sent is a key someone else can be sent.

02

Separate by purpose

Token signing keys, record encryption keys and transport certificates are distinct, with distinct lifecycles. One key doing several jobs means one rotation touching several blast radii at once.

03

Publish and bind

Public key material is published at a discovery endpoint for verifiers. Each key is bound to a tenant and an environment, so verification answers the question it looks like it is answering.

04

Rotate

Overlapping validity windows let a new key be accepted before the old one stops being honoured, which makes rotation a scheduled operation rather than a release coordinated across every consuming application.

05

Revoke

Revocation is immediate, recorded, and checkable by whoever was relying on the key. A verifier that cached a key needs to be able to find out that it should stop trusting it.

06

Retire

The record outlives the key. What a retired key signed, and when, is a question that arrives months later and deserves an answer better than silence.

Scope of this lifecycle

This covers the keys and credentials that establish identity: passkeys, client secrets, signing keys, device certificates and agent keys, each tied to the principal that controls it. General-purpose secrets storage for everything else your systems hold — database passwords, third-party API keys, your own encryption material — stays with a secrets management and infrastructure platform.

Assurance

What a verification outcome is worth.

A verification result is a dated statement that a named method was applied to particular evidence and reached a particular conclusion. Being precise about that is more useful to a risk team than any adjective we could put in front of the word verified.

What every outcome carries.

  • The method applied, named rather than summarised as a score
  • The kinds of evidence examined, and the issuer or source of each
  • The time the outcome was produced, and any validity period attached to it
  • The result, with the strength of the process expressed in a published assurance vocabulary rather than as an invented score
  • A reference to the evidence record, which is stored separately and retained separately

Six limits, stated plainly

It is a statement about evidence, not a fact about a person
An outcome says that a named method was applied to particular evidence and produced a particular result. It does not say that the platform knows who someone is.
It describes the moment it was produced
Documents expire, addresses change, company officers resign, and businesses are restructured. Every outcome carries the time and method that produced it precisely so that a reader can judge how stale it is.
It can be wrong in both directions
A genuine person can fail a check and a determined fraud can pass one. A workflow built on a single boolean has no answer for either case, which is why review and appeal paths belong in the design rather than in the support queue.
It is not an authorization
A verified identity is an input to a permission decision, never the decision itself. Whether this principal may open this account, move this money or call this API is evaluated by the consuming application or a separate authorization layer that holds the policy.
Using an assurance vocabulary is not accreditation against it
Published reference models give the industry a shared language for proofing strength, and the platform uses that language so an architect can reason about a flow. Speaking a standard's vocabulary is not the same as having been assessed against it, and we do not present it as though it were.
An outcome is checked again, not remembered
Credentials carry status, expiry and revocation. A presentation is validated against the issuer and the current status at the moment of use, because an old result proves what was true then and nothing about what is true now.

Availability

The resilience architecture, without a number attached.

Identity sits in front of everything else, so an identity outage is every outage. These are the architectural decisions that follow from that. They are design, not measurement, and the panel beside them says what that distinction costs.

  • Authentication nodes hold no session state of their own, so capacity is added or replaced without draining anyone's logins
  • The control plane is separated from the authentication path: a configuration change, or an outage in the administrative surface, is designed not to stop sign-ins that are already configured
  • Token verification works from published keys, so a service that cached the discovery document can keep verifying tokens it already holds
  • Tenant and environment boundaries contain a failure to the configuration that caused it rather than spreading it across the platform
  • Regional deployment where it is supported, so identity records can stay in a region a customer has to keep them in
  • Backups are taken and restores are exercised, because a backup nobody has restored is an untested assumption

Operational commitments for a specific deployment — what is monitored, what is escalated, what is agreed in writing — are part of an enterprise conversation and of the agreement that follows it, which is where a commitment can be made to a particular architecture rather than to a web page.

Responsible disclosure

Found something? Tell us directly.

A reporting route that is easy to find and answered by a person is worth more than a published test report. If you believe you have found a vulnerability in the identity service, the hosted flows, the SDKs or this website, write to the security address below.

Security contact

security@idcheckglobe.com

Include what you found, where you found it, and the steps to reproduce it — a request and response pair, or a short script, saves everyone a round trip. Tell us if you believe the finding exposes data belonging to anyone else, and say so in the first message if you need a secure channel rather than ordinary email; we will arrange one before you send anything sensitive.

We do not run a paid bounty programme today. If that changes it will be stated here rather than implied, and we would rather hear about a finding now than have it wait for a programme that does not exist yet.

In scope

  • The identity service at https://api.idcheckglobe.com and https://app.idcheckglobe.com
  • This website, idcheckglobe.com
  • The hosted authentication flows and the published SDKs

Please do not

  • Run denial-of-service, stress or load tests against any host
  • Social-engineer staff, customers or end users, or attempt physical access
  • Access, modify or retain data belonging to a tenant that is not yours — use a sandbox tenant and your own test accounts
  • Run automated scanning that degrades the service for other people

What we commit to in return

  • We acknowledge every report that reaches the security address, and we keep the reporter informed as triage proceeds
  • We say plainly when a report is a duplicate, out of scope, or something we have decided not to change — and why
  • We credit reporters who want to be credited, and respect the ones who do not
  • We will not pursue or support legal action against good-faith research that follows the boundaries above
  • If a finding affects customer identity data, affected customers are told what happened and what it means for them

We do not publish a response-time target. A number with no measured history behind it tells a reporter nothing, and we would rather be judged on the acknowledgement you actually receive. Reports about this website and reports about the identity service reach the same address, and have very different consequences: this site holds no credentials and no identity records.

Subprocessors

Who else touches the data, and where.

Running an identity service means engaging other processors. The question a reviewer needs answered is which ones, for what, in which region — and how they find out when that changes.

A current list, provided rather than published

The subprocessor list names each processor, what it processes, the purpose it serves and where the processing happens. It is maintained for the agreement and provided to customers and to prospective customers who ask. A page of logos on a marketing site goes stale quietly, and a stale list is worse than no list because it reads as current.

Categories, not surprises

Processing in the authentication path involves infrastructure and hosting, communications delivery for messages a flow sends, and specialist verification providers where a check requires one. Nothing outside those categories enters the path without the same written terms and the same entry in the list.

Terms that travel down the chain

Every processor is bound by written terms, with confidentiality, security obligations and limits on what it may do with the data, that are no less protective than the obligations we take on. A processor is engaged for a named purpose, not given general access.

Changes announced before they happen

A material change to the subprocessor list is notified in advance under the agreement, so a customer has the opportunity to raise an objection while it is still a proposal rather than a fact.

Transfers with a basis, named in the same place

Where personal data crosses a border, the transfer rests on a documented lawful basis with contractual safeguards, and the destination appears in the subprocessor list alongside everything else. Where regional deployment is supported, keeping records in a region is a configuration choice rather than a negotiation.

What you can do today

Ask for the current subprocessor list and the transfer detail for the regions you care about. A security or procurement review is a conversation we would rather have early than at the end of a trial.

Auditability

The records are the same records, before and after.

Each layer of the platform writes a signed record of what it did. Those are the operational picture while something is happening and the evidence afterwards — and they are one set of records either way, because a log assembled after the fact is evidence of nothing.

  • Authentication attempts, factor challenges, session creation and termination, each with its outcome
  • Credential enrolment, binding, rotation, revocation and expiry
  • Verification outcomes, stored apart from the source evidence they were derived from
  • Directory, organization and delegation lifecycle changes
  • Configuration changes to tenants, applications, connections and keys, with the actor that made them

Events reach your systems as signed webhooks and leave the platform as exports when a review or an investigation needs them. Retention and privacy controls are set per tenant, so the trail is kept as long as its purpose justifies and no longer.

Privacy by design

Six principles the rest of this page serves.

These are the commitments every design decision above is measured against. They are last rather than first because a reader who has come this far already knows what each one costs to keep.

01

Nothing personal goes on a public ledger

Passports and other identity documents, biometric samples, secret keys and personal account data are never written to a public ledger. Where anchoring is used it publishes cryptographic commitments — values that let a holder prove a record existed and has not changed — and nothing that can be read back as a person.

02

Store only what the purpose needs

Each attribute, document and event exists because a stated purpose requires it, and retention is set against that purpose rather than against the storage being cheap. Deletion and export are ordinary operations with a path through the APIs, not exceptions handled by a favour.

03

Separate the source evidence from the issued outcome

The document image, the sample and the provider response are one record; the signed outcome a relying party consumes is another. Keeping them apart lets the evidence be discarded on its own schedule while the outcome remains checkable, and stops a verification result from carrying a copy of someone's passport around your systems.

04

Make verification proportionate to risk and legal basis

The strength of a check is matched to what is actually at stake and to the basis a customer has for performing it. Proofing everyone to the highest available assurance is not caution; it is collecting sensitive evidence that no purpose called for, which is its own risk and its own liability.

05

Present expiry and revocation where they can be seen

Credentials and anchors carry status and validity, and a presentation is checked against them at the moment of use. An expired credential, a revoked key and an old anchor each prove something historical. None of them proves current authorization, and a design that lets a reader forget that is a design with a hole in it.

06

Hold the authentication line in the data model too

The platform records who or what proved itself, with what evidence and when. It does not record, infer or store a judgment about whether an action should be permitted — that decision, and the data behind it, belongs to the consuming application or to a separate authorization layer.

Each of the six is testable against the product rather than against our good intentions: read the architecture, check the API design, and tell us where the design and the principle disagree. That is a more useful conversation than a questionnaire.

Questions

Asked most often by security reviewers.

What is the difference between authentication and authorization?

Authentication establishes who or what is making a request. Authorization determines whether that authenticated principal may perform a particular action. ID Check Globe focuses on the first. The second belongs to your application or to a dedicated authorization layer, and we are deliberate about not blurring the two.

Is blockchain required?

No. Most authentication is handled through ordinary cryptographic protocols. Anchoring is an optional mechanism for independently verifying historical record commitments.

Does a public ledger prove that someone is a real person?

Not by itself. Real-world identity claims require appropriate verification and trustworthy issuers. Anchoring helps protect the integrity of stored evidence; it says nothing about the truth of the claim.

Do you store private identity data on public ledgers?

No. The anchoring design keeps private identity records off-chain and publishes only cryptographic commitments where used. Passports, biometrics, keys and personal account data are never written to a public ledger.

Ask us the awkward questions.

Isolation, key lifecycle, retention, transfers, the limits of a verification outcome — these are easier to settle in a conversation with an architect than in a spreadsheet of yes and no answers.

Privacy noticeTerms of serviceCookie noticePricing structure