Insight

18 things a passkey can do

Eighteen things the passkey in your password manager can do as of November 2026: passwordless sign-in, second factor, step-up, admin role activation, action and payment approval, end-to-end encryption with PRF, vault unlock, on-chain wallets, sharing, moving between password managers and more, with the catch and the references for each.

18 things a passkey can do

Most passkey explainers stop at the login button. We went looking for one page that lists everything else a passkey is good for and didn’t find it. The FIDO Alliance sorts its use cases by industry, and vendor posts tend to cover whichever single feature the vendor sells. So this is the list we wanted, with the catch next to each entry and the primary sources under it.

Which passkey we mean

The one in your password manager. iCloud Keychain, Google Password Manager, Bitwarden, 1Password, or a dedicated passkey manager. It syncs across your devices, it works in browsers and apps, and it’s what a website gets when it asks for a passkey.

Everything on this list works with that. Things that need a hardware security key plugged into a USB port (SSH keys, disk unlock, sudo) are a different list, and they are left out here on purpose.

Under the hood a passkey is a key pair, almost always P-256, tied to one domain, and it only acts when a person approves. It can sign a challenge, and with the right extension it can derive a secret that nothing else can reproduce. All eighteen entries are one of those two tricks pointed at a different problem. If you want the protocol itself first, Passkey Town walks through it.

Getting in

1. Sign in with no password

The use everyone knows. The site sends a random challenge, your password manager asks for a fingerprint or PIN, and the passkey signs the challenge together with the domain the browser is really on. The server checks the signature against the public key it stored at registration.

Possession and verification happen in one gesture, so this counts as two factors on its own, and NIST’s SP 800-63B-4 accepts synced passkeys at AAL2. It can’t be phished, because a lookalike domain produces a signature the real site rejects.

The best version of this needs no button at all. Mark the username field with autocomplete="username webauthn" and the browser offers the passkey in the same dropdown where it used to offer a saved password.

The catch is whatever the site keeps as a fallback. If “forgot my passkey” sends an email link, the email link is the account’s real security level.

Read more: passkey form autofill on web.dev, and NIST on syncable authenticators.

2. Open an account that never has a password

A site can register you with a passkey and nothing else. The FIDO design guidelines describe the flow: ask for an email address first, then offer to create a passkey, and never show a password field. There is no password to choose, reuse, leak or reset, and sign-up gets shorter.

What the site stores is a public key and a credential ID. A copy of that database gives an attacker nothing to log in with.

The catch is recovery, and it arrives sooner than on an account with a password. Decide what happens when someone loses every device before the first user signs up, and nudge people to add a second passkey from another password manager.

Read more: the FIDO pattern for new account creation with a passkey.

3. Be the second factor

A passkey can sit behind a password the way an authenticator app does. The user types the password, then approves with the passkey. It beats SMS codes and TOTP because a fake site can’t relay it.

We’d treat this as a stepping stone, and the platform guidance agrees. GitHub lets a passkey satisfy the password and the 2FA requirement in a single step, and the web.dev passkey checklist says a second factor layered on a passkey adds little. If the site already trusts the passkey enough to use it as the strong half, it can drop the weak half.

The reason to stay here for a while is rollout. Second-factor mode lets a site introduce passkeys without touching its password flows, and remove the password later.

Read more: GitHub’s about passkeys, and the web.dev passkey deployment checklist.

4. Sign you in on a device that doesn’t have it

Sitting at a borrowed laptop, you pick “use a phone”, scan a QR code, and approve on the phone. The standard calls this cross-device authentication, and the transport underneath is named hybrid.

The QR code only starts the session and carries no authority. The two devices then check over Bluetooth Low Energy that they are physically near each other, which is what stops someone on another continent from showing you their QR code. The sign-in data itself travels through an encrypted tunnel and doesn’t rely on Bluetooth for its security.

The passkey never moves to the laptop. Both devices need Bluetooth switched on, and that is the usual reason it fails. FIDO’s own deployment guidance admits the QR step is hard for general users, so don’t make this the main path.

Read more: FIDO’s cross-device sign-in pattern, and the passkeys.dev glossary.

5. Work in the app and on the website

One passkey covers a company’s website and its mobile apps. The site publishes a small file naming the apps it trusts, and the operating system then offers the same passkey in both places.

On Apple platforms that is an associated domain with the webcredentials service, backed by an apple-app-site-association file on the site. On Android it is a Digital Asset Links file at /.well-known/assetlinks.json, read by the Credential Manager API.

Without that file, the app can’t see the passkey. It’s a one-off setup job, and skipping it leaves users with two credentials for one account.

Read more: Apple on supporting associated domains, and Android’s Credential Manager guide.

6. Work across a company’s domains

A passkey is tied to one domain, which is awkward for a business that runs example.com, example.co.nz and example-pay.com. Related Origin Requests fix that.

The main domain serves a JSON file at /.well-known/webauthn listing the other origins. When one of those sites asks for a passkey that belongs to the main domain, the browser fetches the file, finds the site on the list, and allows it. Users keep one passkey for the whole company.

The list has to live on the main domain and be kept current. A forgotten entry is a sign-in page that silently stops offering the passkey.

Read more: Related Origin Requests on web.dev, and the passkeys.dev related origins page.

Proving it’s still you

7. Step up before something sensitive

Being signed in an hour ago is thin evidence when someone is about to change the payout bank account. Ask for a fresh passkey approval right before the action. It takes two seconds and proves the account holder is at the device now.

Two details decide whether it means anything. Set userVerification to required, because the default preferred lets a password manager skip the fingerprint or PIN. And keep that requirement in the server’s session record, then check the verification flag in the response, so a tampered page can’t quietly downgrade it.

You still need a rule for which actions trigger it and how old a session may be. A prompt on every click trains people to approve without reading.

Read more: Chrome’s guidance on passkey reauthentication.

8. Guard admin roles

Identity providers can demand phishing-resistant sign-in before a privileged role activates. In Microsoft Entra, Privileged Identity Management has a setting named “On activation, require Microsoft Entra Conditional Access authentication context”. Point that context at a policy requiring the phishing-resistant authentication strength, and a passkey becomes the price of becoming Global Administrator. Set the policy’s sign-in frequency to “every time” and the prompt appears on each activation.

Microsoft recommends this for the highest roles, and warns about two things: register the passkeys before you enforce the policy, and exclude your emergency access accounts, or you will lock yourself out.

A password-manager passkey can’t prove what device it lives on, so the policy is only as strong as the way passkeys get added. If an attacker who phished a weaker factor can enrol a passkey of their own, they have met your phishing-resistant requirement. Check the enrolment path on admin accounts before you trust the policy.

Read more: Microsoft on PIM role settings, on phishing-resistant MFA for administrators, and on enabling passkeys.

9. Sign off on one specific action

A site chooses the challenge, so it can put meaning in it. Hash “delete project atlas” or “release build 4.2 to production” with a nonce and a timestamp, use the result as the challenge, and the signed response becomes a record that this passkey approved that exact action. Store it next to the audit log. On the server, recompute the hash from the action you are about to perform, and make sure a response replayed against a different action fails.

This is a good fit for approvals that a person must make and software must not, such as confirming what an automated agent is about to do.

Know that this is a workaround. The W3C payments group calls it a misuse of the challenge field, and their objection is fair: nothing in WebAuthn shows the user what the challenge means. The user sees whatever the page shows them, and a compromised page can show one thing and hash another. The signature proves which action was approved. It can’t prove what the person was looking at.

Read more: the problem statement in the W3C Secure Payment Confirmation spec, which describes this gap before solving it for payments.

10. Approve a payment

Payments are the same idea with a stricter rule. European regulation wants the approval tied to the amount and the payee, and wants evidence that the payer saw both.

Secure Payment Confirmation closes the display gap from the previous entry. The browser draws a dialog with the merchant, the amount and the currency, outside the page’s control, and the passkey signs those details through a payment extension. The bank verifies them before authorising. It also lets a merchant’s checkout page invoke the passkey a customer registered with their bank, without a redirect to the bank’s site.

SPC ships in Chromium browsers on Android, macOS and Windows, and the spec is still a Candidate Recommendation draft. Everywhere else, fall back to the hashed challenge and accept that the page is doing the displaying.

Read more: the W3C spec, Chrome’s developer guide, and the FIDO Alliance white paper.

Keeping secrets

11. Encrypt data end to end

A signature changes every time, so it’s useless as an encryption key. The prf extension fixes that. The site sends a salt during sign-in, the passkey mixes it with a secret of its own, and the same salt always returns the same 32 bytes. A different salt returns different bytes, so one passkey can serve several keys.

Run those bytes through HKDF to get an AES key, and use it to wrap the key that encrypts the user’s data. The server stores ciphertext it has no way to read, and the user never sees a second password.

Password managers added prf on their own schedules and a few still lack it, so test with the ones your users bring. And losing the passkey loses the key. Wrap the data key under two passkeys, or hand the user a recovery code to print.

Read more: the W3C PRF explainer, and the extension’s definition in WebAuthn Level 3.

12. Unlock a vault with no master password

The same extension, applied to the oldest problem in password management. A vault can derive its decryption key from a passkey, so signing in and decrypting happen in one approval and there is no master password to type.

Bitwarden ships this. When you add a passkey to your Bitwarden account there is an option to use it for vault encryption. With it on, the passkey logs you in and decrypts the vault. With it off, or with a browser or passkey that can’t do prf, the passkey logs you in and Bitwarden still asks for the master password.

Think about where that passkey lives. A vault unlocked by a passkey stored inside the same vault has a bootstrapping problem on a new device, so keep the unlocking passkey somewhere else.

Read more: Bitwarden’s log in with passkeys help page.

13. Carry a small payload

The largeBlob extension lets a site store a little data alongside the passkey: a certificate, a wrapped key, a configuration blob. The site asks for blob support when the passkey is created, then writes and reads the data during later sign-ins. The blob travels wherever the passkey syncs.

A certificate is the usual example. A site can issue one for the user and park it with the credential, so it follows the passkey between devices.

Support is thinner than for prf, so treat it as an optimisation and keep a server-side copy.

Read more: the W3C Large Blob explainer.

14. Sign blockchain transactions

Blockchains historically used a different curve from passkeys, which forced wallets to keep a seed phrase somewhere. Ethereum added a native verifier for the passkey curve with EIP-7951 in the Fusaka upgrade, and several layer-2 networks had the equivalent earlier.

A smart account can now name a passkey as its signer. The account contract stores the passkey’s public key, and each transaction carries a WebAuthn signature that the contract checks with the new verifier. OpenZeppelin publishes a reference implementation.

The result is a wallet with no seed phrase to write down. Losing every copy of the passkey loses the account unless a second signer was set up first, and on a blockchain there is no support desk to call.

Read more: EIP-7951, and OpenZeppelin’s WebAuthn smart accounts guide.

Looking after itself

15. Replace a password without being asked

Asking people to “set up a passkey” converts badly. Conditional create skips the asking. Right after a successful password sign-in, the site requests a passkey with mediation: "conditional". If the password manager holds the password that was just used and is willing, it creates a passkey for the same account and tells the user afterwards. If any precondition isn’t met, the call fails quietly and the user sees nothing.

Apple calls this automatic passkey upgrades and added it in iOS 18 and macOS 15. Chrome followed in version 136. adidas wrote up what happened when they turned it on.

It depends on the password manager going along with it, so treat a failure as normal. If we could switch on one entry from this list for an existing site, it would be this one.

Read more: Chrome on conditional create, Apple’s WWDC24 session on passkey upgrades, and the adidas case study.

16. Be shared with someone you trust

A hardware key can be in one pocket. A password-manager passkey can be shared. Apple’s shared password groups carry passkeys from iOS 17 and macOS 14 onward, and 1Password shares them by putting the item in a shared vault. A couple can both hold the passkey to the power company, and a small team can share the one for a supplier portal.

The site can’t tell the holders apart. It sees one credential.

Taking access back is the weak point. Apple’s own guidance says removing someone from a group doesn’t undo what they already received, and tells you to change the credentials. For a passkey that means deleting it on the site and making a new one.

Read more: Apple on sharing passwords and passkeys, and 1Password on saving and sharing passkeys.

17. Move to a different password manager

Until recently a passkey was stuck where it was created. The FIDO Credential Exchange specifications define a common format for credentials and an encrypted hand-off between password managers, with no plaintext export file in between.

Apple built it into iOS, iPadOS and macOS 26. The transfer is started by the user, runs directly between the two apps, and is confirmed with Face ID or its equivalent. Websites and apps don’t have to do anything. Google and Bitwarden have shipped support as well.

Coverage beyond those is still arriving. Check both ends support it before promising anyone a migration.

Read more: the FIDO Credential Exchange Format, and Apple’s WWDC25 session on what’s new in passkeys.

18. Tidy up after an account change

Stale passkeys are a support cost: the user deletes one on the site, the password manager keeps offering it, and sign-in fails. The Signal API closes the loop with three calls. One says a credential the password manager just offered no longer exists. One sends the full list of credentials that are still valid, so anything else can be removed. One sends the account’s current username and display name, so a renamed account shows the right label.

It is the least widely supported item here. It fails quietly where it’s missing, so it’s safe to call everywhere.

Read more: Chrome’s Signal API guide.

What it can’t do

Verify identity. A passkey proves the same password manager came back. It has no idea whose hands it is in, or whether the name on the account is real. If you need to know who someone is, check a document or a verifiable digital credential once, then bind a passkey to the result.

Recover an account. A lost passkey is the thing recovery exists to solve. Whatever you bolt on for that case (email link, support call, backup code) sets the real security level of the account.

Run unattended. Every use above needs a person to approve. Cron jobs, CI runners and service accounts need a different kind of credential.

Prove what hardware it is on. A password manager sends a model identifier, and sites use it to show a name and an icon, but nothing signs it. Requirements that depend on the device belong to hardware security keys.

What we’d build with

Numbers 1, 7 and 15 are safe to ship today on every major platform, and together they get most of the benefit. Number 11 works, and we’d still test it against every password manager our users bring, because we build a passkey manager ourselves and know how much each one differs. Numbers 10 and 18 need a fallback until more browsers ship them.

Support in this area moves monthly. Everything above was checked in November 2026, and the list will get edited when it changes.