Skip to main content

Auth0

Auth0's tenant logs record every login and signup to the applications a tenant serves, each multi-factor prompt and its outcome, password changes and breached-password detections, the blocks raised by Auth0's attack protection, and every change an administrator or a script makes through the Dashboard or the Management API. Fluency polls the tenant's GET /api/v2/logs endpoint every five minutes and writes the events into a datalake index.

Authentication is a Machine to Machine application in your tenant, authorized for the Auth0 Management API with the single permission read:logs; the collector trades its Client ID and Client Secret for a short-lived access token. Auth0 is Okta's customer-identity platform and not the Okta org your employees sign in to: if your administrators sign in at manage.auth0.com and the tenant domain ends in auth0.com, this is the right page; an Okta org (*.okta.com) is collected by Okta.

The setup has two halves:

  1. In Auth0: signed in to the Dashboard with the Admin role, create a Machine to Machine application under Applications → Applications, authorize it for the Auth0 Management API with read:logs only, and copy its Domain, Client ID and Client Secret from its Settings tab.
  2. In Fluency: install the Auth0 application template and paste those three values in.

What arrives​

StreamWhat it holdsLands in
Tenant logsEvery event in the tenant's log: successful and failed logins and signups, MFA prompts and results, password and email changes, breached-password detections, attack-protection blocks, token exchanges, and Dashboard and Management API changes, each with the user, application, connection, IP address and location it concerns.The Auth0 index

The logs API is on every Auth0 plan, Free included, but the plan decides how long Auth0 keeps the log, between 1 and 30 days: an outage longer than your tenant's retention loses events for good, and the first collection reaches back 24 hours (retention).

Record layout, event codes and ordering are in Reference.

Before you begin​

Sign in to the Auth0 Dashboard with the Admin role. Creating an application and authorizing it for the Management API takes that role, and the narrower ones cannot do it: Editor - Specific Apps, for example, is "Update-only access for specific applications. Users cannot create new applications."

Development, staging and production are separate Auth0 tenants, each with its own log and its own applications. Each needs its own Machine to Machine application and its own installation in Fluency, with its own index name (Install the Application).

Part 1: Auth0​

1. Create a Machine to Machine application​

In the Auth0 Dashboard, go to Applications → Applications and click Create Application.

Create application dialog with the Name field and four application types, Machine to Machine Applications selected, above the Cancel and Create buttons

  1. In Name, enter a name that identifies the consumer, such as Fluency log collector. Auth0 writes it as client_name on every event this application causes, including the collector's own token requests, which is how you will recognise it in Confirm it is running.
  2. Under Choose an application type, select Machine to Machine Applications. An application of another type either cannot use the Client Credentials grant the collector authenticates with (its token request is refused with unauthorized_client) or is not authorized for the Management API.
  3. Click Create.
Do not reuse one

A tenant often already has a Machine to Machine application authorized for the Management API, typically one created from its API Explorer tab. Auth0 says that one "has been granted all the Management API scopes": its secret can create users, change connections and grant itself more. Create a dedicated application (why).

2. Authorize it for the Management API with read:logs​

Clicking Create opens Authorize Machine to Machine Application.

Authorize Machine to Machine Application dialog with Auth0 Management API selected, the Permissions search box filtered to logs showing read and read ticked, and the Authorize button

  1. In the API list, select Auth0 Management API. The list shows it with its identifier, https://<your Auth0 domain>/api/v2/.
  2. Type logs into the Permissions search box and tick read:logs.
  3. Click Authorize.

read:logs is the only permission the collector uses, and it is read-only. The search also shows read:logs_users, which the logs endpoint accepts as well: ticked alongside, as in the capture, it does no harm and adds nothing. Do not click Select: All: it grants every Management API permission, including the two that let the client grant itself more (permissions).

If the dialog was closed before Authorize, or an existing installation reports insufficient_scope, fix the grant in place: go to Applications → APIs → Auth0 Management API, open the Machine To Machine Applications tab, switch on the toggle beside the application, expand its row, tick read:logs and click Update. The Client ID and Client Secret do not change, and a running installation picks the change up the next time the collector obtains a token, because a token keeps the permissions it was issued with for its 24-hour lifetime.

3. Copy the Domain, Client ID and Client Secret​

Open the application's Settings tab.

Application page for a Machine to Machine application, with the Quickstart, Settings, Credentials, APIs and Organizations tabs and a banner about a quota of 1,000 tokens per month

The banner about "up to 1,000 tokens per month" is the tenant's machine-to-machine token quota, and the collector does not draw on it (authentication).

The three values are under Basic Information:

Basic Information section with the Name, Domain, Client ID and Client Secret fields; the Client Secret is hidden behind an eye icon and a copy button

ValueWhere it goes in Fluency
DomainThe tenant domain field: <tenant>.<region>.auth0.com, such as acme.us.auth0.com (US tenants created before regional domains are acme.auth0.com).
Client IDThe Client ID field.
Client SecretThe Client Secret field. The eye icon reveals it and the copy icon copies it.

The secret stays readable here for as long as the application exists, so there is no one-time copy to miss. Treat it as a password all the same: it is the only thing needed to read the tenant's whole log, user names, email addresses and IP addresses included. Leave the Authentication Method on the application's Credentials tab on Client Secret (Post): the collector sends the secret in the body of its token request, and Private Key JWT has no secret for it to send.

Not a custom domain

If your users sign in at a custom domain such as login.example.com, the Domain field still shows the tenant's Auth0 domain: copy that. Auth0 recognises the Management API only on its own domain, so a custom domain is refused on the first token request with 403 access_denied and Service not found (why).

Optional: verify the credentials before you leave Auth0

Two calls, run from anywhere with internet access: the first exercises the domain, the credentials and the Management API grant; the second, the permission.

DOMAIN="acme.us.auth0.com" # step 3: the Auth0 domain, no https://
CLIENT_ID="…" # step 3
CLIENT_SECRET="…" # step 3

# 1. A token for the Management API
curl -sS --request POST "https://$DOMAIN/oauth/token" \
--data-urlencode grant_type=client_credentials \
--data-urlencode client_id="$CLIENT_ID" \
--data-urlencode client_secret="$CLIENT_SECRET" \
--data-urlencode audience="https://$DOMAIN/api/v2/"

A good answer looks like this, and its scope lists every permission the application holds:

{"access_token":"eyJ…","scope":"read:logs","expires_in":86400,"token_type":"Bearer"}

read:logs (or read:logs read:logs_users) is what you want. Anything more is a grant to trim in step 2.

# 2. One log event with that token
TOKEN="eyJ…" # access_token from call 1
curl -sS -o /dev/null -w '%{http_code}\n' \
-H "Authorization: Bearer $TOKEN" \
"https://$DOMAIN/api/v2/logs?per_page=1"
ResponseWhat it means
200 from call 2Domain, credentials, grant and permission are all good.
404 · Unknown host: <domain>No tenant at that domain: a typo, or the wrong region (.eu. for .us.). Every name under auth0.com resolves, so a wrong domain reaches Auth0 rather than failing to connect. Recopy the Domain (step 3).
401 · {"error":"access_denied","error_description":"Unauthorized"}Wrong Client ID or Client Secret. Auth0 checks these first, so this answer hides every error below it until it is fixed.
403 · access_denied · Service not found: https://…/api/v2/A custom domain: use the Auth0 domain (step 3).
403 · access_denied · Client is not authorized to access "https://…/api/v2/"Not authorized for the Management API (step 2).
403 · unauthorized_client · Grant type 'client_credentials' not allowed for the client.Not a Machine to Machine application (step 1).
403 from call 2 · insufficient_scope · Insufficient scope, expected any of: read:logs,read:logs_usersAuthorized without read:logs: add it (step 2) and request a new token.
429The tenant's Management API rate limit is spent, usually by other automation. Wait a minute and retry (rate limits).

Part 2: Fluency​

Install the Application​

In the navigation rail, open Applications and click Install Application, then choose Auth0 from the Cloud-based Business Softwares category of the Application Catalog.

The three parameters are required and open empty. Their labels are long; each is named in full below.

ParameterNotes
Auth0 tenant domain, e.g. acme.us.auth0.com (the canonical *.auth0.com domain, not a custom login domain)The Domain from step 3. A leading https:// and anything after the host are ignored.
Client ID of a Machine to Machine application authorized for the Auth0 Management API with the read:logs scopeThe Client ID from step 3.
Client Secret of that Machine to Machine applicationThe Client Secret from step 3. Masked as you type.
datalakePre-filled managed.
datalake index namePre-filled Auth0. Two applications writing to the same index name in the same lake will collide, and the second one aborts. For a second Auth0 tenant, give its installation its own Instance name and its own index name, such as Auth0Prod.

The collector takes every event type the tenant logs; nothing on the form selects among them.

datalake and datalake index name sit in the collapsed Advanced configuration section below Configuration; click its heading to reach them.

Install Auth0 form with the Application section&#39;s Instance name and Display name fields, the Configuration section&#39;s tenant domain, Client ID and Client Secret fields, and Advanced configuration expanded to datalake and datalake index name, above Cancel, Dry run and Install Application

Leave Instance name and Display name at default / Default unless you are installing a second instance for another tenant, in which case give each one a name you will recognise on the applications list.

Click Dry run first to have the platform check the values before anything is installed, then click Install Application. The Applications page opens with the notice Default is launching., and the new application is listed with a green Running badge once the pipeline is up.

Confirm it is running​

A Running badge means the pipeline started, not that Auth0 accepted the credentials. Auth0 logs the collector's own token requests, so the check below works even on a quiet tenant.

  1. The application is up. On Applications, Auth0 is listed with Default beneath it and a green Running badge. Click its row to open the application details: the Pipeline card draws the Auth0 data source feeding a router and the destination it writes to, and the Actions list records addDatalakeIndex managed-Auth0. A red Error badge means the pipeline aborted or reported errors in the last hour, and the details page shows the error message beneath the summary figures.
  1. Find the collector in Auth0's own log. Each time the collector obtains a token, Auth0 logs a seccft event, "Successful Exchange of Access Token for a Client Credentials Grant", naming the application. In the Auth0 Dashboard, open Monitoring → Logs and look for events from the application you created in step 1. A feccft from it instead ("Failed exchange of Access Token for a Client Credentials Grant") means Auth0 refused the credentials, and the event's description says why.
  2. Find the same events in Fluency. Allow ten minutes, then query the Auth0 index for records whose @auth0.type is seccft and whose @auth0.client_name is the application's name. The first collection reaches back 24 hours, so the token requests from the verification calls and the sapi events Auth0 logged while you created the application are already among them.

If the collector's seccft events are in Auth0's log and not in Fluency after fifteen minutes, look for an Auth0 Poll Error notification; its text names the failing call and the likely cause (Troubleshooting). Confirm data is arriving has the platform-side checks: application health, ingress volume and storage-side queueing.

Once the application reads Running and the collector's seccft events are in the Auth0 index, setup is complete.

Maintenance​

The clock to watch is Auth0's retention. The collector keeps a checkpoint (the log_id of the last event it collected) and catches up from it after an outage on either side, but only as far back as Auth0 still holds, and Auth0 does not say when it has deleted events past the checkpoint: it carries on from the oldest event it still has. The collector checks for that whenever it has not reached the end of the log for more than 23 hours, and sends an Auth0 Warning naming the period whose events may have been deleted. It also sends one when a poll ends more than an hour behind real time, which means it is falling behind the tenant's volume.

Rotating the Client Secret​

Template parameters are read-only after install, so a new secret means a new application. Rotating in Auth0 retires the old secret almost at once ("New secrets may be delayed up to thirty seconds while rotating"), so do both steps together:

  1. In Auth0, open the application, scroll to the Danger Zone at the foot of its Settings tab, click Rotate and confirm. Copy the new Client Secret; the eye icon beside it on the Credentials tab reveals it.
  2. In Fluency, uninstall the Auth0 application and install it again with the same domain and Client ID and the new secret. To uninstall, click Uninstall at the top right of the application's details page (v1: the red Uninstall button at the foot of its details panel on Platform → Applications).

A fresh installation's first poll reaches back 24 hours, so a gap of less than a day is filled automatically, and events the previous installation already collected in those 24 hours arrive a second time; deduplicate on @auth0.log_id.

Removing the integration​

  1. Uninstall the Auth0 application in Fluency, so nothing is polling: the Uninstall button at the top right of its details page (v1: the red Uninstall button at the foot of its details panel on Platform → Applications).
  2. In Auth0, delete the application from the Danger Zone at the foot of its Settings tab. That retires its Client Secret; a token already issued stays valid until it expires, because, as Auth0 puts it, "Once issued, an access token cannot be revoked."

Troubleshooting​

Collection errors arrive as Auth0 Poll Error or Auth0 Init Error notifications, sent when an error first appears or changes and again once a day while it persists. Each one quotes Auth0's response and adds a hint. The Auth0 side of the same failure is a feccft event in Monitoring → Logs.

SymptomLikely causeFix
token request: HTTP 404, Unknown hostThe domain names no tenant: a typo or the wrong regionReinstall with the Domain from step 3.
token request: HTTP 401 access_denied: UnauthorizedWrong Client ID or Client Secret, or the secret was rotated in Auth0Reinstall with the current values.
token request: HTTP 403 access_denied: Service not foundA custom domain was enteredReinstall with the Auth0 domain (step 3).
token request: HTTP 403 access_denied: Client is not authorized to access …The application is not authorized for the Management API, or its grant was removedAuthorize it again (step 2); no reinstall. Collection resumes at the next attempt, which after repeated failures can be up to an hour away.
token request: HTTP 403 unauthorized_clientNot a Machine to Machine applicationCreate one (step 1) and reinstall with its values.
GET /api/v2/logs: HTTP 403 insufficient_scopeThe grant lacks read:logsAdd it (step 2); no reinstall. It takes effect when the collector next obtains a token, within 24 hours.
Running, no error, and no eventsNot a quiet tenant: Auth0 logs every token exchange, the collector's own included, so a working installation always has something to collectLook for the application's seccft or feccft events in Monitoring → Logs (Confirm it is running); none at all means the collector is not reaching the tenant.
An Auth0 Warning that events may have been deleted by Auth0 before they were collectedCollection stopped for longer than the tenant's retentionNot recoverable from Auth0; the warning names the period, and collection continues from the oldest event Auth0 still holds (retention).
An Auth0 Warning that collection is more than 1h0m0s behind real timeThe tenant logs faster than its Management API rate limit lets the collector read, often because other automation shares the limitCollection continues; on plans with short retention, falling further behind loses events (rate limits).
Events out of chronological orderExpected: Auth0 orders the log by log_id, the time it received an event, not by dateSort on @auth0.date (or @timestamp), not on arrival order (ordering).
The same event twiceThe overlap after a reinstallDeduplicate on @auth0.log_id (rotation).
Large numbers of seccft and sertft eventsExpected: Auth0 logs every machine-to-machine and refresh-token exchange in the tenantFilter them out in searches and rules; the form has no setting that drops them.

Reference​

What the tenant log looks like once it lands and how the collector reads it, for searches and detection rules written against the Auth0 index, and the reasoning behind the permission and domain choices in Part 1.

Stream, endpoint and permission
StreamEndpointPermissionContents
Tenant logsGET https://<domain>/api/v2/logs, read by checkpointread:logs (read:logs_users is also accepted)Every event type Auth0 logs for the tenant.
Permissions and the dedicated application

Why not reuse an application. An application created from the Management API's API Explorer tab is one Auth0 says "has been granted all the Management API scopes": its Client Secret can create users, change connections and, through create:client_grants, grant itself more. Auth0's own advice is to keep consumers apart:

If you have multiple applications that should access the Management API, then you should create separate machine-to-machine applications for each application in Auth0 instead of just a single machine-to-machine application.

A dedicated application also means that rotating its secret disturbs nothing else.

Why not Select: All. It grants every Management API permission, including the two Auth0 warns about:

Use the update:client_grants and create:client_grants scopes with only high-privileged applications, as they allow the client to grant further permissions to itself.

read:logs_users is the per-user view of the same log. The logs endpoint accepts either permission; read:logs is the one the collector needs.

Authentication, the token quota and custom domains

Token request. POST https://<domain>/oauth/token with grant_type=client_credentials, the Client ID and Client Secret in the form body (Auth0's Client Secret (Post) method), and audience=https://<domain>/api/v2/. The token lasts 86,400 seconds (24 hours) by default and is reused until it expires; it is never written to disk. A 401 from the logs endpoint (a key rotation, for example) makes the collector request a new token once before failing.

Token quota. Management API tokens do not count toward the tenant's machine-to-machine token quota, the "up to 1,000 tokens per month" on the application's Settings tab. In Auth0's words, "Tokens issued for internal Auth0 audiences do not count toward your quota", and the Management API is an internal audience.

Custom domains. The audience https://<domain>/api/v2/ is recognised only on the tenant's Auth0 domain: "Continue to use your default tenant domain name (such as https://{yourDomain}/userinfo and https://{yourDomain}/api/v2/) instead of your custom domain when specifying an audience."

Retention by plan

"Your Auth0 log retention period depends on your subscription level."

PlanRetention
Free (Starter)1 day
Essentials (B2C or B2B)5 days
Professional (B2C or B2B)10 days
Enterprise30 days

Past that, the events are gone from Auth0, and nothing reaches further back. Two consequences follow. An outage longer than your plan's retention loses the events in between permanently, and on the Free plan that is anything over a day. And the lake is where Auth0 history longer than a month has to live, which is an argument for installing this before you need it: the first collection reaches back 24 hours and no further.

Sample record and the fields that matter in a detection

A failed password, as the collector forwards it (trimmed; identifiers replaced). Auth0's event is kept unchanged under @auth0, and @timestamp is its date:

{
"@auth0": {
"log_id": "90020261111152233019003000000000000001223372061512345678",
"date": "2026-11-11T15:22:32.927Z",
"type": "fp",
"description": "Wrong email or password.",
"connection": "Username-Password-Authentication",
"connection_id": "con_XXXXXXXXXXXXXXXX",
"client_id": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
"client_name": "Customer Portal",
"ip": "203.0.113.7",
"user_agent": "Chrome 141.0.0 / Windows 10.0.0",
"user_id": "auth0|65f0c0ffee0000000000abcd",
"user_name": "jane@example.com",
"strategy": "auth0",
"strategy_type": "database",
"hostname": "login.example.com",
"isMobile": false,
"location_info": { "country_code": "US", "city_name": "Boston" },
"details": { "error": { "message": "Wrong email or password." } }
},
"@event_type": "auth0",
"@eventType": "Auth0Log",
"@timestamp": 1794410552927
}

The fields that carry the weight in a detection:

  • log_id is unique per event: the deduplication key. It begins with the time Auth0 received the event, so it sorts in arrival order.
  • date is when the event happened, and the field to sort on.
  • type is Auth0's event code (event codes) and description its human-readable text.
  • user_id and user_name name the user, client_name the application, connection the identity source, and ip, user_agent and location_info where the request came from. Names are inline, so events are readable without a second lookup.
  • details holds data specific to the event type. On a sapi event it holds the Management API request (method, path and body) and who made it.

Which fields are present depends on the event type.

Event codes worth knowing

Auth0 adds codes over time, and its event type reference lists them all. The prefixes follow a pattern: s… success, f… failure, se… / fe… a successful or failed token exchange, gd_… multi-factor (Guardian), limit_… a block. The ones a security team usually starts with:

GroupCodes
Failed authenticationf, fp (wrong password), fu (unknown user), fs (failed signup)
Attack protectionlimit_wc (an IP blocked after too many failed logins to one account), limit_sul (logins per IP), limit_mu (an IP blocked for too many failed logins or signups), pla (bot detection, before login)
Breached passwordspwd_leak, signup_pwd_leak, reset_pwd_leak
Multi-factorgd_auth_failed, gd_auth_rejected (a push rejected by the user), gd_enrollment_complete, gd_unenroll, mfar (MFA prompted)
Token abuseferrt (a rotating refresh token reused), feccft (failed client-credentials exchange)
Account changesscp (password changed), sce (email changed), sdu and du (user deleted)
Administrationsapi (a Dashboard or Management API change), fapi (a failed one), mgmt_api_read (a Management API read that returned secrets)
Platformapi_limit, api_limit_warning (rate limits reached or close)
Ordering and duplicates

The collector reads the log the way Auth0 recommends for export, by checkpoint, and Auth0 returns each event once, in log_id order: "The logs are ordered by the log_id, rather than log generation time." An event Auth0 receives late therefore arrives after events dated later than it. Sort on date, never on arrival order. Duplicates occur only when an installation is replaced (Rotating the Client Secret); log_id removes them.

What does not arrive
  • Users, applications and connections as records. The template collects the log only. The events name all three inline, so none is needed to read them.
  • Tenant configuration (attack-protection settings, MFA factors, the application list). Changes to it arrive as sapi events; its current state does not.
Collection behaviour and output format
  • Cadence. Every five minutes. A poll pages for at most four minutes; anything left is collected by the next poll.
  • Checkpoint paging. Each poll asks for the events after the checkpoint (from=<log_id>&take=100), then follows the Link: rel="next" header page by page, as Auth0 asks, until a short page shows it has reached the end of the log. Search mode (q) is never used: it reaches only the first 1,000 results and lags behind the log.
  • First run. With no checkpoint, collection starts 24 hours back, from a synthetic log_id (900 followed by the UTC time).
  • Progress. Events are written in files of up to 10,000, and the checkpoint advances with each file, so a failure part-way keeps what was already collected.
  • Retention gaps. When no poll has reached the end of the log for more than 23 hours, the poll first asks Auth0 for the oldest event it still holds. If that event is past the checkpoint, events in between have been deleted, and an Auth0 Warning names the period.
  • Failures. Network errors, 429 and 5xx are retried with backoff. A poll that fails without collecting anything delays the next attempt by 5, 10, 20, 40 and then 60 minutes; one that collected something first keeps the normal cadence.

Output format. Gzipped JSON lines, one event per line, with sourcetype and import source auth0. Each line carries the raw Auth0 event unchanged under @auth0, plus @event_type: auth0, @eventType: Auth0Log and @timestamp (the event's date, in epoch milliseconds). Codes Auth0 introduces later arrive as-is, with their type and description, and need no collector change.

Why polling, not Log Streams. Auth0 can also push its log to an HTTPS endpoint (a Log Stream). The template polls instead because polling works on every plan, Free included, needs only the three values above, and needs no endpoint reachable from Auth0. An existing Log Stream to another product is independent of this integration and keeps working.

Rate limits

The Management API rate limit is per tenant and shared with everything else that calls it, the customer's own automation included. The collector pauses when x-ratelimit-remaining reaches 0 and, on 429, waits until x-ratelimit-reset.

PlanLimit on reading logs
Free2 requests per second, for the whole Management API
Essentials, Professional100 requests per minute (burst 10) for GET /api/v2/logs: about 10,000 events a minute
Enterprise, production tenant16 requests per second (burst 50)

Reaching the limit writes api_limit and api_limit_warning events into the tenant log, which the collector then collects.

Auth0 documentation

Fluency

Other integrations