Migration10 November 2026

Moving from Duende IdentityServer to Vord: what carries over and what you change

Users with ASP.NET Core Identity V3 hashes can keep their passwords. Your apps and APIs still have to change. Here is what moves, what doesn't, and what we have and haven't tested.

Moving an identity server has two hard parts: your users, who shouldn't all have to reset their passwords, and your apps and APIs, which trust the old server. This post covers both for a move from Duende IdentityServer to Vord, including the parts that make it more work than changing a URL.

A note first. We build Vord, it releases on 1 December 2026, and no customer has made this move yet. Everything below comes from reading our own code and running our own tests. Where we haven't tested something, we say so.

The short version

  • If your IdentityServer uses ASP.NET Core Identity with V3 password hashes, your users can keep their passwords.
  • If your user IDs are GUIDs, they can stay the same, so the sub claim your apps have stored doesn't change.
  • Your clients, secrets, sessions and refresh tokens don't carry over. Everyone signs in once after the move.
  • Your APIs will probably need code changes, because Vord's access tokens have no audience and Vord has no custom API scopes.
  • The import isn't self-serve. For early-access teams, we run it for you.

Why passwords can carry over

IdentityServer can use ASP.NET Core Identity as its user store, and Vord uses ASP.NET Core Identity too. A V3 hash stores its own algorithm, iteration count and salt, so Vord can check a password against a hash it didn't create.

We tested two kinds of V3 hash: the current format (HMAC-SHA512, 100,000 iterations) and the older one (HMAC-SHA256, 10,000 iterations). For each, an automated test imports the hash unchanged and then signs in through Vord's real login page:

  1. The wrong password is refused, and the stored hash stays as it was.
  2. The original password signs in, and the signed-in user keeps the imported ID.
  3. Vord replaces the stored hash with a stronger one (HMAC-SHA512, 210,000 iterations by default).
  4. The same password signs in again.

Check your own hashes

Run this before anything else (SQL Server syntax; on PostgreSQL, quote the table and column names):

SELECT
  COUNT(*) AS total_users,
  SUM(CASE WHEN PasswordHash IS NULL THEN 1 ELSE 0 END) AS no_password,
  SUM(CASE WHEN PasswordHash LIKE 'AQAAAA%' THEN 1 ELSE 0 END) AS v3_hashes
FROM AspNetUsers;

A V3 hash starts with AQAAAA when it's Base64-encoded, as ASP.NET Core Identity stores it. If v3_hashes plus no_password equals total_users, every password in the table is in the format we tested.

We haven't tested any other format, including V2 hashes or a custom password hasher. Plan for those users to set a new password through the forgot-password email, which needs a confirmed email address.

What carries over

WhatMoves?Details
Email, confirmed status, display name, created dateYesThe email address becomes the sign-in name. Vord requires a confirmed address for password sign-in.
User ID (sub)If it's a GUIDThe import only takes GUIDs. Other IDs need new values and a mapping on your side.
Password hashIf it's V3See above.
OrganizationsYesID, name and slug. You supply these from wherever your app keeps its tenants.
Organization membershipsYesVord's built-in roles are Owner, Admin and Member, and each imported membership gets one of them.
Authenticator app (TOTP) setup, passkeysNoUsers set them up again.
External logins, such as Google or MicrosoftNoTell us how many users rely on them, so we can plan for it before the move.
Sessions, refresh tokensNoEveryone signs in once after the move.
Clients and client secretsNoYou register each app in Vord and get a new client ID and secret.
Signing keysNoVord is a new issuer with its own keys, so tokens from the old server stop being valid for anything that now trusts Vord.
Custom IdentityServer code, such as IProfileService or extension grantsNoThis code is written against Duende's APIs and doesn't run on Vord. We'll go through what it does with you, and tell you if Vord has no equivalent.

What changes in your apps and APIs

Sign-in. Any standard OpenID Connect library works: point it at Vord's address and use the new client ID and secret. Two rules may catch older clients:

  • PKCE is required for every client.
  • The supported grants are authorization code, refresh token, client credentials and token exchange. There is no implicit flow, hybrid flow, device code or password grant, so a client using one of those has to change.

API token validation. This is likely the largest change. Except for tokens issued for MCP servers, a Vord access token has no aud claim, so an API configured to require an audience rejects every token. You validate the signature, issuer and expiry instead, and then decide what the caller may do from the scope, org and role claims.

Without an audience, a valid signature only proves that your Vord instance issued the token, not that it was issued for this API. A token issued for another of your apps verifies just as well. Those authorization checks are what protect each API, so check that every endpoint has them.

Custom API scopes. Applications can only be granted a fixed list of scopes: openid, profile, email, roles, offline_access and identity.api. A scope like orders.read has no direct equivalent. The closest thing is Vord's permissions: an organization defines them and grants them through custom roles, and they arrive in the access token's permissions claim. Moving to them is a redesign of how your APIs authorize callers, not a rename.

Reference tokens. Vord has no introspection endpoint, so APIs validate JWTs locally. If you use reference tokens today, those APIs have to change.

Claims. Check any code that reads claims. The organization is in org, and the role is owner, admin or member. amr is a plain string in the access token but an array in the ID token.

Duende BFF. We haven't tested Duende's BFF library with Vord, so treat that as unknown.

How a move works

  1. You send us the numbers. That's the result of the query above, plus a list of your apps, APIs and any custom IdentityServer code. If something won't work, this is where we should find out.
  2. We agree how to transfer the data. Password hashes are sensitive, so don't email them. The import masks them in its audit records.
  3. We rehearse on a test environment. Organizations go in first, then users, then memberships. Automated tests cover each of those imports, and one runs all three in sequence, but we haven't yet done a full run that also signs in with the imported password. So we do that before touching anything real, and you try it with test accounts.
  4. You change your apps and APIs in staging, using the list above.
  5. We run a final import just before the switch. The import can be re-run: it picks up changes, and if a user's password hash has changed, it ends that user's Vord sessions.
  6. You switch your production apps to Vord. Everyone signs in once. Keep IdentityServer available in case you need to roll back, but passwords changed in Vord after the switch won't exist on the old server.

When this isn't worth doing

If your APIs lean heavily on audiences, custom scopes or reference tokens, or you have a lot of custom IdentityServer code, the move is a real project. Vord is also new and has no track record yet. Compare it against staying where you are: our cost comparison covers Duende's prices and the other options.

If it still looks worthwhile, join the early-access list and we'll start with the query above.

Sources

Read on 2026-11-05: