---
url: 'https://www.corbado.com/blog/usernameless-passkey-login-fraud-checks'
title: 'Usernameless Passkey Login: Fraud & Lock Checks'
description: 'Usernameless passkey login removes the identifier your fraud and lock checks ran on. Where each control moves and what to settle before launch.'
lang: 'en'
author: 'Vincent Delitz'
date: '2026-11-22T11:58:35.451Z'
lastModified: '2026-11-22T13:22:18.994Z'
keywords: 'usernameless passkey login, identifier-first login, passkey fraud checks, discoverable credentials banking, passkey failed attempt lockout'
category: 'Passkeys Strategy'
---

# Usernameless Passkey Login: Fraud & Lock Checks

## Key Facts

- In an **identifier-first** login, the bank knows the account before authentication
  starts. Fraud holds, lock status, risk scoring and method routing all run at that moment.
- A **usernameless passkey login** starts with an empty `allowCredentials` list. The
  account is only known after the assertion returns its `userHandle`, so every check keyed
  on the account moves behind the passkey.
- Session signals (bot detection, IP, device) still run before authentication. Account
  decisions (fraud hold, lock, step-up) run after the assertion and before the session.
- Failed usernameless attempts that never return an assertion cannot be linked to an
  account. Per-account counters and funnels miss them unless the journey is tracked
  client-side.

## 1. Introduction

Many banks start their [passkey](https://www.corbado.com/passkeys-for-banking) program with an identifier-first
login: the customer types a customer number or username, the bank looks up the account and
then asks for the passkey. It is the easiest design to bolt onto an existing login page. It
also has a known weakness: the page reveals which accounts have passkeys, which is a form
of [account enumeration](https://www.corbado.com/blog/passkey-login-account-enumeration) that many bank security
teams do not accept.

One fix is to go **usernameless**. The passkey button or
[passkey autofill](https://www.corbado.com/blog/webauthn-conditional-ui-passkeys-autofill) starts a ceremony
without an identifier, the customer picks a passkey and the bank learns who it is from the
response. Combined with synced passkeys that are not tied to one browser, this is also the
design with the least friction for the customer.

What gets overlooked is that the identifier-first step was doing more than routing. Over
the years, fraud, risk and operations teams attached checks to the moment the identifier
arrived. When that moment disappears, those checks stop running at the point the team assumes
they run, and nothing in the login flow reports it. This article covers:

- **What exactly changes when the identifier no longer comes first?**
- **Which fraud, lock and routing controls depended on the early identifier?**
- **Where should each control move in a usernameless flow?**
- **How do you measure a login attempt you cannot attribute to an account?**
- **What should fraud, risk and product teams settle before launch?**

## 2. What changes when the Identifier no longer comes first

### 2.1 Order of Events in both Flows

In an identifier-first passkey login, the server receives the identifier, resolves the
account and returns WebAuthn request options with the account's credential IDs in
`allowCredentials`. In a usernameless login, the server returns options with an empty
`allowCredentials` list. The
[WebAuthn specification](https://www.w3.org/TR/webauthn-3/#dictionary-assertion-options)
describes this case directly: the user account "MAY be identified by the userHandle of the
resulting AuthenticatorAssertionResponse". Google's
[passkey server guide](https://developers.google.com/identity/passkeys/developer-guides/server-authentication)
recommends the same: pass an empty array, then find the user from the
[user handle](https://www.corbado.com/blog/webauthn-user-id-userhandle) or the credential ID in the response.

| Step                             | Identifier-first passkey login                 | Usernameless passkey login                          |
| -------------------------------- | ---------------------------------------------- | --------------------------------------------------- |
| **1. Page load**                 | Session and device signals                     | Session and device signals                          |
| **2. Identifier**                | Customer types it, account is resolved         | No identifier                                       |
| **3. Request options**           | `allowCredentials` lists the account's keys    | `allowCredentials` is empty                         |
| **4. Passkey ceremony**          | Customer verifies on the device                | Customer picks a passkey and verifies               |
| **5. Assertion verified**        | Account already known                          | Account resolved from `userHandle` or credential ID |
| **6. Account checks, session**   | Often already done at step 2                   | Must run here                                       |

Steps 2 and 5 are where the difference sits. In the identifier-first flow, the account is
known before any cryptography happens. In the usernameless flow, it is known only after the
[assertion](https://www.corbado.com/glossary/assertion) has been verified.

### 2.2 Why Banks choose usernameless Passkey Login

For banks that rule out identifier-first, a usernameless flow has clear benefits:

- **Closes the enumeration gap:** the login page behaves the same for every visitor, because
  nobody is asked for an identifier before the passkey ceremony.
- **Removes a typing step:** the customer does not need to remember or type a customer
  number.
- **Works across devices:** with [synced passkeys](https://www.corbado.com/blog/device-bound-synced-passkeys), a
  returning customer on a new phone or laptop can sign in without any device-specific
  state on the page.

It has a cost too. A passkey button that the customer has to find and press usually gets
lower passkey usage than an identifier-first flow or a one-tap login on a known device, as
covered in [passkey login best practices](https://www.corbado.com/blog/passkey-login-best-practices). Banks that
accept a remembered identifier on known devices can combine both, as described in
[remember me and passkeys](https://www.corbado.com/blog/remember-me-passkeys).

The security of the login itself does not depend on the identifier. A passkey assertion is
bound to the bank's domain and signed by a key held only in the customer's credential manager or security key.
What depends on the identifier are the checks around the login, which is the subject of the
rest of this article.

The following diagram shows how the checks shift between the two flows.

## 3. Which Controls depended on the early Identifier

Before changing the flow, fraud and risk teams should list every control that reads the
identifier before authentication. In bank login pages, the list usually includes five
groups.

### 3.1 Account Status and Fraud Holds

An identifier lookup tells the bank whether the account is open, closed, suspended or
under a fraud hold. Many login pages stop or redirect at this point, for example to a
"please call us" page for accounts under investigation. In a usernameless flow, the bank
only learns the account after the customer has completed a valid passkey ceremony. The
check still has to happen. It now happens later, with a cryptographically verified account
instead of a typed and unverified one.

### 3.2 Failed-attempt Counters and Lockouts

Password logins count failed attempts per account. The
[OWASP Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html)
recommends associating the counter "with the account itself, rather than the source IP
address". [NIST SP 800-63B-4](https://pages.nist.gov/800-63-4/sp800-63b.html) limits
consecutive failed attempts for a specific authenticator on a single account to no more than
100.

A usernameless passkey attempt has no account until it succeeds. Most failures (the
customer cancels, the device has no matching passkey, a `NotAllowedError` from the browser)
never reach the server at all. Those that do reach it with a credential ID the bank does not
know cannot be mapped to an account either. The per-account counter therefore sees almost
nothing from the passkey path. That is acceptable, because a passkey cannot be guessed. The
counter remains essential on the fallback paths (password, OTP), which still carry an
identifier.

A related policy question comes up early: if the password is locked after too many failed
attempts, should the passkey be locked too? NIST frames the limit per authenticator, which
supports keeping a password lock from blocking a valid passkey, as long as the failures came
from the password alone. Account-level fraud holds
are a different matter and must still apply to every method.

### 3.3 Risk Scoring keyed on the Account

Risk engines often combine session signals (IP reputation, device, location) with account
history (known devices, recent changes to contact details, previous fraud cases). In an
identifier-first flow, both are available before the passkey prompt and the engine can
decide early whether to allow, step up or block. In a usernameless flow, only the session
half is available before authentication.

### 3.4 Method Routing

Identifier-first flows decide what to show next based on the account: a passkey prompt for
enrolled customers, a hardware token or SMS for others, a migration path for accounts on a
legacy stack. Without the identifier, the first screen has to be the same for everyone and
routing moves to the point after the first method has identified the customer.

Security keys deserve a specific note here. A usernameless ceremony only finds
[discoverable credentials](https://www.corbado.com/blog/webauthn-resident-key-discoverable-credentials-passkeys).
Security keys registered as non-discoverable second factors need the credential ID in
`allowCredentials` and therefore an identified account. The FIDO server must also be able
to tell whether a security key credential was registered as a first factor or as a second
factor, otherwise a second-factor key could end up accepted as a complete login. Keeping
[security keys](https://www.corbado.com/blog/fido2-security-key-vs-passkey) as a second factor at first limits the
changes to the FIDO server. First-factor use can follow once the server separates the two
registrations.

### 3.5 Customer-facing Messages

In an identifier-first flow, account-specific messages ("your account is locked", "please
complete your registration") are tempting and leak account state to anyone who types an
identifier. OWASP recommends one generic response "regardless of whether" the credentials
were wrong, the account does not exist or it is locked. A usernameless flow makes this
easier: account-specific messages are only shown after a verified passkey, to the account
holder.

![Where account status, lockouts, risk scoring, method routing and messages run in a usernameless passkey login, while session signals stay before authentication](https://s3.eu-central-1.amazonaws.com/corbado-cloud-staging-website-assets/usernameless_controls_moved_behind_passkey_0b472eb411.png)

## 4. Where each Control moves in a usernameless Flow

The pattern that works is simple to state: **score the session early, decide on the
account late**. Everything that does not need the account stays before authentication.
Everything that needs it runs after the assertion is verified and before the session is
issued.

### 4.1 Run Account Checks after the Assertion, before the Session

The verified assertion gives you the account through the `userHandle` or the credential ID.
That is the new place for fraud holds, account status, lock policy and per-account risk
scoring. Three rules keep this step clean:

- **No session before the checks:** the session cookie or token is issued only after the
  account checks have passed. A verified passkey proves the credential. The account checks
  decide whether that account may bank right now.
- **One decision point:** the check returns allow, [step-up](https://www.corbado.com/glossary/step-up-authentication)
  or block. Fraud teams get a single hook for every passkey login instead of logic spread
  over the identifier and the session steps.
- **Same checks on every path:** password and OTP fallbacks reach the same decision point
  after their own authentication, so no path skips a fraud hold.

### 4.2 Keep Session Signals before Authentication

Bot detection, IP reputation, device signals and rate limits per IP or device do not need
the account. They can run at page load and on the request for WebAuthn options, as they do
today. The session score is then combined with the account history once the account is
known. NIST lists these signals (IP address, geolocation, timing, browser metadata) as risk-based
techniques that keep legitimate users from being locked out.

### 4.3 Treat unknown Credential IDs as a Signal

A usernameless assertion can return a credential ID the bank no longer knows, for example
because the customer deleted the passkey in online banking but it still exists in their
credential manager. Respond with the same generic failure as any other error. Then, where supported, use the
[WebAuthn Signal API](https://www.corbado.com/blog/webauthn-signal-api) (`signalUnknownCredential`) to tell the
credential manager to hide or remove the stale passkey, so the customer is not offered it
again. A spike of unknown credential IDs is also worth a look from the fraud team.

### 4.4 Route after Identification

Once the first method has identified the customer, route as before: step-up for risky
sessions, a security key as a second factor for customers who use one and the migration
path for accounts on a legacy stack. Only the order changes: routing follows
identification.

The following map shows the three places a control can sit in a usernameless login and the
rule that keeps the fallback paths aligned.

## 5. Two Paths, one Set of Controls

### 5.1 Usernameless and Identifier Fallback side by side

A usernameless passkey path rarely replaces the identifier field. Customers without a
passkey on the current device still need password, OTP or a hardware token. Most bank
login pages therefore end up with both: a passkey button or passkey autofill that starts
without an identifier and an identifier field for everything else.

This creates two paths with two different moments of identification. The common mistake is
to adapt the controls for one path and forget the other. The identifier fallback keeps its
pre-authentication lookups, but must not reveal whether a passkey exists for the typed
account. The usernameless path needs the post-assertion checks from section 4. Both should
end in the same decision point.

### 5.2 Gate Enrollment, not the Login Button

When the bank runs a usernameless entry point, it also changes how a phased rollout works.
Without a remembered identifier or device-binding state, the page cannot tell which
customer is returning. If the passkey button is shown
only to a pilot cohort (for example through a cookie or a device flag), an enrolled
customer who returns on a different device or browser loses the visible passkey route.

The more robust pattern is to show the passkey login to everyone on the launch channel and
phase the **enrollment** instead: offer passkey creation first to staff, then to selected
operating system and browser combinations, and expand as each combination proves stable.
Make sure passkey management in the account settings follows the same gates, otherwise
customers enroll through the side door. Read more on securing that step in
[passkey enrollment security](https://www.corbado.com/blog/passkey-enrollment-security).

![The usernameless passkey path and the identifier fallback both end in the same account checks, with enrollment gated in four steps](https://s3.eu-central-1.amazonaws.com/corbado-cloud-staging-website-assets/usernameless_two_paths_one_decision_point_2fec614667.png)

## 6. Measuring a Login you cannot attribute

Usernameless login creates a measurement gap that surprises many teams after launch. An
identifier-first attempt is linked to an account from the first keystroke. A usernameless
attempt is anonymous until the assertion arrives. If the customer cancels, has no passkey
on this device or the cross-device QR flow fails, the server sees at most the options
request and cannot link the attempt to an account. This is the
[pre-identifier blindness](https://www.corbado.com/blog/authentication-observability) that server-side logging
cannot fix.

Three practices close most of the gap:

- **Track the journey client-side:** record the passkey attempt, its outcome and the
  browser error in the frontend, keyed to a session identifier. Server logs see the
  options request and the assertions that arrive, but not why an attempt stopped in the
  browser.
- **Attribute after the fallback:** when the same session then completes a password or OTP
  login, link the earlier passkey attempt to that account. You now know who tried a passkey
  and fell back.
- **Measure from the first method:** report login success per journey, starting from the
  method the customer tried first. In usernameless flows, a
  [passkey success rate](https://www.corbado.com/kpi/passkey-authentication-success-rate) counted per attempt can
  look low, because every cancelled or empty prompt counts as an attempt, while password
  failures often end in resets that never show up as attempts. The
  [total authentication success rate](https://www.corbado.com/kpi/total-authentication-success-rate) across the
  journey shows the real contribution.

Some failed attempts will stay anonymous because the customer leaves without logging in at
all. That share should be small and stable. If it grows after a browser or OS update, it is
an early sign of a client-side regression. The
[authentication analytics playbook](https://www.corbado.com/blog/authentication-analytics-playbook) covers the
underlying metrics in more depth.

![What server logs see compared with what client-side tracking adds for five usernameless login situations](https://s3.eu-central-1.amazonaws.com/corbado-cloud-staging-website-assets/usernameless_measuring_unattributed_attempts_a8e124033b.png)

## 7. Pre-launch Checklist for Fraud, Risk and Product Teams

Before switching from identifier-first to usernameless, the following questions should
have an owner and an answer:

1. **Control inventory:** which fraud, lock and routing checks read the identifier before
   authentication today, and where does each run after the change?
2. **Decision point:** is there exactly one post-assertion check that every login path
   (passkey, password, OTP, token) passes before a session is issued?
3. **Lock policy:** does a password lock block passkey login, and do account-level fraud
   holds apply to all methods?
4. **FIDO server:** does it support empty `allowCredentials`, resolve the account from the
   `userHandle` and distinguish first-factor from second-factor security key credentials?
5. **Unknown credentials:** is the response generic, and is the Signal API used to clean up
   stale passkeys?
6. **Messages:** are account-specific messages only shown after a verified login?
7. **Rollout:** is enrollment gated by cohort and platform while the login stays visible to
   everyone?
8. **Measurement:** are client-side attempts tracked and attributed after fallback, with a
   baseline across all login methods?
9. **Device testing:** has the flow been tested across the operating systems, browsers and
   credential managers your customers actually use, with production monitoring planned
   for the combinations you could not test?

Points 1 to 3 belong to the fraud and risk teams, points 4 to 6 to engineering and points 7
to 9 to the product owner. The list is short, but each item is a common source of late
surprises in [bank passkey deployments](https://www.corbado.com/blog/passkey-deployment-mistakes-banks).

![Nine pre-launch questions for a usernameless passkey login, each with its owner: fraud and risk, engineering or product owner](https://s3.eu-central-1.amazonaws.com/corbado-cloud-staging-website-assets/usernameless_pre_launch_checklist_a8d91fac0d.png)

## 8. How Corbado can help

Moving checks behind the passkey only works if you can see what happens in front of it.
[Corbado Observe](https://www.corbado.com/observe) tracks every login attempt client-side across passkeys,
passwords, OTP and security keys, without replacing the existing identity provider. It
captures pre-identifier events, so usernameless attempts that stop before an account is
known stay visible, and breaks down failures by operating system, browser and credential
manager. Fraud, product and support teams see the same journey, so a stalled rollout or a
new error class shows up as data instead of support tickets.

[Video: Error overview](https://www.corbado.com/videos/features/error-overview.mp4) ([See Passkey Errors in Corbado Observe](https://www.corbado.com/observe/passkey-errors))

For banks still designing the flow,
[Corbado's passkey consulting](https://www.corbado.com/blog/passkeys-login-consulting) helps map the existing
controls to the usernameless design and plan a phased rollout with measurable pause points.

## 9. Conclusion

Usernameless passkey login is a common target for banks that rule out identifier-first: it
closes the enumeration gap and removes a typing step for returning customers. The identifier-first step, however,
quietly carried fraud holds, lock checks, risk scoring and method routing. Those controls
need a new home.

- **What changes:** the account is known only after the verified assertion, through the
  `userHandle` or credential ID.
- **Which controls depended on the identifier:** account status and fraud holds,
  per-account failure counters, account-based risk scoring, method routing and
  account-specific messages.
- **Where they move:** session signals stay before authentication. Account checks run
  after the assertion and before the session, in one decision point for every path.
- **How to measure it:** track attempts client-side and attribute them after fallback,
  because server logs do not show why an attempt stopped in the browser.
- **What to settle before launch:** the nine checklist items above, each with an owner.

Teams that do this inventory before launch keep their fraud controls intact and get a
cleaner design than before, because every check now runs on a verified account.
