Disclosure: Frontegg publishes this guide and sells the product it describes. Auth0 facts come from Auth0's own documentation and Frontegg facts from developers.frontegg.com, both checked on 8 November 2026. Where the guide says "in our test", the result comes from a small import we ran on one Frontegg environment on 16 November 2026, through the single-user migration endpoint, with test users, a password hash and an authenticator secret we created ourselves. We did not test with a real Auth0 export or with the bulk endpoint. Check both sets of docs before you plan a migration.
Summary
Frontegg documents three routes for moving from Auth0:
| Path | What it does | Auth0 stays live? | Best when |
|---|---|---|---|
| 1. "Migrate from Auth0" API route | Frontegg reads users from your Auth0 tenant through an Auth0 machine-to-machine app and creates them in Frontegg | Until you switch login | You want a one-time move driven by an API call, without building an export file (attribute coverage: see Path 1) |
| 2. Auth0 as an external user pool | Frontegg authenticates users against Auth0 while you run both | Yes | You need a coexistence period before cutover |
| 3. Export, then bulk API or CSV import | You export from Auth0 (plus a password-hash export from Auth0 Support) and import through the bulk API (up to 1,000 users per request) or CSV files (up to 10 files of 1 MB) | Until you switch login | You need full control over field mapping, or you want to keep existing passwords |
Whatever the route, a B2B migration is mostly about tenants. Every user must land in the right Frontegg tenant with the right roles, and each customer's SSO connection and SCIM directory has to keep working on the day that customer moves.
Before you start: the inventory
Write these down per Auth0 tenant before touching an API:
- How you model customers. Frontegg assigns a migrated user to a tenant by reading a tenant ID you store on the Auth0 user, in
app_metadataoruser_metadata(you name the field, for exampletenant_id). If you model customers with Auth0 Organizations instead: before migrating, map each Auth0 Organization to a Frontegg tenant ID and tag each user accordingly so they land in the right tenant. - Tenants. Create the Frontegg tenants before you migrate users. You can keep your existing tenant IDs; the tenant migration endpoint accepts batches of up to 1,000 tenants and returns a
migrationIdyou can poll. - Roles. Create the Frontegg roles first. Imports reference roles by ID, and the roles must already exist. Users imported without role IDs get the default role.
- Passwords. Auth0 does not return password hashes through its Management API. If you want users to keep their passwords, request the password-hash export from Auth0 Support (not available on Auth0's Free plan). Auth0 does not commit to a delivery date, so request it early. Auth0 reviews each request and says not all requests qualify. The request needs a PGP public key and an acknowledgment form signed by a CISO, CSO or executive at VP level or above, and the download link expires after 3 days. Otherwise plan a reset or passwordless sign-in.
- MFA. List which factors your users enrolled: authenticator apps (TOTP), SMS, others.
- Enterprise SSO connections. For every customer SAML or OIDC connection, record the IdP, the values the IdP holds today (see "Move each SSO connection"), and the customer contact who can change the IdP configuration.
- SCIM directories. List which customers provision users into Auth0 through inbound SCIM, and from which IdP.
- Applications. Frontegg does not assign migrated users to specific applications automatically. Keep a default or auto-assigned application, and assign users to other applications afterwards with the assignment API.
- Custom logic. List what each Auth0 Rule and Action does. Frontegg documents no automatic way to bring them across; rebuild the behavior with Frontegg configuration such as prehooks.
- References to Auth0 user IDs. Find every table, log and third-party system in your own stack that stores Auth0
user_idvalues. Every user gets a new Frontegg user ID. You can store the Auth0 ID on the Frontegg user at import (see Path 3), which gives you the mapping from each Auth0 ID to the new Frontegg ID.
Path 1: the "Migrate from Auth0" API route
- Create or reuse an Auth0 machine-to-machine application authorized on the Auth0 Management API with
read:users,read:user_idp_tokensandread:roles. You can check and update scopes with Auth0's client-grants endpoints. - Store the tenant ID on every Auth0 user in
app_metadataoruser_metadata. - Create the matching tenants in Frontegg, keeping the IDs you stored.
- Call the "Migrate from Auth0" route with your Auth0
domain(includinghttps://),clientId,secret,isTenantIdOnUserMetadataandtenantIdFieldName. Frontegg creates each user and assigns them to the tenant whose ID matches the field. - Check the result in the Frontegg backoffice before you change any login flow.
Frontegg's docs for this route do not list which attributes come across. Their example shows the created user with name, email, the tenant, and the Auth0 user_id saved in the user's metadata as auth0_id. This route does not import password hashes. Auth0 does not return password hashes through its Management API, so to keep passwords, MFA enrollment, roles and phone numbers, use Frontegg's migration endpoints (single-user or bulk) with a password-hash export obtained from Auth0 Support, as in Path 3. Otherwise plan a password reset.
Path 2: run Auth0 and Frontegg side by side (external user pool)
Frontegg supports Auth0 as an external user pool. The documented setup in Auth0:
- Set the application's client authentication method to Client Secret (Post).
- Enable the Password grant type.
- Authorize the app on the Auth0 Management API and grant
read:usersandread:roles. - Set
app_metadata.tenantIdon each user to the Frontegg tenant ID. - Create Auth0 roles whose names match the Frontegg role keys.
Frontegg documents just-in-time migration for Amazon Cognito pools only. To move users out of an Auth0 pool and into Frontegg, plan to migrate them with Path 3 (or Path 1).
While users are still stored in Auth0, the user-pool overview lists three Frontegg sign-in methods as unavailable to them: one-time code, Frontegg-managed SSO and login with SMS. SSO configured in Auth0 keeps working through Auth0. To move an SSO customer's connection to Frontegg, migrate their users with Path 1 or Path 3.
Frontegg also documents an Auth0 IdP user pool, where Auth0 federates sign-in and the tenant ID travels in the Auth0 ID token (added from app_metadata with an Auth0 Login Action).
Path 3: export, then bulk or CSV import
- Export users from Auth0. Auth0's bulk export job (
POST /jobs/users-exports) produces NDJSON or CSV. If your tenant ID lives inapp_metadata, note that CSV exports cannot includeapp_metadataoruser_metadataas whole objects: name the subfield (for exampleapp_metadata.tenant_id) or use the JSON format. CSV exports are capped at 30 fields, job data is deleted after 24 hours, and the download link expires after 60 seconds (you can request it again while the job exists). - Request hashes and MFA secrets. If you keep passwords, request the password-hash export from Auth0 Support; Auth0 links its guidance under "Export Password Hashes and MFA Secrets", so ask for authenticator-app secrets in the same request. The hash export is newline-delimited JSON without user metadata, so merge it with the regular export by user. Sample hashes in Auth0's support article use the bcrypt format.
- Map fields to Frontegg's migration payload. The basics are
email,tenantId,name,metadata,roleIdsandverifyUser(set it totrueif email verification is on, so migrated users are marked verified). Then:- Passwords. Send
passwordHashwithpasswordHashType. Frontegg's migration docs list bcrypt as supported, which matches Auth0's sample hashes. - Phone numbers. Send
phoneNumberwithphoneNumberType(authormfa). A phone number can be a sign-in method or an MFA factor for a user, not both: for users enrolled in SMS MFA, import the number withphoneNumberType: mfa. - Authenticator apps. Send each user's TOTP secret in
authenticatorAppMfaSecretas a Base32 string, the encoding authenticator apps use for setup keys. Frontegg's API reference does not state a format. In our test, a user imported with a Base32 secret we generated was asked for a code at sign-in, and a code computed from that secret was accepted without re-enrolling. The import did not reject the same secret sent as hex or Base64, and we did not test whether those work at sign-in. Check which encoding your Auth0 export uses, convert to Base32 if needed, and test one real user before the batch. provider. It is optional and defaults tolocal, which is what password users need. The API reference listslocal,saml,google,github,facebook,microsoft,scim2,slackandapple; in our testauth0was rejected with HTTP 400. We have not tested whether a user imported with a social value such asgooglecan then sign in with that provider, so do not rely on it without your own test.- Auth0 user ID. Send each user's Auth0
user_idasexternalId. It is an optional field in the migration API, and in our test the import response returned the user with the value as sent. Frontegg's own Auth0 example (Path 1) stores the ID inmetadataasauth0_idinstead, which also works. We suggestexternalIdbecause it is a dedicated field, so you do not have to parse the metadata JSON string to read it. If some of your users come through Path 1, usemetadata.auth0_idfor all of them so the ID lives in one place.
- Passwords. Send
- Import through the bulk endpoint (
/identity/resources/migrations/v1/local/bulk) in batches of up to 1,000 users, polling eachmigrationId. Or use CSV import, where onlyemailandtenantIdare required and you can upload up to 10 files of 1 MB each. In our test on the single-user endpoint, importing an email that already existed in the tenant returned HTTP 400 "User already exists" and left the existing user unchanged. We did not test the bulk endpoint, which returns amigrationIdinstead of a per-user result, so check the migration status after re-running a batch. - Respect limits:
nameup to 256 characters;metadataandvendorMetadataup to 65,535 bytes each. Oversized requests fail with HTTP 400.
The single-user and bulk migration endpoints cover passwords, MFA enrollment, roles and phone numbers. Users whose hashes Frontegg does not support are prompted to reset their password. In our test, a user imported with a bcrypt hash we generated (cost 10, $2a$ prefix) signed in with the original password, with no reset. We did not test with a real Auth0 export, whose sample hashes use the $2b$ prefix, so import one real user and sign in before you run the full batch.
The Frontegg user ID is new whichever field holds the Auth0 ID. The single-user endpoint returns the new user in its response; the bulk endpoint returns only a migrationId, so after a bulk import read the users back to pair each Auth0 ID with its Frontegg ID for any system that stores user IDs.
Plan the cutover per customer
Plan each wave around tenants:
- Group tenants into cohorts. Start with internal and test tenants, then customers that sign in with passwords or social login, then customers on SSO and SCIM, with your largest SSO customers last.
- Route each cohort's logins with the
AUTH_INITIATEDprehook. It fires when a login starts, before credentials are checked, and can let the login continue in Frontegg or redirect it to another login page (externalRedirectUrl), for example your Auth0 login for cohorts that have not moved. Frontegg's prehooks page does not list the payload fields for this event, so confirm on a test tenant which user or tenant identifier you receive before you build cohort rules on it. - Import before you route. A tenant's users, roles and SSO connection exist in Frontegg before its cohort is routed there.
- Handle sign-ups in the window. Decide whether new sign-ups go to Frontegg from the first wave or are paused.
Our gradual CIAM migration guide covers the cohort register, monitoring and rehearsal in more depth. This section covers what is specific to leaving Auth0.
Move each SSO connection
A customer's IdP holds values that point at Auth0. Compare them with the values Frontegg will use for the same connection:
| Value in the customer IdP | Auth0 today (default) | Frontegg |
|---|---|---|
| ACS / reply URL | https://{yourDomain}/login/callback?connection={connectionName} | {your Frontegg or custom domain}/auth/saml/callback |
| SP entity ID / audience | urn:auth0:{tenant}:{connectionName}, unless you overrode it | The SP entity ID you set in Frontegg; the SAML Audience must match it |
| IdP signing certificate | Uploaded to the Auth0 connection | Applied to the Frontegg connection; the response must be signed with it |
| NameID | Per connection | Must match the user's login email |
Each customer's IdP must be updated with Frontegg's ACS URL and SP entity ID.
Checklist per SSO customer:
- Set your Frontegg custom domain before the first SSO customer moves. Frontegg's docs warn that changing domains after go-live with active SSO connections is hard.
- Create the customer's connection on their Frontegg account (backoffice SSO tab or API), reusing their IdP metadata and signing certificate.
- Ask the customer to add Frontegg as a new SAML application in their IdP rather than editing the Auth0 one. Both stay configured during the window, so a rollback does not need another IdP change.
- Agree a test window. Sign in with a test user from that customer, and check Audience, Destination, certificate and NameID if it fails.
- Route that tenant's logins to Frontegg, watch sign-ins and support tickets, then ask the customer to remove the Auth0 application after the agreed period.
- If you enable Frontegg's self-service SSO module in the admin portal, tell the customer's admins where they will manage the connection from now on.
Message template for the customer's IT admin (fill in the brackets):
We are moving [Product] sign-in to a new identity provider on [date]. Please add a new SAML application for [Product] with these values: ACS URL [value], Entity ID [value]. Keep the existing [Product] application until [date]; we will tell you when it is safe to remove. Test window: [date/time]. Contact: [name].
Move SCIM directories
If a customer provisions users into Auth0 with inbound SCIM, their IdP holds an Auth0 SCIM endpoint URL and token that are specific to that Auth0 connection. Under the SCIM 2.0 protocol the IdP is the client: it sends requests to the service provider's base URL with a credential the provider issues. Moving the directory therefore means the customer points their IdP's provisioning at Frontegg's endpoint and token.
Checklist per SCIM customer:
- Create a SCIM configuration for the customer's Frontegg account (API or backoffice); Frontegg returns a token for it. Or enable the admin portal's SCIM module so the customer's admin sets it up.
- Move SCIM and SSO for a tenant in the same wave. In Auth0, SCIM-provisioned users are tied to their connection; deprovisioning has to reach whichever system the customer signs in to.
- Decide how users who already exist in Frontegg (from your import) meet the IdP's first push. Frontegg matches SCIM users by email and documents a "user already exists" conflict whose fix is to remove the user and re-provision. Test this with one imported user and one SCIM push on a test tenant before the first SCIM customer moves.
- Map roles: SCIM-provisioned users get the environment's default roles, and at SSO login they also get the connection's default role and group roles from the SAML response.
- Warn the customer that changing a user's email in the IdP creates a new Frontegg user rather than updating the existing one.
- After the switch, compare the IdP's assigned users with the tenant's Frontegg users and resolve differences. If the customer uses Microsoft Entra ID, check that group and user updates arrive: Frontegg notes that Entra "Replace" requests can be skipped and Support can enable a replace-as-add setting.
Sessions and tokens during the transition
- Refresh tokens do not move between providers. Under OAuth 2.0, refresh tokens are issued by an authorization server and used only with that server. Users must re-authenticate after cutover.
- Accept both issuers in your APIs for the window. If your backend validates Auth0 access tokens, add validation for Frontegg tokens (issuer and signing keys) before the first cohort moves, and remove the Auth0 issuer after the last one.
- Plan for user ID changes. Use the Auth0 ID you stored on each Frontegg user (
externalIdormetadata.auth0_id) to update foreign keys, or translate IDs at the edge until you do. - Social login users. List users who sign in with Google, Microsoft or other social providers and configure the same providers in Frontegg before their cohort moves. Frontegg does not document how social sign-ins link to imported users. Test a social-login cohort on a test tenant before moving it.
- Emails and webhooks during import. Frontegg's docs don't say whether emails or webhooks fire during bulk import. Test with a small tenant first.
Rollback
Write the rollback before the first wave:
- Login routing. Change the
AUTH_INITIATEDrouting so the cohort's logins redirect back to your Auth0 login page. - SSO customers. Because the customer kept the Auth0 SAML application, rollback is a routing change. Without that, rollback needs another IdP change from the customer.
- SCIM customers. Ask the customer to point provisioning back to Auth0, and re-run your reconciliation.
- Data drift. Users who signed up, changed passwords or enrolled MFA in Frontegg during the window do not exist in that state in Auth0. List them and decide how they return.
- Keep Auth0 in place. Keep Auth0 users and the Auth0 tenant in place until the last cohort has run on Frontegg for an agreed period.
Update your application
- Replace the Auth0 SDK with the Frontegg SDK for your stack, and update callback and logout URLs.
- Update API token validation (see "Sessions and tokens").
- List your Auth0 machine-to-machine applications and plan their replacement.
- Rebuild Rules and Actions logic (see the inventory).
Cutover checklist
- A test tenant signs in with password, MFA and SSO in Frontegg.
- User counts per tenant match between Auth0 and Frontegg.
- Roles and permissions match for a sample of users in every tenant.
- Each SSO customer in the cohort has added the Frontegg SAML application and passed a test sign-in.
- Each SCIM customer in the cohort points provisioning at Frontegg, and the reconciliation is clean.
- Your APIs accept Frontegg tokens.
- Rollback is written down and rehearsed for this cohort.
- Auth0 stays available until the last cohort has signed in through Frontegg for an agreed period.
FAQ
Can users keep their Auth0 passwords?
Yes, through Path 3, if Auth0 Support provides the password-hash export (not available on Auth0's Free plan; Auth0 does not commit to a delivery date). Import the hashes with passwordHashType: bcrypt. In our test, a user imported with a bcrypt hash we generated signed in with the original password; we did not test with a real Auth0 export, so try one real user first. Without the export, users reset their password or use passwordless sign-in.
Do my SSO customers have to change anything?
Yes. Each customer's IdP must be updated with Frontegg's ACS URL and SP entity ID: Frontegg's ACS URL path differs from Auth0's, and Frontegg checks the SAML Audience against its own SP entity ID. Ask each customer to add a new SAML application for the transition.
Do I need Auth0 Organizations to migrate tenants?
No. Frontegg reads a tenant ID field you store on each Auth0 user. If your tenants live in Organizations: before migrating, map each Auth0 Organization to a Frontegg tenant ID and tag each user accordingly so they land in the right tenant.
Does Frontegg migrate Auth0 Rules and Actions?
Frontegg documents no automatic path. Rebuild the logic with prehooks and other Frontegg configuration.
Can I add Frontegg SSO or SCIM to Auth0 without migrating?
No. Frontegg SSO/SCIM is part of Frontegg's full CIAM platform. Enabling it for a tenant means that tenant authenticates through Frontegg; it cannot be used as a standalone SSO/SCIM module alongside another provider.
Do users stay signed in through the cutover?
No. Users must re-authenticate after cutover.
Can I keep my Auth0 user IDs?
Not as the Frontegg user ID: every user gets a new one. You can store the Auth0 user_id on the Frontegg user at import, in the externalId field (our suggestion for bulk and single-user imports) or in metadata as auth0_id (what the "Migrate from Auth0" route does), and use it to map your own records.
Do users have to set up their authenticator app again?
Not if Auth0 Support gives you their authenticator-app (TOTP) secrets and you import them. Import each secret as a Base32 string in authenticatorAppMfaSecret. In our test with one user and a secret we generated, a code computed from the imported secret was accepted at sign-in with no re-enrollment. The import does not check the encoding, so test one real user first. Without the secret, users enroll again.
Next steps
- Read the Frontegg docs: Migrate users, API migration (includes Migrate from Auth0), CSV migration, user pools and user-pool providers, SAML SSO, SCIM provisioning, prehooks.
- Plan the waves: Gradual CIAM migration guide.
- Compare the products first: Frontegg vs Auth0. Check pricing for the Enterprise Connections (SSO/SCIM) your plan includes: Pay as you go lists 5, and Enterprise includes everything in Pay as you go (as of November 2026).
- Planning a migration with many SSO or SCIM customers? Talk to our team.
Put this into practice with Frontegg
Frontegg is customer identity and access management (CIAM) for B2B SaaS. It's free up to 7,500 monthly active users, including 5 SSO/SCIM connections.
Start for free