CIAM

How to Migrate from Auth0 to Frontegg

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:

PathWhat it doesAuth0 stays live?Best when
1. "Migrate from Auth0" API routeFrontegg reads users from your Auth0 tenant through an Auth0 machine-to-machine app and creates them in FronteggUntil you switch loginYou 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 poolFrontegg authenticates users against Auth0 while you run bothYesYou need a coexistence period before cutover
3. Export, then bulk API or CSV importYou 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 loginYou 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_metadata or user_metadata (you name the field, for example tenant_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 migrationId you 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_id values. 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

  1. Create or reuse an Auth0 machine-to-machine application authorized on the Auth0 Management API with read:users, read:user_idp_tokens and read:roles. You can check and update scopes with Auth0's client-grants endpoints.
  2. Store the tenant ID on every Auth0 user in app_metadata or user_metadata.
  3. Create the matching tenants in Frontegg, keeping the IDs you stored.
  4. Call the "Migrate from Auth0" route with your Auth0 domain (including https://), clientId, secret, isTenantIdOnUserMetadata and tenantIdFieldName. Frontegg creates each user and assigns them to the tenant whose ID matches the field.
  5. 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:

  1. Set the application's client authentication method to Client Secret (Post).
  2. Enable the Password grant type.
  3. Authorize the app on the Auth0 Management API and grant read:users and read:roles.
  4. Set app_metadata.tenantId on each user to the Frontegg tenant ID.
  5. 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

  1. Export users from Auth0. Auth0's bulk export job (POST /jobs/users-exports) produces NDJSON or CSV. If your tenant ID lives in app_metadata, note that CSV exports cannot include app_metadata or user_metadata as whole objects: name the subfield (for example app_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).
  2. 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.
  3. Map fields to Frontegg's migration payload. The basics are email, tenantId, name, metadata, roleIds and verifyUser (set it to true if email verification is on, so migrated users are marked verified). Then:
    • Passwords. Send passwordHash with passwordHashType. Frontegg's migration docs list bcrypt as supported, which matches Auth0's sample hashes.
    • Phone numbers. Send phoneNumber with phoneNumberType (auth or mfa). 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 with phoneNumberType: mfa.
    • Authenticator apps. Send each user's TOTP secret in authenticatorAppMfaSecret as 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 to local, which is what password users need. The API reference lists local, saml, google, github, facebook, microsoft, scim2, slack and apple; in our test auth0 was rejected with HTTP 400. We have not tested whether a user imported with a social value such as google can 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_id as externalId. 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 in metadata as auth0_id instead, which also works. We suggest externalId because 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, use metadata.auth0_id for all of them so the ID lives in one place.
  4. Import through the bulk endpoint (/identity/resources/migrations/v1/local/bulk) in batches of up to 1,000 users, polling each migrationId. Or use CSV import, where only email and tenantId are 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 a migrationId instead of a per-user result, so check the migration status after re-running a batch.
  5. Respect limits: name up to 256 characters; metadata and vendorMetadata up 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_INITIATED prehook. 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 IdPAuth0 today (default)Frontegg
ACS / reply URLhttps://{yourDomain}/login/callback?connection={connectionName}{your Frontegg or custom domain}/auth/saml/callback
SP entity ID / audienceurn:auth0:{tenant}:{connectionName}, unless you overrode itThe SP entity ID you set in Frontegg; the SAML Audience must match it
IdP signing certificateUploaded to the Auth0 connectionApplied to the Frontegg connection; the response must be signed with it
NameIDPer connectionMust 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:

  1. 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.
  2. Create the customer's connection on their Frontegg account (backoffice SSO tab or API), reusing their IdP metadata and signing certificate.
  3. 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.
  4. Agree a test window. Sign in with a test user from that customer, and check Audience, Destination, certificate and NameID if it fails.
  5. 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.
  6. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Warn the customer that changing a user's email in the IdP creates a new Frontegg user rather than updating the existing one.
  6. 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 (externalId or metadata.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_INITIATED routing 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

Looking to take your User Management to the next level?
Sign up. It's free