diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000000..1cd9745822
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,4 @@
+/articles/quickstart @auth0/dx-sdks-engineer
+/articles/libraries @auth0/dx-sdks-engineer
+/articles/cms @auth0/dx-sdks-engineer
+/articles/quickstart/webapp/express @pdillon
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 49861ab9d9..bd61ed03a3 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,8 +1,3 @@
diff --git a/.github/workflows/check-content-version.yml b/.github/workflows/check-content-version.yml
new file mode 100644
index 0000000000..8d471da8b9
--- /dev/null
+++ b/.github/workflows/check-content-version.yml
@@ -0,0 +1,22 @@
+name: Check Content Version
+
+on:
+ schedule:
+ - cron: '0 * * * *' # Runs every hour
+ workflow_dispatch: # Allows manual trigger from GitHub Actions tab
+
+jobs:
+ run-script:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v3
+
+ - name: Make script executable
+ run: chmod +x scripts/check-version.sh
+ shell: bash
+
+ - name: Run check-version.sh script
+ run: scripts/check-version.sh
+ shell: bash
\ No newline at end of file
diff --git a/.github/workflows/clean-redirects-pr.yml b/.github/workflows/clean-redirects-pr.yml
new file mode 100644
index 0000000000..06b704805c
--- /dev/null
+++ b/.github/workflows/clean-redirects-pr.yml
@@ -0,0 +1,34 @@
+# Cleanup redirects config file.
+name: Redirects cleanup PR
+
+on:
+ schedule:
+ - cron: '0 7 * * 1'
+ workflow_dispatch:
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Get current date
+ id: date
+ run: echo "current_date=$(date +'%Y-%m-%d')" >> $GITHUB_ENV
+ - name: Checkout
+ uses: actions/checkout@v2
+ - uses: actions/setup-node@v2
+ with:
+ node-version: '14.17'
+ cache: 'yarn'
+ - run: yarn
+ - run: yarn run clean-redirects
+ - name: Create Pull Request
+ id: cpr
+ uses: peter-evans/create-pull-request@v3
+ with:
+ commit-message: Redirects config cleanup ${{ env.current_date }}
+ committer: GitHub In the APIs section in dashboard, click the Create API button. Provide a Name and Identifier for your API. You must choose the RS256 signing algorithm. Once it is created, navigate to the Scopes tab and create the applicable scopes for your API. In the APIs section in dashboard, click the Create API button. Provide a Name and Identifier for your API. You must choose the RS256 signing algorithm. Once it is created, navigate to the Scopes tab and create the applicable scopes for your API. Create an Auth0 account (or login) navigate to the APIs section in Dashboard. Click the Create API button and provide a Name and Identifier for your API. You must choose the RS256 signing algorithm. Once it is created, navigate to the Scopes tab and create the applicable scopes for your API. Create an Auth0 account (or login) navigate to the APIs section in Dashboard. Click the Create API button and provide a Name and Identifier for your API. You must choose the RS256 signing algorithm. Once it is created, navigate to the Scopes tab and create the applicable scopes for your API.
+ Setup and configure analytics integrations with Auth0.
+
+ Learn how to integrate Facebook Analytics into your application using either the Facebook JavaScript SDK or the Facebook Pixel.
+
+ Learn how to integrate Google Analytics into your application.
+
- How to setup and configure analytics integrations with Auth0.
-
- This document will show you how to integrate Facebook Analytics into your application using either the Facebook JavaScript SDK or the Facebook Pixel.
-
- This document will show you how to integrate Google Analytics into your application.
-
+
\ No newline at end of file
+
\ No newline at end of file
diff --git a/articles/_includes/_ip_whitelist.md b/articles/_includes/_ip_whitelist.md
index 76a8d744b5..a3d9ad21b8 100644
--- a/articles/_includes/_ip_whitelist.md
+++ b/articles/_includes/_ip_whitelist.md
@@ -1,3 +1,3 @@
-## Network Firewall
-
+::: note Network Firewall
If you are behind a firewall, this feature may require [whitelisting of the appropriate Auth0 IP addresses](/guides/ip-whitelist) to work properly.
+:::
diff --git a/articles/_includes/_libraries_support_frameworks.html b/articles/_includes/_libraries_support_frameworks.html
index 3e3ec91472..b14527fae5 100644
--- a/articles/_includes/_libraries_support_frameworks.html
+++ b/articles/_includes/_libraries_support_frameworks.html
@@ -27,16 +27,6 @@
${http_method}
${path}
-
v1
-
-
- Auth0 ASP.NET 4.5 Owin
- v2
-
-
-
Auth0 ASP.NET
- v1
-
-
- OIDC Client for .NET Desktop and Mobile applications
v1
@@ -47,15 +37,5 @@
v3
-
- Auth0 with UWP applications
- v1
-
-
-
diff --git a/articles/_includes/_libraries_support_lock.html b/articles/_includes/_libraries_support_lock.html
index 54a62fd2f9..b23b2b155f 100644
--- a/articles/_includes/_libraries_support_lock.html
+++ b/articles/_includes/_libraries_support_lock.html
@@ -18,7 +18,7 @@
Auth0 application for Winforms and WPF
- v0.9
-
-
-
@@ -27,7 +27,7 @@
+ Lock.Android
v1
v2
-
+
+ Lock for iOS v1
v1
diff --git a/articles/_includes/_libraries_support_sdks.html b/articles/_includes/_libraries_support_sdks.html
index 662bb4932a..9fae1bad76 100644
--- a/articles/_includes/_libraries_support_sdks.html
+++ b/articles/_includes/_libraries_support_sdks.html
@@ -7,6 +7,16 @@
+
+ Auth0 Single Page Application SDK
+ v1
+
+
+
Auth0 React SDK
+ v1
+
+
- Auth0.js
v9
@@ -27,11 +37,6 @@
v4
-
- v3
-
-
Auth0 Java
v1
@@ -49,7 +54,7 @@
diff --git a/articles/_includes/_linking_accounts.md b/articles/_includes/_linking_accounts.md
index f79677c8ea..547909a2a2 100644
--- a/articles/_includes/_linking_accounts.md
+++ b/articles/_includes/_linking_accounts.md
@@ -1,4 +1,4 @@
-There may be situations when your users want to log in with multiple accounts that they own. In these cases, you may want to link these accounts together so that they are all reflected in the user's Auth0 profile. For example, if a user has signed up with an email and password (which provides very little information about them), you can ask them to link their account to an OAuth provider like Facebook or Google to gain access to their social profile. For a detailed description of linking accounts, see the [full documentation](https://auth0.com/docs/link-accounts).
+There may be situations when your users want to log in with multiple accounts that they own. In these cases, you may want to link these accounts together so that they are all reflected in the user's Auth0 profile. For example, if a user has signed up with an email and password (which provides very little information about them), you can ask them to link their account to an OAuth provider like Facebook or Google to gain access to their social profile. See [User Account Linking](/users/concepts/overview-user-account-linking) for details.
## Linking Accounts
diff --git a/articles/_includes/_lock_auth0js_deprecations_notice.md b/articles/_includes/_lock_auth0js_deprecations_notice.md
index f989f7af01..9e03f9bb98 100644
--- a/articles/_includes/_lock_auth0js_deprecations_notice.md
+++ b/articles/_includes/_lock_auth0js_deprecations_notice.md
@@ -1,3 +1,3 @@
::: panel-warning Lock and Auth0.js Deprecations
-The Lock v8, v9, and v10 widgets as well as the Auth0.js v6, v7, and v8 SDKs are deprecated and should be migrated away from prior to their removal from service on July 16, 2018. The [Deprecation Guidance](/migrations/guides/legacy-lock-api-deprecation) page provides details about update recommendations.
+The Lock v8, v9, and v10 widgets as well as the Auth0.js v6, v7, and v8 SDKs are deprecated and should be migrated away from prior to their removal from service on July 16, 2018.
:::
\ No newline at end of file
diff --git a/articles/_includes/_logout_url.md b/articles/_includes/_logout_url.md
new file mode 100644
index 0000000000..ed3e9ac189
--- /dev/null
+++ b/articles/_includes/_logout_url.md
@@ -0,0 +1,11 @@
+
+
+### Configure Logout URLs
+
+A logout URL is a URL in your application that Auth0 can return to after the user has been logged out of the authorization server. This is specified in the `returnTo` query parameter. The logout URL for your app must be added to the **Allowed Logout URLs** field in your Application Settings. If this field is not set, users will be unable to log out from the application and will get an error.
+
+<% if (typeof(returnTo) !== "undefined") { %>
+ ::: note
+ If you are following along with the sample project you downloaded from the top of this page, the logout URL you need to add to the **Allowed Logout URLs** field is `${returnTo}`.
+ :::
+<% } %>
diff --git a/articles/_includes/_metadata_on_signup_warning.md b/articles/_includes/_metadata_on_signup_warning.md
new file mode 100644
index 0000000000..1af9aab000
--- /dev/null
+++ b/articles/_includes/_metadata_on_signup_warning.md
@@ -0,0 +1,3 @@
+::: note
+When setting the `user_metadata` field using the Authentication API's [Signup endpoint](/api/authentication?javascript#signup), you are limited to a maximum of 10 `String` fields and 500 characters.
+:::
diff --git a/articles/_includes/_native_passwordless_warning.md b/articles/_includes/_native_passwordless_warning.md
index 11aeffa50a..04eaae8300 100644
--- a/articles/_includes/_native_passwordless_warning.md
+++ b/articles/_includes/_native_passwordless_warning.md
@@ -1,3 +1,3 @@
::: warning
-Passwordless functionality should not be embedded in native apps until Auth0 libraries can be updated to properly support it. Until that time, passwordless authentication can still be achieved by using [Universal Login](/connections/passwordless/native-passwordless-universal) via the web.
+This functionality has been deprecated in native. After June 2017, tenants cannot use the native passwordless flow. The functionality will continue to work for tenants that currently have it enabled. If at some point the passwordless mode feature is changed or removed from service, customers who currently use it will be notified beforehand and given ample time to migrate.
:::
diff --git a/articles/_includes/_new_api.html b/articles/_includes/_new_api.html
index 5ef9d7f6ff..924a36341f 100644
--- a/articles/_includes/_new_api.html
+++ b/articles/_includes/_new_api.html
@@ -1,5 +1,5 @@
<% if (account.userName) { %>
- Auth0 PHP
- v5
+ v7.3
Analytics Integrations
+
+
diff --git a/articles/analytics/integrations/_install.md b/articles/analytics/integrations/_install.md
deleted file mode 100644
index a89abef1c4..0000000000
--- a/articles/analytics/integrations/_install.md
+++ /dev/null
@@ -1,17 +0,0 @@
-## Install
-
-To add the <%- name %> integration to your app, include a reference to the `Auth0 Analytics.js` script on any pages with Auth0 Lock. Include the script reference after Lock and set the configuration options before the script reference.
-
-```
-
-
-
-```
-
-::: note
-The script version above uses a placeholder version `X.Y.Z`. For example, to reference release 1.2.0 use `https://cdn.auth0.com/js/analytics/1.2.0/analytics.min.js`. To find the latest release, see the [releases on github](https://github.com/auth0/auth0-analytics.js/releases/).
-:::
\ No newline at end of file
diff --git a/articles/analytics/integrations/_usage.md b/articles/analytics/integrations/_usage.md
deleted file mode 100644
index 756e06685b..0000000000
--- a/articles/analytics/integrations/_usage.md
+++ /dev/null
@@ -1,19 +0,0 @@
-## Usage
-After installation on your site there is nothing else you need to do to start collecting data. Auth0 Analytics will immedately begin sending events to <%- name %>.
-
-You will see the following events being logged:
-
-* Auth0 Lock show
-* Auth0 Lock hide
-* Auth0 Lock unrecoverable_error
-* Auth0 Lock authenticated
-* Auth0 Lock authorization_error
-* Auth0 Lock forgot_password ready
-* Auth0 Lock forgot_password submit
-* Auth0 Lock signin submit
-* Auth0 Lock signup submit
-* Auth0 Lock federated login
-
-Note that some events that Lock emits like `hash_parsed` are not used for analytics purposes. Also, be aware that some events are only availible in newer versions of Lock. If you are using an older version of Lock you will only see some of these events. We suggest upgrading to the latest version of Lock to get the most of the Auth0 Analytics integration.
-
-For more information on the events that are sent see the [Lock API documentation](/libraries/lock/v10/api).
diff --git a/articles/analytics/integrations/facebook-analytics/index.md b/articles/analytics/integrations/facebook-analytics/index.md
deleted file mode 100644
index 6916c36db7..0000000000
--- a/articles/analytics/integrations/facebook-analytics/index.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-description: This article explains how to install and configure the Facebook Analytics for Auth0 integration.
-topics:
- - facebook
- - analytics
-contentType: how-to
-useCase:
- - manage-analytics
- - analyze-external-analytics
----
-# Facebook Analytics for Auth0
-
-This article explains how to install and configure the **Facebook Analytics for Auth0** integration. You can use this integration on your own page that is using [Lock](/libraries/lock) or you can use this on the [hosted Lock pages](/hosted-pages/login). Additionally, you will find instructions on how to configure funnels and reports inside of Facebook Analytics to get the most out of this integration.
-
-<%= include('../_install', { name: "Facebook Analytics" }) %>
-
-## Setup
-
-There are several ways you can use the Facebook Analytics integration. If you already have either the Facebook Tracking Pixel or the Facebook Javascript SDK referenced on your site, configure Auth0 Analytics with the `preload` option as shown below. If you don't have either script loaded you need to set your Facebook Analytics App ID using the Facebook Javascript SDK configuration below.
-
-### Using Facebook Javascript SDK (Recommended)
-
-The simplest configuration is to let the Analytics script load the Facebook Javascript SDK. You can do this by providing your Facebook Analytics App ID to the analytics options as shown below.
-
-```
-
-```
-
-If you have already loaded the Facebook Javascript SDK on your site, configure Auth0 Analytics to not load it again as shown below.
-
-```
-
-```
-
-### Using Facebook Pixel
-
-If you already have the Facebook Pixel installed on your site you can use that configuration mode. Note that with the Facebook Pixel, certain features of Facebook Analytics are not availible. The configuration for using the pixel is shown below.
-
-```
-
-```
-
-<%= include('../_usage', { name: "Facebook Analytics" }) %>
-
-## Reporting
-
-For the most up to date information on using Facebook Analytics, check out the [Facebook Analytics documentation](https://www.facebook.com/help/analytics/1710582659188030).
-
-We recommend [creating funnels](https://www.facebook.com/help/analytics/935921203105136) to measure the success of your aquistion and registration flows using these new events.
diff --git a/articles/analytics/integrations/google-analytics/index.md b/articles/analytics/integrations/google-analytics/index.md
deleted file mode 100644
index 5505583bcc..0000000000
--- a/articles/analytics/integrations/google-analytics/index.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-description: This article explains how to install and configure the Google Analytics for Auth0 integration.
-topics:
- - google
- - analytics
- contentType: how-to
-useCase:
- - manage-analytics
- - analyze-external-analytics
----
-# Google Analytics for Auth0
-
-This article explains how to install and configure the **Google Analytics for Auth0** integration. You can use this integration on your own page that is using Lock or you can use this on the hosted Lock pages. Additionally, you will find instructions on how to configure funnels and reports inside of Google Analytics to get the most out of this integration.
-
-<%= include('../_install', { name: "Google Analytics" }) %>
-
-## Setup
-
-There are several ways you can use the Google Analytics integration. If you already have the Google Analytics Script on your site, configure Auth0 Analytics with the `preload` option as shown below. If you don't have Google Analytics loaded you need to set your Google Analytics ID using the Google Analytics configuration below.
-
-### Google Analytics Script Already Loaded (Recommended)
-
-If you have already loaded the Google Analytics script loaded on your site, configure Auth0 Analytics to not load it again as shown below.
-
-```
-
-```
-
-### No Google Analytics Script
-
-If you are not using Google Analytics already you can have the Auth0 Analytics script load Google Analytics for you. To do this you need to set your Google Analytics ID in the options as shown below.
-
-```
-
-```
-
-<%= include('../_usage', { name: "Google Analytics" }) %>
-
-## Reporting
-
-For the most up to date information on using Google Analytics, check out the [Google Analytics documentation](https://support.google.com/analytics).
diff --git a/articles/analytics/integrations/index.md b/articles/analytics/integrations/index.md
deleted file mode 100644
index 626fe96bdd..0000000000
--- a/articles/analytics/integrations/index.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-url: /analytics/integrations
-section: articles
-classes: topic-page
-title: Analytics Integrations
-topics:
- - analytics
-contentType: index
-useCase:
- - manage-analytics
- - analyze-external-analytics
----
-
-Integrate Facebook Analytics with Auth0
+
Integrate Google Analytics with Auth0
+
Analytics Integrations
-
-
diff --git a/articles/anomaly-detection/breached-passwords.md b/articles/anomaly-detection/breached-passwords.md
deleted file mode 100644
index bb2a776a5e..0000000000
--- a/articles/anomaly-detection/breached-passwords.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-description: Explains why a user received a breached password email and general web security tips.
-topics:
- - security
- - passwords
-contentType: concept
-useCase: customize-anomaly-detection
----
-
-# Breached Password Security
-
-## What happened that I received an email saying "Please change your password immediately"?
-
-Your account could have possibly been hacked, compromised or stolen by a third party application that experienced a security breach. This breach did not happen to this account, but based on available data, your credentials may have been released. Since many people reuse passwords, we wanted to make sure you stay protected.
-
-You may also want to change your password at any other sites that you suspect you used a shared password.
-Here are links for password resets on commonly used sites:
-* [Google](https://www.google.com/accounts/recovery/)
-* [Facebook](https://www.facebook.com/settings)
-* [Twitter](https://twitter.com/settings/password)
-
-## General Security Tips
-
-You can't prevent certain sites from security breaches, but there are some things you can do to help keep your accounts safe.
-
-* **Check your emails carefully**
-Make sure to check where an email is coming from, and the links that they provide. Often phishing emails do not include your name but something generic such as "Dear Customer". Always do a password reset through the actual site itself.
-* **Never enter personal or financial information in an email**
-Emails in general are not very secure, so this is not a good way to communicate sensitive information. A trusted company/application would not ask for your information in this way. Also watch out to make sure you are not entering confidential information through false the links provided in emails. A secure website always starts with “https”.
-* **Never download files from unreliable sources**
-Most web browsers detect suspicious sites, when you try to access a malicious site, an alert message will appear. Never download files from suspicious emails or websites.
-* **Do not reuse passwords**
-When one site has a breach of user data, if you use the same credentials elsewhere, your information in other sites can also be accessed. There are many password tools out there to help you keep track of passwords.
-* **Use strong passwords**
-The longer a password is, the harder it becomes to guess. Try to make passwords long and use a mix of special characters, numbers and upper and lowercase letters.
-* **Keep software current**
-Applications release patches and updates when they find security vulnerabilities in their systems. Keeping your applications, web browsers and operating system up to date can help prevent security breaches.
\ No newline at end of file
diff --git a/articles/anomaly-detection/concepts/breached-passwords.md b/articles/anomaly-detection/concepts/breached-passwords.md
new file mode 100644
index 0000000000..92f077dc01
--- /dev/null
+++ b/articles/anomaly-detection/concepts/breached-passwords.md
@@ -0,0 +1,64 @@
+---
+title: Breached Password Security
+description: Understand why a user receives a breached password email and general web security tips.
+topics:
+ - security
+ - passwords
+contentType: concept
+useCase: customize-anomaly-detection
+v2: true
+---
+
+# Breached Password Security
+
+When a user receives an email requesting that they change their password immediately, it is because their account could be the victim of a security breach. This may be the result of a compromise by a third-party application that experienced a security breach. The breach may not have happened to this account, but based on available data, the user's credentials may have been released. Since many people reuse passwords, the request to change passwords is a precaution to make sure the user stays protected.
+
+Users may also want to change their password at any other sites where they suspect they used a shared password.
+
+## General security tips
+
+Users can't usually prevent certain sites from experiencing security breaches, but there are some things they can do to help keep their accounts safe.
+
+### Check emails carefully
+
+Check where an email is coming from and the links that they provide. Often phishing emails do not include a user's name but something generic such as "Dear Customer."
+
+### Reset passwords directly from sites
+
+Always do a password reset through the actual site itself not via potentially false links in emails. Also note that secure website URL always starts with `https`.
+
+Here are some links for password resets on commonly used sites:
+* [Google](https://www.google.com/accounts/recovery/)
+* [Facebook](https://www.facebook.com/settings)
+* [Twitter](https://twitter.com/settings/password)
+
+### Never enter personal or financial information in email
+
+Emails in general are not very secure and are not a good way to communicate sensitive information. A trusted company/application would not ask for information in this way. Make sure not to enter confidential information through false links in emails.
+
+### Never download files from unreliable sources
+
+Most web browsers detect suspicious sites. An alert should appear when you try to access a malicious site. Never download files from suspicious emails or websites.
+
+### Do not reuse passwords
+
+When one site has a breach of user data, if a user uses the same credentials elsewhere, information in other sites can also be accessed. The only way to prevent this is by not reusing passwords for multiple sites. The problem is that remembering countless passwords is frustrating and often impossible. One solution to this problem is the use of a password manager. There are many password managers available which can help users to use separate and secure passwords for each account, but at the same time not be responsible for remembering all of them.
+
+### Use strong passwords
+
+The longer a password is, the harder it becomes to be guessed via brute force methods. Many sites allow the use of pass-phrases (a phrase or sentence instead of just a complicate word.) Try to make passwords long and use a mix of special characters, numbers, and upper- and lowercase letters.
+
+### Keep software current
+
+Applications release patches and updates when they find security vulnerabilities in their systems. Keeping applications, web browsers, and operating systems up to date can help prevent security breaches.
+
+### Check the security of your email inbox
+
+If you use Gmail, Google offers the [Security Checkup](https://myaccount.google.com/security-checkup) tool to let you know if there are any security issues related to your inbox.
+
+You can also use third-party tools, such as websites like [HaveIBeenPwned](https://haveibeenpwned.com/PwnedWebsites) to see if there might be security issues associated with your email address.
+
+## Keep reading
+
+* [Anomaly Detection](/anomaly-detection)
+* [Customize Blocked Account Emails](/anomaly-detection/guides/customize-blocked-account-emails)
diff --git a/articles/anomaly-detection/guides/customize-blocked-account-emails.md b/articles/anomaly-detection/guides/customize-blocked-account-emails.md
new file mode 100644
index 0000000000..1347250973
--- /dev/null
+++ b/articles/anomaly-detection/guides/customize-blocked-account-emails.md
@@ -0,0 +1,30 @@
+---
+title: Customize Blocked Account Emails
+description: Learn how to customize blocked account emails.
+topics:
+ - security
+ - anomaly-detection
+ - brute-force-protection
+ - breached-password-detection
+contentType: how-to
+useCase: customize-anomaly-detection
+v2: true
+---
+# Customize Blocked Account Emails
+
+When Auth0 sends an email to a user to notify them of the [breached password block action](/anomaly-detection/references/breached-password-detection-triggers-actions), the message contains a link to re-enable the origin of the request.
+
+::: note
+Auth0 never blocks the user itself, just the attempts from the suspicious origin.
+:::
+
+The email sent to the user looks like this:
+
+
+
+You can customize the template used for this message on the [Dashboard](${manage_url}/#/emails) under __Emails > Templates > Blocked Account Email__.
+
+## Keep reading
+
+* Learn more about [email templates](/email/templates).
+* Understand [why a user receives a breached password email](/anomaly-detection/concepts/breached-passwords) and general web security tips.
diff --git a/articles/anomaly-detection/guides/enable-disable-brute-force-protection.md b/articles/anomaly-detection/guides/enable-disable-brute-force-protection.md
new file mode 100644
index 0000000000..e40844c3be
--- /dev/null
+++ b/articles/anomaly-detection/guides/enable-disable-brute-force-protection.md
@@ -0,0 +1,29 @@
+---
+title: Enable and Disable Brute-Force Protection
+description: Learn how to disable and enable brute-force protection.
+topics:
+ - security
+ - anomaly-detection
+ - brute-force-protection
+contentType: how-to
+useCase: customize-anomaly-detection
+v2: true
+---
+# Enable and Disable Brute-Force Protection
+
+Brute-force protection is enabled by default for all connections.
+
+
+
+::: warning
+Auth0 strongly recommends that you **do not** set the `brute_force_protection` flag to `false` (effectively disabling brute-force protection for the connection), however if you do, you can change it back in the [Dashboard](${manage_url}/#/anomaly).
+:::
+
+Once enabled, you can [customize](/anomaly-detection/guides/set-anomaly-detection-preferences#brute-force-protection-preferences) your brute-force protection settings.
+
+
+
+## Keep reading
+
+* [Brute-Force Protection Triggers and Actions](/anomaly-detection/references/brute-force-protection-triggers-actions)
+* [Set Anomaly Detection Preferences](/anomaly-detection/guides/set-anomaly-detection-preferences)
\ No newline at end of file
diff --git a/articles/anomaly-detection/guides/prevent-credential-stuffing-attacks.md b/articles/anomaly-detection/guides/prevent-credential-stuffing-attacks.md
new file mode 100644
index 0000000000..c4d5d0b291
--- /dev/null
+++ b/articles/anomaly-detection/guides/prevent-credential-stuffing-attacks.md
@@ -0,0 +1,91 @@
+---
+title: Prevent Credential Stuffing Attacks
+description: Learn how to prevent credential stuffing attacks on your system.
+beta: true
+topics:
+ - anomaly-detection
+ - credential-stuffing
+contentType: how-to
+useCase:
+ - prevent-credential-stuffing
+---
+# Prevent Credential Stuffing Attacks
+
+Credential stuffing attacks (also known as *list validation attacks*) occur when bad actors automate the process of trying username and password combinations (usually stolen from another site) for many accounts in a short period of time. According to recent statistics, as many as 71% of accounts use the same password across multiple sites so a credential stuffing attack has the potential to successfully log into your system.
+
+Consider, for example, the number of errors caused by an incorrect email or username (identified in the logs as type `fu`) for a particular tenant, which suggests an attack occurred November 20, with some abuse patterns afterwards:
+
+
+
+Auth0 provides a number of tools to combat credential stuffing attacks:
+
+* [Brute Force Protection](/anomaly-detection/guides/enable-disable-brute-force-protection) blocks login attempts after a number of consecutive failed logins.
+
+* [Breached Password Protection](/anomaly-detection/concepts/breached-passwords) identifies credentials that are known to be stolen.
+
+* [Multi-factor Authentication](/mfa) can be effective in preventing unauthorized logins, but it adds friction to the user experience.
+
+If you do not want to turn on additional features such as MFA, you can add **Automated Credential Stuffing Attack Protection** to provide a standard level of protection against credential stuffing attacks that does not add any friction to legitimate users.
+
+## How it works
+
+Auth0 uses a large amount of data to identify patterns that signal that a credential stuffing attack is taking place. Auth0 uses sophisticated algorithms to determine when bursts of traffic are likely to be from a bot or script. Users attempting to sign in from IPs which are determined to have a high likelihood of being a credential stuffing attack will see a Captcha step. The algorithms are designed so that this only happens for bad traffic; the objective is to not show any friction to legitimate users.
+
+
+
+## Enable automated credential stuffing attack protection
+
+### Prerequisites
+
+* Please read Auth0’s [Beta Service Terms](https://cdn.auth0.com/website/legal/terms/beta-service-terms-11-18-19.pdf) and acknowledge you have read and agreed to the terms by emailing **Antonio Fuentes** at **antonio.fuentes@auth0.com**.
+
+* Determine which type of login experience you have configured:
+
+ - Go to [Dashboard](${manage_url}/#).
+ - Navigate to **Universal Login**.
+ - Determine which login experience is selected (Classic or New).
+
+### If you are using New Universal Login
+
+No further configuration is required. If you are part of the Beta program, the Early Access features will work for your tenant immediately.
+
+### If you are using Classic Universal Login
+
+Determine if your page is customized.
+
+1. Select the **Login** tab.
+
+2. Verify the status of the toggle **Customize Login Page**.
+
+3. If it is on, you have a customized login page.
+
+### If you are using customized Classic Universal Login
+
+Upgrade your version of Lock.
+
+1. Navigate to the **Universal Login** section in the Dashboard.
+
+2. Select the **Login** tab.
+
+3. Update your version of Auth0’s Lock to version v11.20 by replacing the script tag with the tag for version v11.20.
+
+For example, replace this tag:
+```html
+
+```
+
+With the following:
+```html
+
+```
+
+## Performance impact
+
+This feature is intended to reduce the number of login attempts associated with automated or scripted credential stuffing attacks. It is not expected to cause a degradation in the latency or performance of the login flows. Auth0 monitors the impact on these metrics and will share them with you.
+
+In addition, you can look at the [tenant logs](/anomaly-detection/guides/use-tenant-data-for-anomaly-detection). Events that indicate a credential stuffing attack is happening.
+
+- `f`: failed login
+- `fu`: failed login due to invalid email/username
+
+If you have questions, you can contact Auth0 through your TAM or contact **antonio.fuentes@auth0.com**.
diff --git a/articles/anomaly-detection/guides/set-anomaly-detection-preferences.md b/articles/anomaly-detection/guides/set-anomaly-detection-preferences.md
new file mode 100644
index 0000000000..7096901ab2
--- /dev/null
+++ b/articles/anomaly-detection/guides/set-anomaly-detection-preferences.md
@@ -0,0 +1,70 @@
+---
+title: Set Anomaly Detection Preferences
+description: Learn how to set anomaly detection preferences in the Dashboard.
+topics:
+ - security
+ - anomaly-detection
+ - brute-force-protection
+ - breached-password-detection
+contentType: how-to
+useCase: customize-anomaly-detection
+v2: true
+---
+# Set Anomaly Detection Preferences
+
+Customize the actions that occur after the triggers in the **Anomaly Detection** section on the [Dashboard](${manage_url}/#/anomaly).
+
+::: warning
+Auth0 recommends that you **do not** make changes to your anomaly detection features with the Management API.
+:::
+
+
+
+## Brute-force protection preferences
+
+Brute-force protection is enabled by default for all connections. For more information, see [Enable and Disable Brute-Force Protection](/anomaly-detection/guides/enable-disable-brute-force-protection).
+
+::: warning
+Auth0 strongly recommends that you **do not** set the `brute_force_protection` flag to `false` (effectively disabling brute-force protection for the connection), however if you do, you can change it back in the [Dashboard](${manage_url}/#/anomaly).
+:::
+
+Limit the amount of signups and failed logins from a suspicious IP address. For more information, see [Brute-Force Protection Triggers and Actions](/anomaly-detection/references/brute-force-protection-triggers-actions).
+
+1. Click on the **Brute-force Protection** shield.
+
+
+
+2. Use the toggles to enable or disable actions for single or multiple user accounts.
+
+3. Add any IP addresses to the **Whitelist** field to avoid erroneously triggering the protection action.
+
+4. Click **Save** when you are finished.
+
+## Breached password detection preferences
+
+Set preferences for breached password detection actions. For more information, see [Breached Password Detection Triggers and Actions](/anomaly-detection/references/breached-password-detection-triggers-actions).
+
+1. Click on the **Breached-password Detection** shield.
+
+
+
+2. Use the toggles to enable or disable actions when login security breaches are detected.
+
+3. Determine how administrators are notified.
+
+4. Click **Save** when you are finished.
+
+## Restrictions and limitations
+
+Both brute-force protection and breached password detection depend on the IP address of the user. Because of this, the following use cases are *not* supported:
+
+* **Using the [Resource Owner](/api/authentication#resource-owner) from the backend of the application.** Using this call does not get the IP address of the user. See point 2 below as an alternative.
+
+* **Using [Resource Owner Password Grant](/api-auth/grant/password) from the backend of the application.** Using this call does not get the IP address of the user, however, you can [configure your application and send the IP address of the user as part of the request](/api-auth/tutorials/using-resource-owner-password-from-server-side) to make brute-force protection work correctly.
+
+* **Authenticating many users from the same IP address.** For example, users that are behind a proxy are more likely to reach these limits and trigger the associated protection. It is possible to configure a whitelist for the proxy's IP and CIDR range and avoid erroneously triggering the protection.
+
+## Keep reading
+
+* [Anomaly Detection](/anomaly-detection)
+* [Breached Password Security](/anomaly-detection/concepts/breached-passwords)
\ No newline at end of file
diff --git a/articles/anomaly-detection/guides/use-tenant-data-for-anomaly-detection.md b/articles/anomaly-detection/guides/use-tenant-data-for-anomaly-detection.md
new file mode 100644
index 0000000000..fd88341413
--- /dev/null
+++ b/articles/anomaly-detection/guides/use-tenant-data-for-anomaly-detection.md
@@ -0,0 +1,57 @@
+---
+description: Learn how to use tenant traffic log data to view anomaly detection events.
+topics:
+ - security
+ - anomaly-detection
+contentType: how-to
+useCase: tenant-logs
+---
+
+# View Anomaly Detection Events
+
+The tenant logs contain useful data that you can use to build charts to look at the profile of the traffic going through your tenant. This is helpful when evaluating anomaly detection activity.
+
+## Authentication failure events
+
+You can use the log data `event` field to view the tenant traffic data. We recommend building a daily histogram of failure events of the following types:
+
+| Event Code | Event |
+| -- | -- |
+| `f` | Failed login |
+| `fcoa` | Failed cross-origin authentication |
+| `feccft` | Failed exchange |
+| `fepft` | Failed exchange |
+| `fsa` | Failed silent authentication |
+| `fu` | Failed login (invalid email/username) |
+| `sepft` | Success exchange |
+
+These failure events depend on the flow you have set up with Auth0.
+
+The following example shows a credential stuffing attack on 11/20, with a large surge of events of type `fu` which is a failed username (typical of a credential stuffing attack).
+
+
+
+## Authenticaton failure events from distinct IPs
+
+You can use the `ip` event to see the number of distinct IPs that your failure traffic is coming from, in this case, the number of distinct IPs that correspond to your `fu` event traffic.
+
+## Anomaly detection events
+
+You can perform the same type of analysis with the events corresponding to anomaly detection events to see how many times they are triggered. Use the following log events which correspond to brute force detection with many accounts, one account, and breached password detection:
+
+| Event Code | Event |
+| -- | -- |
+| `limit_mu` | Blocked IP address |
+| `limit_wc` | Blocked account |
+| `pwd_leak` | Breached password |
+
+Here's an example of what that data might look like.
+
+
+
+## Keep reading
+
+* [Log Event Data](/logs/references/log-events-data)
+* [Log Search Query Syntax](/logs/references/query-syntax)
+* [Export Log Data to External Services](/extensions#Monitor)
+* [Retrieve Logs Using the Management API](/logs/guides/retrieve-logs-mgmt-api)
diff --git a/articles/anomaly-detection/index.md b/articles/anomaly-detection/index.md
index 555b5ef1bf..9dc98e5ece 100644
--- a/articles/anomaly-detection/index.md
+++ b/articles/anomaly-detection/index.md
@@ -1,166 +1,73 @@
---
-toc: true
-description: Explains all the types of Anomaly Detection provided by Auth0 and how to enable them.
-url: /anomaly-detection
+title: Anomaly Detection
+description: Understand how Auth0 detects anomalies to stop malicious attempts to access your application, alert you and your users of suspicious activity, and block further login attempts.
+toc: true
topics:
- security
- anomaly-detection
-contentType:
- - index
- - reference
- - how-to
+ - brute-force-protection
+ - breached-password-detection
+contentType: concept
useCase: customize-anomaly-detection
+v2: true
---
-
# Anomaly Detection
-Auth0 provides built-in tools to detect anomalies and stop malicious attempts to access your application. Anomaly detection can alert you and your users of suspicious activity, as well as block further login attempts. You can set your preferences on the notifications that get sent and you can decide whether to block a suspicious IP address or not.
-
-## What Anomaly Detection Provides
-
-Currently Auth0 has three types of **shields** you can enable to handle anomalies and attacks. A **shield** specifies the **action** you wish to take given a specific **trigger**.
-
-A **trigger** is a suspicious event that is detected when someone is trying to login to your system, or there may have been a breached password with another 3rd party service.
-
-## Shields
-
-### Brute-Force Protection
+Auth0 can detect anomalies and stop malicious attempts to access your application. Anomaly detection can alert you and your users of suspicious activity, as well as block further login attempts. You can [set preferences](/anomaly-detection/guides/set-anomaly-detection-preferences) for notifications and decide whether to block a suspicious IP address or not.
-There are two different triggers for the brute-force protection shield, for two slightly different attack scenarios.
+Auth0 has two types of **shields** to handle anomalies and attacks.
-**Trigger:** *10* failed login attempts into a single account from the same IP address.
+* [Brute-force protection](#brute-force-protection)
+* [Breached password detection](#breached-password-detection)
-**Actions**:
-* Send an email to the affected user (The email can be [customized](#customize-the-blocked-account-email))
-* Block the suspicious IP address
+A **shield** specifies the **action** you wish to take given a specific **trigger**. A **trigger** is a suspicious event that is detected when someone is trying to login to your system, or there may have been a breached password with another third party service.
-::: panel Note
-The way this anomaly protection works is that if user with "user_id1" signs in from IP1 and fails to login consecutively for 10 attempts their login from this IP - IP1 will be blocked. Another user, say "user_id2" signing in from the same IP (IP1) will not be blocked. The mechanism to clear this block is described below.
+Customize the actions in the **Anomaly Detection** section on the [Dashboard](${manage_url}/#/anomaly).
-Currently the default trigger amount of 10 cannot be changed.
+::: note
+Auth0 recommends that you [create reports using tenant traffic data to see anomaly detection events](/anomaly-detection/guides/use-tenant-data-for-anomaly-detection).
:::
-If this block is triggered, it can be cleared the following ways:
-
-* An administrator removes the block via the [Dashboard](${manage_url}) (by clicking **unblock for all IPs** under the **ACTIONS** button when viewing the user's details) or by using the [Management API](/api/management/v2#!/User_Blocks/delete_user_blocks) ;
-* The User clicks on the "unblock" link provided in the email sent when the block went into effect;
-* The User changes their password.
-
-**Trigger:** *100* failed login attempts from a single IP address using different usernames, all with incorrect passwords in 24 hours. Or *50* sign ups attempts per minute from the same IP address.
-
-**Actions:**
-* Notify dashboard administrator(s)
-* Block suspicious addresses
-
-If this block is triggered, additional access attempts are released one at a time over the course of 24 hours until 100 attempts are allocated. More specifically, you will gain 100 attempts / 24 hours * 60 minutes = 1 additional attempt every 25 minutes.
-
-Auth0 does email the dashboard administrator(s) when this block is triggered. Within this email there's a link the owner can click on to remove the block.
-
-#### Enable or Disable Brute Force Protection
+## Brute-force protection
-By default, brute force protection is enabled for all connections.
+Brute-force protection is [enabled by default](/anomaly-detection/guides/enable-disable-brute-force-protection) for all connections. There are two different [triggers](/anomaly-detection/references/brute-force-protection-triggers-actions) for the brute-force protection shield, for two slightly different attack scenarios.
-Each connection has a flag called `brute_force_protection` that you can use to disable brute force protection. If this flag is set to `true`, then brute force protection is enabled *even if general brute force protection is enabled*.
+* 10 consecutive failed login attempts for the same user and from the same IP address
+* 100 failed login attempts from the same IP address in 24 hours *or* 50 sign up attempts per minute from the same IP address
-We do not recommend setting the `brute_force_protection` flag to `false` (effectively disabling brute force protection for the connection), but if you do, you will be able to change this in the Dashboard. There will be a **Improve brute force protection** toggle under Connection Settings that changes the flag from `false` to `true`.
+For example, if a user with *user_id1* signs in from *IP1* and fails to login consecutively for 10 attempts, their log in attempt from this *IP1* will be blocked. Another user, *user_id2*, signing in from *IP1* will not be blocked.
-#### Restrictions Regarding Brute-Force Protection
+## Breached password detection
-Both of these anomaly types depend on the IP address of the user. Because of this, the following use cases are *not* supported:
+Every day, malicious hackers penetrate websites and applications, exposing thousands of email and passwords. Because it's common for users to use the same password to login to multiples sites, this poses a problem, not only for the hacked system, but to any application that shares those [breached passwords](/anomaly-detection/concepts/breached-passwords).
-1. Using the [Resource Owner](/api/authentication#resource-owner) from the backend of the application. Using this call does not get the IP address of the user. See point 2 below as an alternative.
-2. Using [Resource Owner Password Grant](/api-auth/grant/password) from the backend of the application. Using this call does not get the IP address of the user, however, you can [configure your application and send the IP address of the user as part of the request](/api-auth/tutorials/using-resource-owner-password-from-server-side) to make brute-force protection work correctly.
-3. Authenticating many users from the same IP address. For example, users that are behind a proxy are more likely to reach these limits and trigger the associated protection. It is possible to configure a whitelist for the proxy's IP and CIDR range and avoid erroneously triggering the protection.
+Auth0 tracks large security breaches that are happening on major third party sites to help keep your users and system secure. By [enabling breached password detection](/anomaly-detection/guides/set-anomaly-detection-preferences), when a [trigger](/anomaly-detection/references/breached-password-detection-triggers-actions) occurs, your users can be notified and/or blocked from logging in if we suspect their credentials were part of a published security breach. You can [customize blocked account emails](/anomaly-detection/guides/customize-blocked-account-emails).
-### Breached Password Detection
+## Frequently asked questions
-Every day malicious hackers penetrate websites and applications, exposing thousands of email and passwords. Given that it's quite common for users to use the same password to login to multiples sites, this poses a problem, not only for the hacked system, but to any application that shares those credentials.
-
-Auth0 tracks large security breaches that are happening on major third party sites to help keep your users and system secure. By enabling Breached Password Detection, your users can be notified and/or blocked from logging in if we suspect their credentials were part of a published security breach.
-
-**Trigger:** Auth0 suspects that a specific user's credentials were included in a major public security breach.
-
-**Actions:**
-* Send an email to the affected user
-* Send an email to dashboard owners immediately, and/or have a daily/weekly/monthly summary
-* Block login attempts for suspected user accounts using that username and password combination
-
-This block remains in place until the user changes their password.
-
-:::note
-Watch our [Breached Password Detection 101 video tutorial](https://auth0.com/resources/videos/learn-about-breached-password-detection).
-:::
-
-## Set your anomaly detection preferences
-
-To customize the **actions** that get taken from the **triggers**, go to the [Anomaly Detection](${manage_url}/#/anomaly) section on the dashboard.
-
-
-
-You can use the toggle to disable all the actions of a certain shield. Or to enable/disable certain actions, click on the shield that has the action in it that you wish to change.
-
-Then you can use the toggle to enable/disable an action.
-
-::: warning
-We do not recommend making changes to your anomaly detection features via the Management API.
-:::
-
-### Brute-force Protection
-
-
-
-Here you can also add any IP addresses to the **Whitelist** field to avoid erroneously triggering the protection.
-
-Click **Save** when you have finished.
-
-### Breached-password Detection
-
-
-
-Click **Save** when you have finished.
-
-### Customize the Blocked Account Email
-
-When Auth0 sends an email to a user to notify them of the block, the message contains a link to re-enable the origin of the request. Notice that Auth0 never blocks the user itself, just the attempts from the suspicious origin.
-
-The email sent to the user looks like this:
-
-
-
-The template used for this message can be customized on the [Dashboard](${manage_url}/#/emails) under __Emails > Templates > Blocked Account Email__.
-
-[Learn more about Customizing your Emails](/email/templates)
-
-## FAQs
-
-1. **Is the user notified at every login?**
-
-We send one email every hour, regardless of the number of logins. For example, if a user tries to log in 200 times in 1 hour and 30 minutes, we will send two emails.
-
-2. **Is there a limit to the number of times a user will be notified?**
+* **Is the user notified at every login?**
+We send one email every hour, regardless of the number of logins. For example, if a user tries to log in 200 times in 1 hour and 30 minutes, we will send 2 emails.
+* **Is there a limit to the number of times a user will be notified?**
Users will only be notified once per hour.
-3. **How long is the reset password link, included in the breached password email, valid for?**
+* **How often does Auth0 email administrators when traffic is blocked using Brute Force Protection for multiple accounts?**
+In the event of an ongoing attack, traffic can be blocked from thousands of IP addresses at a time. Auth0 will send a single email to each administrator every hour that traffic is blocked, regardless of the number of IPs involved in the attack.
-Password reset links are valid for five days.
-
-4. **Is there a test dataset of breached passwords?**
+* **For how long is the reset password link, included in the breached password email, valid?**
+Password reset links are valid for 5 days.
+* **Is there a test dataset of breached passwords?**
You can test with **leak-test@example.com** as the email and **Paaf213XXYYZZ** as the password.
-5. **Does the breached password detection work when logging in using the Resource Owner password grant?**
-
+* **Does the breached password detection work when logging in using the Resource Owner password grant?**
Yes.
-6. **Does the breached password detection feature work with a custom database?**
-
+* **Does the breached password detection feature work with a custom database?**
Yes.
-7. **What Redirect URL applies to the *Change password* link included in the breached password notification email?**
-
+* **What Redirect URL applies to the *Change password* link included in the breached password notification email?**
The **RedirectTo** URL is the URL listed in the Dashboard in [Emails > Templates > Change Password Template](${manage_url}/#/emails).
-8. **Is there a way to configure the Redirect URL and length of time the change password link is valid?**
-
-You can configure the **URL Lifetime** and **Redirect To** values in the Dashboard by going to [Emails > Templates > Change Password Template](${manage_url}/#/emails).
+* **Is there a way to configure the Redirect URL and the length of time that the change password link is valid?**
+You can configure the **URL Lifetime** and **Redirect To** values in the Dashboard by going to [Emails > Templates > Change Password Template](${manage_url}/#/emails).
\ No newline at end of file
diff --git a/articles/anomaly-detection/references/breached-password-detection-triggers-actions.md b/articles/anomaly-detection/references/breached-password-detection-triggers-actions.md
new file mode 100644
index 0000000000..c7e0e93b8b
--- /dev/null
+++ b/articles/anomaly-detection/references/breached-password-detection-triggers-actions.md
@@ -0,0 +1,35 @@
+---
+title: Breached Password Detection Triggers and Actions
+description: Breached password detection triggers and actions taken upon anomaly detection and how blocks are cleared.
+topics:
+ - security
+ - anomaly-detection
+ - breached-password-detection
+contentType: reference
+useCase: customize-anomaly-detection
+v2: true
+---
+# Breached Password Detection Triggers and Actions
+
+## Trigger
+
+A trigger occurs when Auth0 suspects that a specific user's credentials were included in a major public security breach.
+
+::: panel Video Tutorial
+Watch our [Breached Password Detection 101 video tutorial](https://auth0.com/resources/videos/learn-about-breached-password-detection).
+:::
+
+## Actions
+
+* Send an email to the affected user.
+* Send an email to dashboard owners immediately, and/or have a daily/weekly/monthly summary.
+* Block login attempts for suspected user accounts using that username and password combination.
+
+## Remove block
+
+This block remains in place until the user changes their password.
+
+## Keep reading
+
+* [Anomaly Detection](/anomaly-detection)
+* [Breached Password Security](/anomaly-detection/concepts/breached-passwords)
\ No newline at end of file
diff --git a/articles/anomaly-detection/references/brute-force-protection-triggers-actions.md b/articles/anomaly-detection/references/brute-force-protection-triggers-actions.md
new file mode 100644
index 0000000000..3342464d8f
--- /dev/null
+++ b/articles/anomaly-detection/references/brute-force-protection-triggers-actions.md
@@ -0,0 +1,64 @@
+---
+title: Brute-Force Protection Triggers and Actions
+description: Brute-force protection triggers and actions taken upon anomaly detection and how blocks are cleared.
+topics:
+ - security
+ - anomaly-detection
+ - brute-force-protection
+contentType: reference
+useCase: customize-anomaly-detection
+v2: true
+---
+# Brute-Force Protection Triggers and Actions
+
+## 10 failed login attempts
+
+### Trigger
+
+This trigger occurs when there are 10 failed login attempts into a single account from the same IP address.
+
+::: note
+The default trigger amount of 10 cannot be changed.
+:::
+
+### Actions
+
+* Send an email to the affected user. (You can [customize the email](/anomaly-detection/guides/customize-blocked-account-emails).)
+* Block the suspicious IP address for that user.
+
+### Remove block
+
+If this block is triggered, it can be cleared the following ways:
+
+* An administrator removes the block via the [Dashboard](${manage_url}) (by clicking **unblock for all IPs** under the **ACTIONS** button when viewing the user's details) or by using the [Management API](/api/management/v2#!/User_Blocks/delete_user_blocks).
+* The user clicks on the **unblock** link provided in the email sent when the block went into effect.
+* The user changes their password.
+
+## 100 failed login attempts *or* 50 sign up attempts
+
+### Triggers
+
+A trigger occurs when there are 100 failed login attempts from one IP address using different usernames with incorrect passwords in 24 hours.
+
+Another trigger occurs if there are 50 sign up attempts per minute from the same IP address.
+
+### Actions
+
+* Notify dashboard administrator(s).
+* Block suspicious addresses for 15 minutes.
+
+If this block is triggered, additional access attempts are released one-at-a-time over the course of 24 hours until 100 attempts are allocated. This results in approximately 1 additional attempt every 15 minutes.
+
+### Remove block
+
+Auth0 emails the dashboard administrator(s) when this block is triggered. The email contains a link that the owner can click to navigate to tenant logs to examine which IPs have been blocked. Recent blocks can be found using this query:
+```
+type:limit_mu
+```
+Blocks can then be removed using the [Management API](/api/management/v2#!/Anomaly/delete_ips_by_id).
+
+## Keep reading
+
+* [Anomaly Detection](/anomaly-detection)
+* [Set Anomaly Detection Preferences](/anomaly-detection/guides/set-anomaly-detection-preferences)
+* [Enable and Disable Brute-Force Protection](/anomaly-detection/guides/enable-disable-brute-force-protection)
diff --git a/articles/api-auth/_includes/_ropg-warning.md b/articles/api-auth/_includes/_ropg-warning.md
new file mode 100644
index 0000000000..c19c5320ac
--- /dev/null
+++ b/articles/api-auth/_includes/_ropg-warning.md
@@ -0,0 +1,9 @@
+::: warning
+Since the Resource Owner Password Grant (ROPG) flow involves the client handling the user's password, it **must not be used by third-party clients**. In this flow, the user's username and password are exchanged directly for an Access Token.
+
+Only consider using it when there is a high degree of trust between the user and the application and when other authorization flows (such as redirect-based flows) are not available.
+
+Instead, Auth0 recommends:
+* For confidential clients, like Regular Web Applications, use the [Authorization Code Flow](/flows/concepts/auth-code).
+* For public clients, like Native/Mobile Apps and Single-Page Applications, use the [Authorization Code Flow with PKCE](/flows/concepts/auth-code-pkce).
+:::
diff --git a/articles/api-auth/apis.md b/articles/api-auth/apis.md
index b262bdd12f..da33b407f4 100644
--- a/articles/api-auth/apis.md
+++ b/articles/api-auth/apis.md
@@ -15,21 +15,13 @@ useCase:
---
# APIs
-<%= include('../_includes/_pipeline2') %>
-
-## Overview
-
An API is an entity that represents an external resource, capable of accepting and responding to protected resource requests made by applications. At the [OAuth2 spec](https://tools.ietf.org/html/rfc6749) an API maps to the **Resource Server**.
-When an application wants to access an API's protected resources it must provide an [Access Token](/tokens/access-token). The same Access Token can be used to access the API's resources without having to authenticate again, until it expires.
-
-Each API has a set of defined permissions. Applications can request a subset of those defined permissions when they execute the authorization flow, and include them in the Access Token as part of the **scope** request parameter.
+When an application wants to access an API's protected resources it must provide an Access Token. The same Access Token can be used to access the API's resources without having to authenticate again, until it expires.
-For example, an API that holds a user's appointments, may accept two different levels of authorization: read only (scope `read:appointments`) or write (scope `write:appointments`). When an application asks the API to list a user's appointments, then the Access Token should contain the `read:appointments` scope. In order to edit an existing appointment or create a new one, the Access Token should contain the `write:appointments` scope.
+Each API has a set of defined permissions. Applications can request a subset of those defined permissions when they execute the authorization flow, and include them in the Access Token as part of the **scope** request parameter.
-::: note
-For more information on tokens please refer to: [Tokens used by Auth0](/tokens).
-:::
+For example, an API that holds a user's appointments, may accept two different levels of authorization: read only (scope `read:appointments`) or write (scope `write:appointments`). When an application asks the API to list a user's appointments, then the Access Token should contain the `read:appointments` scope. In order to edit an existing appointment or create a new one, the Access Token should contain the `write:appointments` scope. See [Tokens](/tokens) for more information.
## How to configure an API in Auth0
@@ -49,7 +41,7 @@ You need to provide the following information for your API:
- **Identifier**: a unique identifier for the API. Auth0 recommends using a URL. Auth0 does differentiate between URLs that include the last forward slash. For example, https://example.com and https://example.com/ are two different identifiers. The URL does not have to be a publicly available URL. Auth0 will not call your API. This value **cannot** be modified afterwards.
-- **Signing Algorithm**: the algorithm to sign the tokens with. The available values are `HS256` and `RS256`. When selecting `RS256` the token will be signed with the tenant's private key. For more details on the signing algorithms go to the [Signing Algorithms paragraph](#signing-algorithms).
+- **Signing Algorithm**: the algorithm to sign the tokens with. The available values are `HS256` and `RS256`. When selecting `RS256` the token will be signed with the tenant's private key. To learn more about signing algorithms, see [Signing Algorithms paragraph](/tokens/concepts/signing-algorithms).
Fill in the required information and click the **Create** button.
@@ -60,11 +52,11 @@ Once you do so you will be navigated to the *Quick Start* of your API. Here you
The other available views for your API are:
-- **Settings**: lists the settings for your API. Some are editable. Here you can change the token expiration time and enable offline access (this way Auth0 will allow your applications to ask for Refresh Tokens for this API). For details refer to the [API Settings paragraph](#api-settings).
+- **Settings**: lists the settings for your API. Some are editable. Here you can change the token expiration time and enable offline access (this way Auth0 will allow your applications to ask for Refresh Tokens for this API). For details refer to the [API Settings paragraph](#api-settings).
- **Scopes**: here you can define the scopes for this API, by setting a name and a description.
-- **Machine to Machine Applications**: lists all applications for which the **Client Credentials** grant is **enabled**. By default, this grant is **enabled* for [Regular Web Applications](/applications/webapps) and [Machine to Machine Applications](/applications/machine-to-machine). You can authorize any of these applications to request Access Tokens for your API. Optionally, you can select a subset of the defined scopes to limit your authorized application's access.
+- **Machine to Machine Applications**: lists all applications for which the **Client Credentials** grant is **enabled**. By default, this grant is **enabled** for [Regular Web Applications and Machine to Machine Applications](/applications). You can authorize any of these applications to request Access Tokens for your API. Optionally, you can select a subset of the defined scopes to limit your authorized application's access.
- **Test**: from this view, you can execute a sample Client Credentials flow with any of your authorized applications to check that everything is working as expected.
@@ -80,50 +72,14 @@ Click on the *Settings* tab of your [API](${manage_url}/#/apis) to review the av
- **Token Expiration (Seconds)**: The amount of time (in seconds) before the Auth0 Access Token expires. The default value is 86400 seconds (24 hours). The maximum value you can set is 2592000 seconds (30 days).
-- **Allow Skipping User Consent**: When a first party application requests authorized access against an API with the *Allow Skipping User Consent* flag set, the User Consent dialog will not be shown to the final user. Note that if the hostname of your application's **callbackURL** is `localhost` or `127.0.0.1` the consent dialog will always be displayed.
+- **Allow Skipping User Consent**: When a first party application requests authorized access against an API with the *Allow Skipping User Consent* flag set, the User Consent dialog will not be shown to the final user. Note that if the hostname of your application's **callback URL** is `localhost` or `127.0.0.1` the consent dialog will always be displayed.
- **Allow Offline Access**: If this setting is enabled, Auth0 will allow applications to ask for Refresh Tokens for this API.
-- **Signing Algorithm**: The algorithm to sign the tokens with. The available values are `HS256` and `RS256`. When selecting `RS256` (recommended) the token will be signed with the tenant's private key. This value is set upon API creation and cannot be modified afterwards. For more details on the signing algorithms see the [Signing Algorithms paragraph](#signing-algorithms) below.
-
-### Signing Algorithms
-
-When you create an API you have to select the algorithm your tokens will be signed with. The signature is used to verify that the sender of the JWT is who it says it is and to ensure that the message wasn't changed along the way.
-
-::: note
-The signature is part of a JWT. If you are not familiar with the JWT structure please refer to: [JSON Web Tokens (JWTs) in Auth0](/jwt#what-is-the-json-web-token-structure-).
-:::
-
-To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that. That algorithm, which is part of the JWT header, is the one you select for your API: `HS256` or `RS256`.
-
-- **RS256** is an [asymmetric algorithm](https://en.wikipedia.org/wiki/Public-key_cryptography) which means that there are two keys: one public and one private (secret). Auth0 has the secret key, which is used to generate the signature, and the consumer of the JWT has the public key, which is used to validate the signature.
+- **Signing Algorithm**: The algorithm to sign the tokens with. The available values are `HS256` and `RS256`. When selecting `RS256` (recommended) the token will be signed with the tenant's private key. This value is set upon API creation and cannot be modified afterwards. To learn more about signing algorithms, see [Signing Algorithms](/tokens/concepts/signing-algorithms).
-- **HS256** is a [symmetric algorithm](https://en.wikipedia.org/wiki/Symmetric-key_algorithm) which means that there is only one secret key, shared between the two parties. The same key is used both to generate the signature and to validate it. Special care should be taken in order for the key to remain confidential.
+## Keep reading
-The most secure practice, and our recommendation, is to use **RS256**. Some of the reasons are:
-
-- With RS256 you are sure that only the holder of the private key (Auth0) can sign tokens, while anyone can check if the token is valid using the public key.
-
-- Under HS256, if the secret key is compromised (e.g. by the application) you would have to re-deploy the API with the new secret.
-
-- With RS256 you can request a token that is valid for multiple audiences.
-
-- With RS256 you can implement key rotation without having to re-deploy the API with the new secret.
-
-::: panel Verify an RS256 signed token
-Go to [Dashboard > Applications](${manage_url}/#/applications). Open the **Settings** of your applications, scroll down and open **Advanced Settings**. Open the **Certificates** tab and you will find the Public Key in the **Signing Certificate** field.
-
-If you want to use the Public Key to verify a JWT signature on [JWT.io](https://jwt.io/), you can copy the Public Key and paste it in the **Public Key or Certificate** field under the **Verify Signature** section on the [JWT.io](https://jwt.io/) website.
-
-If you want to verify the signature of a token from one of your applications, we recommend that you get the Public Key from your tenant's [JSON Web Key Set (JWKS)](/jwks). Your tenant's JWKS is `https://${account.namespace}/.well-known/jwks.json`.
-:::
-
-For a more detailed overview of the JWT signing algorithms refer to: [JSON Web Token (JWT) Signing Algorithms Overview](https://auth0.com/blog/json-web-token-signing-algorithms-overview/).
-
-## Keep Reading
-
-::: next-steps
- [API Authorization landing page](/api-auth)
- [Identify the proper OAuth 2.0 flow for your use case](/api-auth/which-oauth-flow-to-use)
-- [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
-:::
+- [Tokens](/tokens)
diff --git a/articles/api-auth/blacklists-vs-grants.md b/articles/api-auth/blacklists-vs-grants.md
index 84941c461e..8a8fbedf29 100644
--- a/articles/api-auth/blacklists-vs-grants.md
+++ b/articles/api-auth/blacklists-vs-grants.md
@@ -1,12 +1,12 @@
---
-description: This document covers blacklists vs. grants when it comes handling tokens.
+description: Understand blacklists vs. grants when it comes handling tokens.
topics:
- api-authentication
- oidc
- security
- blacklists
- application-grants
-contentType: how-to
+contentType: concept
useCase:
- secure-api
- call-api
@@ -14,7 +14,7 @@ useCase:
# Blacklists and Application Grants
-Let's say that you're using a machine to machine [application](/application) to access your API. You have a partner that calls your API, and at the end of your existing contract, you and your partner decide not to renew your partnership. As such, you now want to remove your partner's access to your API. The issue, however, is that you've given your partner an [Access Token](/tokens/access-token) that lasts for a month.
+Let's say that you're using a machine to machine [application](/application) to access your API. You have a partner that calls your API, and at the end of your existing contract, you and your partner decide not to renew your partnership. As such, you now want to remove your partner's access to your API. The issue, however, is that you've given your partner an Access Token that lasts for a month.
* What can you do in this situation?
* How might you configure your Auth0 environment to make such situations easier to handle in the future?
@@ -30,14 +30,10 @@ We will then compare the two methods and provide our recommendations.
Let's say that you grant access to your API to anyone in possession of the appropriate Access Token. One method of revoking access to a user is to blacklist their token so that it can no longer be used.
-::: note
-Please see the Auth0 blog for an in-depth treatment on [Blacklisting JSON Web Token API Keys](https://auth0.com/blog/blacklist-json-web-token-api-keys/).
-:::
-
-Auth0-issued tokens are [JWTs](/jwt), so you can set the JWT ID, or `jti`, for the token by including it in the token payload's `jwtid` field. With the `jti` in hand, you can make the appropriate `POST` call to the Management API's [blacklist a token endpoint](/api/management/v2#!/Blacklists/post_tokens). You'll need to provide the JWT's `aud` and `jti` claims.
+Auth0-issued tokens are [JWTs](/tokens/concepts/jwts), so you can set the JWT ID, or `jti`, for the token by including it in the token payload's `jwtid` field. With the `jti` in hand, you can make the appropriate `POST` call to the Management API's [blacklist a token endpoint](/api/management/v2#!/Blacklists/post_tokens). You'll need to provide the JWT's `aud` and `jti` claims.
::: panel Add a JWT ID
-You can add `jti` via a [rule](/rule). Here's a simple example using UUID:
+You can add `jti` via a [rule](/rules). Here's a simple example using UUID:
```js
function (user, context, callback) {
diff --git a/articles/api-auth/config/using-the-auth0-dashboard.md b/articles/api-auth/config/using-the-auth0-dashboard.md
index 7eafe6253b..dde2b216f6 100644
--- a/articles/api-auth/config/using-the-auth0-dashboard.md
+++ b/articles/api-auth/config/using-the-auth0-dashboard.md
@@ -8,11 +8,11 @@ contentType: how-to
useCase: secure-api
---
-# Set up a Client Grant using the Dashboard
+# Set Up Client Credentials Grants Using the Dashboard
-Auth0 lets you authorize applications that have the **Client Credential** grant type enabled to call APIs using the OAuth Client Credentials Grant.
+Auth0 lets you authorize applications that have the **Client Credentials** grant type enabled to call APIs using the [Client Credentials Flow](/flows/concepts/client-credentials).
-By default, the **Client Credentials** grant is enabled for all Machine to Machine Applications and Regular Web Applications, but they are _not yet_ authorized to call any API.
+By default, the **Client Credentials** grant is enabled for all Machine-to-Machine Applications and Regular Web Applications, but they are _not yet_ authorized to call any API.
To authorize the applications to call an API:
@@ -20,16 +20,14 @@ To authorize the applications to call an API:
2. Select the API you want to invoke using the **Client Credentials** Grant.
-3. Under the **Authorized Application** tab, look for the application you want to authorize, click the Authorize button, and optionally select the list of scopes that will be granted in the Access Token. This will create a 'client grant' in Auth0, which will allow the application to call the API.
+3. Under the **Authorized Application** tab, look for the application you want to authorize, click the Authorize button, and optionally, select the list of scopes that will be granted in the Access Token. This will create a 'client grant' in Auth0, which will allow the application to call the API.

-4. In the Test tab, you can select the application you granted access to, and see the Access Tokens that will be generated for it.
+4. In the Test tab, you can select the application to which you granted access, and see the Access Tokens that will be generated for it.
## Keep reading
-:::next-steps
-* [How to implement the Client Credentials Grant](/api-auth/tutorials/client-credentials)
-* [How to change the scopes and add custom claims to a token using Hooks](/api-auth/tutorials/client-credentials/customize-with-hooks)
-* [How to add custom claims to a token using Rules](/scopes#custom-claims)
-:::
+* [Call API using the Client Credentials Flow](/flows/guides/client-credentials/call-api-client-credentials)
+* [Use Hooks with Client Credentials Grant](/api-auth/tutorials/client-credentials/customize-with-hooks)
+* [Add Custom Claims Tokens Using Rules](/scopes/current/sample-use-cases#add-custom-claims-to-a-token)
diff --git a/articles/api-auth/config/using-the-management-api.md b/articles/api-auth/config/using-the-management-api.md
index 78401eb673..fc9e75f35a 100644
--- a/articles/api-auth/config/using-the-management-api.md
+++ b/articles/api-auth/config/using-the-management-api.md
@@ -1,6 +1,5 @@
---
-title: Set up a Client Credentials Grant using the Management API
-description: How to set up a Client Credentials Grant using the Management API.
+description: Learn how to set up a Client Credentials Grant using the Management API.
crews: crew-2
topics:
- client-credentials
@@ -9,17 +8,17 @@ contentType: how-to
useCase: secure-api
---
-# Set up a Client Grant using the Management API
+# Set Up Client Credentials Grants Using the Management API
-Auth0 lets you authorize applications that have the 'Client Credential' grant type enabled to call APIs using the OAuth Client Credentials Grant.
+Auth0 lets you authorize applications that have the Client Credentials grant type enabled to call APIs using the [Client Credentials Flow](/flows/concepts/client-credentials).
-By default, all Machine to Machine Applications and Regular Web Applications have it the 'Client Credentials' grant enabled, but they are not authorized to call any API.
+By default, all Machine-to-Machine Applications and Regular Web Applications have the 'Client Credentials' grant enabled, but they are not authorized to call any API.
-If you want to call an API from these applications, you first need to authorize the application to call the API and specify the scopes that will be granted. You can do that [using the Dashboard](/api-auth/config/using-the-dashboard), or follow the steps below to use the API.
+If you want to call an API from these applications, you first need to authorize the application to call the API and specify the scopes that will be granted. You can do that [using the Dashboard](/api-auth/config/using-the-auth0-dashboard), or follow the steps below to use the API.
You will need the following:
-- A Management API access token with the `create:client_grants` scopes. For details on how to get one refer to [How to Get an Access Token for the Management API](/api/management/v2/tokens).
+- A Management API Access Token with the `create:client_grants` scopes. For details on how to get one, refer to [Access Tokens for the Management API](/api/management/v2/tokens).
- The application information (`Client_Id` and `Client_Secret`) for the application you want to authorize [Auth0 dashboard](${manage_url}/#/applications).
@@ -27,7 +26,7 @@ You will need the following:
## Authorize the Application
-To authorize your Application send a `POST` request to the [/client-grants endpoint of the Management APIv2](/api/management/v2#!/Client_Grants/post_client_grants) with the Management API Access Token.
+To authorize your Application, send a `POST` request to the [/client-grants endpoint of the Management APIv2](/api/management/v2#!/Client_Grants/post_client_grants) with the Management API Access Token.
The following example authorizes the application with Id `${account.clientId}`, to access the API with Identifier `https://my-api-urn`, while granting the scope `sample-scope`.
@@ -59,12 +58,12 @@ Sample response:
}
```
-That's it, you are done! Now that all the elements are in place, you can request Access Tokens for your API from Auth0 using the Client Credentials Grant.
+That's it, you are done! Now that all the elements are in place, you can request Access Tokens for your API from Auth0 using the Client Credentials Flow.
## Keep reading
:::next-steps
-* [How to implement the Client Credentials Grant](/api-auth/tutorials/client-credentials)
+* [Call API using the Client Credentials Flow](/flows/guides/client-credentials/call-api-client-credentials)
* [How to change the scopes and add custom claims to a token using Hooks](/api-auth/tutorials/client-credentials/customize-with-hooks)
-* [How to add custom claims to a token using Rules](/scopes#custom-claims)
+* [How to add custom claims to a token using Rules](/scopes/current/sample-use-cases#add-custom-claims-to-a-token)
:::
diff --git a/articles/api-auth/dynamic-client-registration.md b/articles/api-auth/dynamic-client-registration.md
index e6683e31eb..6bac759f08 100644
--- a/articles/api-auth/dynamic-client-registration.md
+++ b/articles/api-auth/dynamic-client-registration.md
@@ -1,6 +1,5 @@
---
-title: Dynamic Client Registration
-description: How to dynamically register applications with Auth0 using the Management API
+description: Learn how to dynamically register applications with Auth0 using the Management API.
crews: crew-2
toc: true
topics:
@@ -13,27 +12,17 @@ useCase:
# Dynamic Client Registration
-<%= include('../_includes/_pipeline2') %>
-
-Dynamic Client Registration enables you to register applications dynamically. These applications can be either [first-party or third-party applications](/applications/application-types#first-vs-third-party-applications).
+Dynamic Client Registration enables you to register [third-party applications](/applications/guides/enable-third-party-apps) dynamically.
This feature is based on the [OpenID Connect Dynamic Client Registration specification](https://openid.net/specs/openid-connect-registration-1_0.html) and in this article we will see how you can enable and use it.
## Enable dynamic registration
-By default, the feature is disabled for all tenants. To change this, you have to:
-
-- update your tenant settings
-- promote the connections you will use with your dynamic applications to **domain connections**, and
-- update your application's login page (if you use [Lock](/libraries/lock/v11))
-
::: warning
Auth0 supports **Open Dynamic Registration**, which means that if you enable this feature, **anyone** will be able to create applications in your tenant without a token.
:::
-### Update tenant settings
-
-Set the `enable_dynamic_client_registration` flag to `true` in your tenant's settings.
+By default, the feature is disabled for all tenants. To change this, you have to set the `enable_dynamic_client_registration` flag to `true` in your tenant's settings.
This can be done by enabling the **OIDC Dynamic Application Registration** toggle on your tenant's [Advanced Settings page](${manage_url}/#/tenant/advanced).
@@ -55,76 +44,7 @@ Alternatively, you can update this flag using the [Update tenant settings endpoi
}
```
-You need to update the `API2_ACCESS_TOKEN` with a valid token with the scope `update:tenant_settings`. See [How to get a Management APIv2 Token](/api/management/v2/tokens#how-to-get-a-management-apiv2-token) for details on how to do so.
-
-### Promote connections
-
-Applications registered via the [Dynamic Application Registration Endpoint](#register-your-application) can only authenticate users using connections flagged as **Domain Connections**. These connections will be open for any dynamic application to allow users to authenticate.
-
-You can promote a connection to domain level using the [Update a Connection endpoint](/api/management/v2#!/Connections/patch_connections_by_id).
-
-```har
-{
- "method": "PATCH",
- "url": "https://${account.namespace}/api/v2/connections/CONNECTION_ID",
- "headers": [
- { "name": "Content-Type", "value": "application/json" },
- { "name": "Authorization", "value": "Bearer API2_ACCESS_TOKEN" },
- { "name": "Cache-Control", "value": "no-cache" }
- ],
- "postData": {
- "mimeType": "application/json",
- "text" : "{ \"is_domain_connection\": true }"
- }
-}
-```
-
-Where:
-- `API2_ACCESS_TOKEN`: [Α valid Auth0 API2 token](/api/management/v2/tokens#how-to-get-a-management-apiv2-token) with the scope `update:connections`
-- `CONNECTION_ID`: Τhe Id of the connection to be promoted
-
-
-### Update the login page
-
-To use the Auth0's [Universal Login](/hosted-pages/login) with the Dynamic Application feature, you need to use at least version `10.7.x` of Lock, and set `__useTenantInfo: config.isThirdPartyClient` when instantiating Lock.
-
-Sample script:
-
-```html
-
-...
-
-```
+You need to update the `API2_ACCESS_TOKEN` with a valid token with the scope `update:tenant_settings`. See [Access Tokens for the Management API](/api/management/v2/tokens) for details on how to do so.
## Use dynamic registration
@@ -132,9 +52,9 @@ In this section we will see how you can dynamically register and configure an ap
### Register your application
-In order to dynamically register an application with Auth0, you need to send an HTTP `POST` message to the Application Registration endpoint: `https://${account.namespace}/oidc/register`. Note that Auth0 supports **Open Dynamic Registration**, which means that the endpoint will accept a registration request without an [Access Token](/tokens/access-token).
+To dynamically register an application with Auth0, you need to send an HTTP `POST` message to the Application Registration endpoint: `https://${account.namespace}/oidc/register`. Note that Auth0 supports **Open Dynamic Registration**, which means that the endpoint will accept a registration request without an Access Token.
-To create an application with the name `My Dynamic application` and the callback URLs `https://application.example.com/callback` and `https://application.example.com/callback2`, use the following snippet.
+To create an application with the name `My Dynamic application` and the callback URLs `https://application.example.com/callback` and `https://application.example.com/callback2`, use the following snippet.
```har
{
@@ -154,7 +74,7 @@ Where:
- **client_name**: The name of the Dynamic Application to be created
- **redirect_uris** (required): An array of URLs that Auth0 will deem valid to call at the end of an authentication flow
-Optionally, you can set a value for `token_endpoint_auth_method`, which can be `none` or `client_secret_post` (default value).
+Optionally, you can set a value for `token_endpoint_auth_method`, which can be `none` or `client_secret_post` (default value). Use `token_endpoint_auth_method: none` in the request payload if creating a SPA.
The response includes the basic application information.
@@ -175,7 +95,7 @@ Content-Type: application/json
Where:
- **client_id**: Unique client identifier. This is the ID you will use while configuring your apps to use Auth0. It is generated by the system and it cannot be modified.
-- **client_secret**: Alphanumeric 64-bit client secret. This value is used by applications to authenticate to the [token endpoint](/api/authentication#get-token) and for signing and validating [ID Tokens](/tokens/id-token).
+- **client_secret**: Alphanumeric 64-bit client secret. This value is used by applications to authenticate to the [token endpoint](/api/authentication#get-token) and for signing and validating [ID Tokens](/tokens/concepts/id-tokens).
- **client_secret_expires_at**: Time at which the `client_secret` will expire. For Auth0 this value will always be zero (`0`) which means that the application never expires.
Make a note of the Client ID and Secret, as these are the most important pieces for executing [authentication](/application-auth) and [authorization](/api-auth) flows.
@@ -186,7 +106,7 @@ Also, keep in mind that third-party developers are not allowed to modify the app
Now that you have a Client ID and Secret, you can configure your application to authenticate users with Auth0.
-We will go through a simple example, that shows how to call an API from a client-side web app, using the [Implicit Grant](/api-auth/tutorials/implicit-grant). For a list of tutorials on how to authenticate and authorize users, based on your application type, see the [API Authorization](/api-auth) page.
+We will go through a simple example, that shows how to call an API from a client-side web app, using the [Implicit Flow](/flows/guides/implicit/call-api-implicit). For a list of tutorials on how to authenticate and authorize users, based on your application type, see the [API Authorization](/api-auth) page.
First, you need to configure your application to send the user to the authorization URL:
@@ -197,12 +117,12 @@ https://${account.namespace}/authorize?
response_type={RESPONSE_TYPE}&
client_id=${account.clientId}&
redirect_uri=${account.callback}&
- nonce={CRYPTOGRAPHIC_NONCE}
+ nonce={NONCE}
state={OPAQUE_VALUE}
```
Where:
-- **audience** (optional): The target API for which the Application is requesting access on behalf of the user. Set this parameter if you need API access.
+- **audience** (optional): The target API for which the Application is requesting access on behalf of the user. Set this parameter if you need API access.
- **scope** (optional): The scopes which you want to request authorization for. These must be separated by a space. You can request any of the [standard OIDC scopes](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) about users, such as `profile` and `email`, custom claims that must conform to a namespaced format (see panel below for more info), or any scopes supported by the target API (for example, `read:contacts`). Set this parameter if you need API access.
::: panel Custom claims namespaced format
@@ -225,4 +145,4 @@ For example:
This call will redirect the user to Auth0, and upon successful authentication, back to your application (specifically to the **redirect_uri**).
-If you need API access, then following the authentication, you need to [extract the Access Token](/api-auth/tutorials/implicit-grant#2-extract-the-access-token) from the hash fragment of the URL, and use it to make calls to the API, by passing it as a `Bearer` token in the `Authorization` header of the HTTP request.
+If you need API access, then following the authentication, you need to extract the Access Token from the hash fragment of the URL, and use it to make calls to the API, by passing it as a `Bearer` token in the `Authorization` header of the HTTP request.
diff --git a/articles/api-auth/faq.md b/articles/api-auth/faq.md
index 5c56bc63d3..d5fea1d7e6 100644
--- a/articles/api-auth/faq.md
+++ b/articles/api-auth/faq.md
@@ -16,13 +16,13 @@ useCase:
## I have an Application that needs to talk to different Resource Servers
-If a single Application needs Access Tokens for different resource servers, then multiple calls to `/authorize` (that is, multiple executions of the same or different Authorization Flow) needs to be performed. Each authorization will use a different value for `audience`, which will result in a different Access Token at the end of the flow.
+If a single Application needs Access Tokens for different resource servers, then multiple calls to `/authorize` (that is, multiple executions of the same or different Authorization Flow) needs to be performed. Each authorization will use a different value for `audience`, which will result in a different Access Token at the end of the flow.
For more information, see the [OAuth 2.0: Audience Information Specification](https://tools.ietf.org/html/draft-tschofenig-oauth-audience-00#section-3).
## Can I try the endpoints before I implement my application?
-**A** Sure! You have two options:
+Sure! You have two options:
- [Download our Postman collection](https://app.getpostman.com/run-collection/2a9bc47495ab00cda178). For more information on how to use our Postman collection refer to [Using the Auth0 API with our Postman Collections](/api/postman).
- Use our [Authentication API Debugger Extension](/extensions/authentication-api-debugger). You can find detailed instructions per endpoint/grant at our [Authentication API Reference](/api/authentication).
diff --git a/articles/api-auth/grant/authorization-code-pkce.md b/articles/api-auth/grant/authorization-code-pkce.md
index c3b3f76c4d..fb575ab2c1 100644
--- a/articles/api-auth/grant/authorization-code-pkce.md
+++ b/articles/api-auth/grant/authorization-code-pkce.md
@@ -9,11 +9,9 @@ useCase:
- secure-api
- call-api
---
-# Calling APIs from Mobile Apps
+# Call APIs from Mobile Apps
-<%= include('../../_includes/_pipeline2') %>
-
-In order to access an API from a [mobile app](/quickstart/native), you need to implement the **Authorization Code using Proof Key for Code Exchange (PKCE)** OAuth 2.0 grant. In this document we will see how this flow works.
+To access an API from a [mobile app](/quickstart/native), you need to implement the **Authorization Code using Proof Key for Code Exchange (PKCE)** OAuth 2.0 grant. In this document, we will see how this flow works.
::: note
If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth 2.0](/protocols/oauth2) article.
@@ -21,7 +19,7 @@ If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth
## Overview of the flow
-The [Authorization Code Grant](/api-auth/grant/authorization-code) has some security issues, when implemented on native applications. For instance, a malicious attacker can intercept the `authorization_code` returned by Auth0 and exchange it for an [Access Token](/tokens/access-token) (and possibly a [Refresh Token](/tokens/refresh-token)).
+The [Authorization Code Grant](/api-auth/grant/authorization-code) has some security issues when implemented on native applications. For instance, a malicious attacker can intercept the `authorization_code` returned by Auth0 and exchange it for an Access Token (and possibly a Refresh Token).
The **Proof Key for Code Exchange (PKCE)** (defined in [RFC 7636](https://tools.ietf.org/html/rfc7636)) is a technique used to mitigate this authorization code interception attack.
@@ -29,18 +27,18 @@ With PKCE, the application creates, for every authorization request, a cryptogra

- 1. The native app initiates the flow and redirects the user to Auth0 (specifically to the [/authorize endpoint](/api/authentication#authorization-code-grant-pkce-)), sending the `code_challenge` and `code_challenge_method` parameters.
+ 1. The native application initiates the flow and redirects the user to Auth0 (specifically to the [/authorize endpoint](/api/authentication#authorization-code-grant-pkce-)), sending the `code_challenge` and `code_challenge_method` parameters.
- 2. Auth0 redirects the user to the native app with an `authorization_code` in the querystring.
+ 2. Auth0 redirects the user to the native application with an `authorization_code` in the querystring.
- 3. The native app sends the `authorization_code` and `code_verifier` together with the `redirect_uri` and the `client_id` to Auth0. This is done using the [/oauth/token endpoint](/api/authentication?http#authorization-code-pkce-).
+ 3. The native application sends the `authorization_code` and `code_verifier` together with the `redirect_uri` and the `client_id` to Auth0. This is done using the [/oauth/token endpoint](/api/authentication?http#authorization-code-pkce-).
4. Auth0 validates this information and returns an Access Token (and optionally a Refresh Token).
- 5. The native app can use the Access Token to call the API on behalf of the user.
+ 5. The native application can use the Access Token to call the API on behalf of the user.
::: note
-In OAuth 2.0 terms, the native app is the Client, the end user the Resource Owner, the API the Resource Server, the browser the User Agent, and Auth0 the Authorization Server.
+In OAuth 2.0 terms, the native application is the Client, the end user the Resource Owner, the API the Resource Server, the browser the User Agent, and Auth0 the Authorization Server.
:::
## How to implement the flow
@@ -58,7 +56,6 @@ For details on how to implement this, refer to [Execute an Authorization Code Gr
::: next-steps
- [Execute an Authorization Code Grant Flow with PKCE](/api-auth/tutorials/authorization-code-grant-pkce)
- [How to configure an API in Auth0](/apis)
-- [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
+- [Tokens](/tokens)
- [Application Authentication for Mobile & Desktop Apps](/application-auth/mobile-desktop)
-- [Tokens used by Auth0](/tokens)
:::
diff --git a/articles/api-auth/grant/authorization-code.md b/articles/api-auth/grant/authorization-code.md
index edc82248d9..45412c6e0b 100644
--- a/articles/api-auth/grant/authorization-code.md
+++ b/articles/api-auth/grant/authorization-code.md
@@ -8,9 +8,7 @@ useCase:
- secure-api
- call-api
---
-# Calling APIs from Server-side Web Apps
-
-<%= include('../../_includes/_pipeline2') %>
+# Call APIs from Server-side Web Apps
In order to access an API from a [regular web app](/quickstart/webapp), you need to implement the **Authorization Code** OAuth 2.0 grant. In this document we will see how this flow works.
@@ -20,7 +18,7 @@ If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth
## Overview of the flow
-The **Authorization Code Grant** (defined in [RFC 6749, section 4.1](https://tools.ietf.org/html/rfc6749#section-4.1)) is a flow where the browser receives an Authorization Code from Auth0 and sends this to the web app. The web app will then interact with Auth0 and exchange the Authorization Code for an [Access Token](/tokens/access-token), and optionally an [ID Token](/tokens/id-token) and a [Refresh Token](/tokens/refresh_token). The web app can now use this Access Token to call the API on behalf of the user.
+The **Authorization Code Grant** (defined in [RFC 6749, section 4.1](https://tools.ietf.org/html/rfc6749#section-4.1)) is a flow where the browser receives an Authorization Code from Auth0 and sends this to the web app. The web app will then interact with Auth0 and exchange the Authorization Code for an [Access Token](/tokens/concepts/access-tokens), and optionally an [ID Token](/tokens/concepts/id-tokens) and a Refresh Token. The web app can now use this Access Token to call the API on behalf of the user.

@@ -56,7 +54,6 @@ For details on how to implement this, refer to [Execute an Authorization Code Gr
::: next-steps
- [How to implement an Authorization Code Grant flow](/api-auth/tutorials/authorization-code-grant)
- [How to configure an API in Auth0](/apis)
-- [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
+- [Tokens](/tokens)
- [Application Authentication for Server-side Web Apps](/application-auth/server-side-web)
-- [Tokens used by Auth0](/tokens)
:::
diff --git a/articles/api-auth/grant/client-credentials.md b/articles/api-auth/grant/client-credentials.md
index fff1ad9981..8fa8cd26d3 100644
--- a/articles/api-auth/grant/client-credentials.md
+++ b/articles/api-auth/grant/client-credentials.md
@@ -12,7 +12,7 @@ useCase:
The **Client Credentials Grant** (defined in [RFC 6749, section 4.4](https://tools.ietf.org/html/rfc6749#section-4.4)) allows an application to request an Access Token using its __Client Id__ and __Client Secret__. It is used for non interactive applications (a CLI, a daemon, or a Service running on your backend) where the token is issued to the application itself, instead of an end user.
-In order to be able to perform the Client Credentials Grant, the Application needs to have the [Client Credentials grant type](/applications/application-grant-types) enabled. Machine to Machine Applications and Regular Web Applications have it enabled by default.
+In order to be able to perform the Client Credentials Grant, the Application needs to have the [Client Credentials grant type](/applications/concepts/application-grant-types) enabled. Machine to Machine Applications and Regular Web Applications have it enabled by default.
## Client Credentials Grant Flow
@@ -37,7 +37,6 @@ For details on how to implement this using Auth0, refer to [Execute a Client Cre
::: next-steps
- [How to implement a Client Credentials flow](/api-auth/tutorials/client-credentials)
- [How to configure an API in Auth0](/apis)
-- [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
+- [Tokens](/tokens)
- [How to change the scopes and add custom claims to the tokens using Hooks](/api-auth/tutorials/client-credentials/customize-with-hooks)
-- [Tokens used by Auth0](/tokens)
:::
diff --git a/articles/api-auth/grant/hybrid.md b/articles/api-auth/grant/hybrid.md
new file mode 100644
index 0000000000..496e658d8b
--- /dev/null
+++ b/articles/api-auth/grant/hybrid.md
@@ -0,0 +1,66 @@
+---
+description: Describes how to call APIs from applications using the Hybrid Flow
+public: false
+topics:
+ - authorization-code
+ - api-authorization
+ - implicit
+contentType: concept
+useCase:
+ - secure-api
+ - call-api
+---
+# Call APIs Using the Hybrid Flow
+
+The Hybrid Flow is an OpenID Connect (OIDC) flow that draws from the following:
+
+1. [Authorization Code Flow](/flows/concepts/auth-code)
+2. [Implicit Flow](/flows/concepts/implicit)
+
+The Hybrid Flow enables use cases where your application can immediately use an ID token to access information about the user while obtaining an authorization code that can be exchanged for an Access Token (therefore gaining access to protected resources for an extended period of time).
+
+## Background
+
+With the [Authorization Code Flow](/flows/concepts/auth-code), Auth0 sends you an authorization code, which your app then sends in to retrieve tokens. Your application authenticates itself with a Client ID and Client Secret stored securely on your server.
+
+On the other hand, the [Implicit Flow](/flows/concepts/implicit) allows you to request Access Tokens without needing to authenticate your application. Auth0 verifies your app's identity based on the provided redirect URI. Because of this, you shouldn't utilize long-lived Access Tokens, and you cannot use Refresh Tokens.
+
+## The Hybrid Flow
+
+The Hybrid Flow allows you to take advantage of aspects of both the Authorization Code and Implicit Grants. For each interaction with Auth0, you will receive two (sometimes three) items in response:
+
+1. An authorization code and an Access Token
+1. An authorization code and an ID Token
+1. An authorization code, an Access Token, and an ID Token
+
+In this article, we will take a closer look at how this flow works.
+
+## Overview of the flow
+
+1. The web application initiates the authorization flow and redirects the browser to Auth0 (specifically, the [Authorization Endpoint](/api/authentication#authorization-code-grant)) so that the user can authenticate.
+
+1. Auth0 authenticates the user via the browser. If this is the first time the user does this, they will see a consent page listing the permissions that Auth0 will give to the application.
+
+1. Auth0 redirects the user to the app with an [Access Token](/tokens/access-token) and (optionally) an [ID Token](/tokens/concepts/id-tokens) in the hash fragment of the URI. The app can now extract the tokens from the hash fragment.
+
+1. The application parses out the Authorization Code, sends it to Auth0's [token endpoint](/api/authentication?http#authorization-code), and requests that Auth0 return (in exchange) the Access Token. The application identifies itself during this request using its assigned Client ID and Client Secret.
+
+1. If the request sent to the token endpoint is valid, Auth0 responds to the application's request with an ID Token, as well as an Access Token (and possibly a Refresh Token).
+
+1. The application can now validate the ID Token and retrieve the end user's information. The application can also use the Access Token to call desired APIs.
+
+ If the application received an ID Token from the Authorization endpoint already, it should have validated the token's signature, `c_hash`, and any other claims as defined. You must validate such tokens [the way you would for an Implicit Flow](https://openid.net/specs/openid-connect-core-1_0.html#ImplicitIDTValidation).
+
+## How to implement the flow
+
+For details on how to implement this using Auth0, refer to [Execute the Hybrid Flow](/api-auth/tutorials/hybrid-flow).
+
+## Keep reading
+
+::: next-steps
+- [Execute the Hybrid Flow](/api-auth/tutorials/hybrid-flow)
+- [How to configure an API in Auth0](/apis)
+- [Tokens](/tokens)
+- [Application authentication for regular web apps](/flows/concepts/auth-code)
+- [Application authentication for single-page apps](/flows/concepts/implicit)
+:::
\ No newline at end of file
diff --git a/articles/api-auth/grant/implicit.md b/articles/api-auth/grant/implicit.md
index 5846093f3a..bf1a08f84c 100644
--- a/articles/api-auth/grant/implicit.md
+++ b/articles/api-auth/grant/implicit.md
@@ -12,9 +12,7 @@ useCase:
---
# Call APIs from Client-side Web Apps
-<%= include('../../_includes/_pipeline2') %>
-
-In order to access an API from a [client-side app](/quickstart/spa) (typically a Single Page Application or a Mobile Application), you need to implement the OAuth 2.0 **Implicit Grant**. In this document we will see how this flow works.
+In order to access an API from a [client-side app](/quickstart/spa) (typically a Single-Page Application or a Mobile Application), you need to implement the OAuth 2.0 **Implicit Grant**. In this document we will see how this flow works.
::: note
If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth 2.0](/protocols/oauth2) article.
@@ -22,7 +20,7 @@ If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth
## Overview
-The **Implicit Grant** (defined in [RFC 6749, section 4.1](https://tools.ietf.org/html/rfc6749#section-4.2)) is similar to the [Authorization Code Grant](/api-auth/grant/authorization-code), but the main difference is that the application receives an [Access Token](/tokens/access-token) directly, without the need for an `authorization_code`. This happens because the application, which is typically a JavaScript app running within a browser, is less trusted than a web app running on the server, hence cannot be trusted with the `client_secret` (which is required in the [Authorization Code Grant](/api-auth/grant/authorization-code)). Also, in the Implicit Grant, no Refresh Tokens are returned for the same reason (for an alternative refer to [Silent authentication for SPAs](/api-auth/tutorials/silent-authentication)).
+The **Implicit Grant** (defined in [RFC 6749, section 4.1](https://tools.ietf.org/html/rfc6749#section-4.2)) is similar to the [Authorization Code Grant](/api-auth/grant/authorization-code), but the main difference is that the application receives an [Access Token](/tokens/concepts/access-tokens) directly, without the need for an `authorization_code`. This happens because the application, which is typically a JavaScript app running within a browser, is less trusted than a web app running on the server, hence cannot be trusted with the `client_secret` (which is required in the [Authorization Code Grant](/api-auth/grant/authorization-code)). Also, in the Implicit Grant, no Refresh Tokens are returned for the same reason (for an alternative refer to [Silent authentication for SPAs](/api-auth/tutorials/silent-authentication)).
Once the user authenticates, the application receives the Access Token in the hash fragment of the URI. The application can now use this Access Token to call the API on behalf of the user.
@@ -32,7 +30,7 @@ Once the user authenticates, the application receives the Access Token in the ha
1. Auth0 authenticates the user. The first time the user goes through this flow a consent page will be shown where the permissions, that will be given to the Application, are listed (for example: post messages, list contacts, and so forth).
- 1. Auth0 redirects the user to the app with an [Access Token](/tokens/access-token) (and optionally an [ID Token](/tokens/id-token)) in the hash fragment of the URI. The app can now extract the tokens from the hash fragment. In a Single Page Application (SPA) this would be done using Javascript and in a Mobile Application this is typically handled by interacting with a Web View.
+ 1. Auth0 redirects the user to the app with an [Access Token](/tokens/concepts/access-tokens) (and optionally an [ID Token](/tokens/concepts/id-tokens)) in the hash fragment of the URI. The app can now extract the tokens from the hash fragment. In a Single-Page Application (SPA) this would be done using Javascript and in a Mobile Application this is typically handled by interacting with a Web View.
1. The app can use the Access Token to call the API on behalf of the user.
@@ -52,7 +50,7 @@ For details on how to implement this, refer to [How to implement the Implicit Gr
## Silent Authentication
-If you need to authenticate your users without a login page (for example, when the user is already logged in via [SSO](/sso) scenario) or get a new Access Token (thus simulate refreshing an expired token), you can use Silent Authentication.
+If you need to authenticate your users without a login page (for example, when the user is already logged in via [Single Sign-on (SSO)](/sso) scenario) or get a new Access Token (thus simulate refreshing an expired token), you can use Silent Authentication.
For details on how to implement this, refer to [Silent Authentication](/api-auth/tutorials/silent-authentication).
@@ -62,6 +60,6 @@ For details on how to implement this, refer to [Silent Authentication](/api-auth
* [How to implement the Implicit Grant](/api-auth/tutorials/implicit-grant)
* [How to protect your SPA against replay attacks](/api-auth/tutorials/nonce)
* [How to configure an API in Auth0](/apis)
-* [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
+* [Tokens](/tokens)
* [Application Authentication for Client-side Web Apps](/application-auth/client-side-web)
:::
diff --git a/articles/api-auth/grant/password.md b/articles/api-auth/grant/password.md
index 48a7f2c31f..3da4c9a514 100644
--- a/articles/api-auth/grant/password.md
+++ b/articles/api-auth/grant/password.md
@@ -12,23 +12,11 @@ useCase:
---
# Call APIs from Highly Trusted Applications
-<%= include('../../_includes/_pipeline2') %>
+<%= include('../_includes/_ropg-warning') %>
-Highly trusted applications can use this flow to access APIs. In this flow the end-user is asked to fill in credentials (username/password), typically using an interactive form. This information is sent to the backend and from there to Auth0.
+You can use the ROPG flow for your highly trusted applications to access APIs. In this flow the end-user is asked to fill in credentials (username/password), typically using an interactive form. This information is sent to the backend and from there to Auth0.
-You should use this flow **only if** the following apply:
-- The application is absolutely trusted with the user's credentials. For [client side](/api-auth/grant/implicit) applications and [mobile apps](/api-auth/grant/authorization-code-pkce) we recommend using web flows instead.
-- Using a redirect-based flow is not possible. If this is not the case and redirects are possible in your application you should use the [Authorization Code Grant](/api-auth/grant/authorization-code) instead.
-
-::: note
-If you need a refresher on the OAuth 2.0 protocol, you can go through our [OAuth 2.0](/protocols/oauth2) article.
-:::
-
-## Overview
-
-The **Resource Owner Password Grant** (defined in [RFC 6749, section 4.3](https://tools.ietf.org/html/rfc6749#section-4.3)) can be used directly as an authorization grant to obtain an Access Token, and optionally a Refresh Token. This grant should only be used when there is a high degree of trust between the user and the application and when other authorization flows are not available.
-
-This grant type can eliminate the need for the application to store the user credentials for future use, by exchanging the credentials with a long-lived Access Token or Refresh Token.
+ROPG (defined in [RFC 6749, section 4.3](https://tools.ietf.org/html/rfc6749#section-4.3)) can be used directly as an authorization grant to store the user credentials for future use, by exchanging the credentials for an Access Token, and optionally a Refresh Token.

@@ -43,9 +31,9 @@ In OAuth 2.0 terms, the web app is the Client, the end user the Resource Owner,
## How to implement the flow
-For details on how to implement this using Auth0, refer to [Execute the Resource Owner Password Grant](/api-auth/tutorials/password-grant).
+For details on how to implement this using Auth0, see [Implement the Resource Owner Password Grant](/api-auth/tutorials/password-grant).
-## Realm Support
+## Realm support
A extension grant that offers similar functionality with the **Resource Owner Password Grant**, including the ability to indicate a specific realm, is the `http://auth0.com/oauth/grant-type/password-realm`.
@@ -55,7 +43,7 @@ For more information on how to implement this extension grant refer to [Executin
## Scopes
-Due to the implied trust in these grants (a user providing his or her password to an application), the Access Token returned will include all of the available scopes defined for the audience API. An application can request a restricted set of scopes by using the `scope` parameter, or you can restrict the returned scopes by using a [rule](#customize-the-returned-token).
+Due to the implied trust in these grants (a user providing his or her password to an application), the Access Token returned will include all of the available scopes defined for the audience API. An application can request a restricted set of scopes by using the `scope` parameter, or you can restrict the returned scopes by using a [rule](#customize-the-returned-token).
## Rules
@@ -65,17 +53,15 @@ Due to the implied trust in these grants (a user providing his or her password t
If you wish to execute special logic unique to the Password exchange, you can look at the `context.protocol` property in your rule. If the value is `oauth2-password`, then the rule is running during the password exchange.
-For details on how to implement this, refer to [Execute the Resource Owner Password Grant: Customize the Tokens](/api-auth/tutorials/password-grant#optional-customize-the-tokens).
+For details on how to implement this, see [Customize the Tokens](/api-auth/tutorials/password-grant#optional-customize-the-tokens).
-## MFA Support
+## MFA support and anomaly detection
-For details on how to implement multi-factor authentication, refer to [Multi-factor Αuthentication and Resource Owner Password](/api-auth/tutorials/multifactor-resource-owner-password).
+For details on how to implement multi-factor authentication (MFA), refer to [Multi-factor Authentication and Resource Owner Password](/mfa/guides/mfa-api/multifactor-resource-owner-password).
+
+When using this flow from server-side applications, some anomaly detection features might fail because of the particularities of this scenario. For details on how to implement this, while avoiding some common issues, refer to [Using Resource Owner Password from Server side](/api-auth/tutorials/using-resource-owner-password-from-server-side).
## Keep reading
-::: next-steps
-* [How to Execute a Resource Owner Password Grant](/api-auth/tutorials/password-grant)
-* [How to use MFA with Resource Owner Password Grant](/api-auth/tutorials/multifactor-resource-owner-password)
-* [Why you should always use Access Tokens to secure an API](/api-auth/why-use-access-tokens-to-secure-apis)
-* [How to use Resource Owner Password Grant from the server side together with Anomaly Detection](/api-auth/tutorials/using-resource-owner-password-from-server-side)
-:::
+* [Implement the Resource Owner Password Grant](/api-auth/tutorials/password-grant)
+* [Tokens](/tokens)
diff --git a/articles/api-auth/index.md b/articles/api-auth/index.md
index 43e9ab512a..2c2bdf84b6 100644
--- a/articles/api-auth/index.md
+++ b/articles/api-auth/index.md
@@ -20,13 +20,9 @@ useCase:
Facebook Analytics Integration
-
Google Analytics Integration
-
If your application executes on a server and you want to configure it to use OAuth 2.0 to access an API, read these docs.
If your application is a native app and you want to configure it to use OAuth 2.0 to access an API, read these docs.
If your application is a JavaScript-centric app executing on the browser, and you want to configure it to use OAuth 2.0 to access an API, read these docs.
If you want to implement server-to-server interaction, and you want to configure it to use OAuth 2.0, read these docs.
- Learn about the differences between Αccess Τoken and ID Τoken and why the latter should never be used to secure an API. + Learn about the types of tokens related to identity and authentication and how they are used by Auth0.
Learn what an API has to do in order to verify a Bearer Access Token.
- Learn how to restrict users/applications from requesting API scopes for which they don't have access. + Learn how to restrict users/applications from accessing APIs.
- Learn how to represent multiple APIs using a single Auth0 API. + Learn how to represent multiple APIs using a single logical API.
"grant_type": "refresh_token"
device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.favorite_color is no longer a valid scope value.device parameter is removed.audience parameter is optional.audience parameter is optional.device parameter was passed and the offline_access scope was requested.device parameter was passed and the offline_access scope was requested.audience parameter and the /userinfo endpoint (provided that the API uses RS256 as the signing algorithm and openid is used as a scope parameter). If you are not implementing your own Resource Server (API), then you can use https://{$account.namespace}/userinfo as the audience parameter, which will return an opaque Access Token.audience parameter and the /userinfo endpoint (provided that the API uses RS256 as the signing algorithm and openid is used as a scope parameter). If you are not implementing your own Resource Server (API), then you can use https://${account.namespace}/userinfo as the audience parameter, which will return an opaque Access Token.offline_access scope was granted.favorite_color claim must be namespaced and added through a rule.favorite_color claim must be namespaced and added through a rule.audience parameter and the /userinfo endpoint (provided that the API uses RS256 as the signing algorithm and openid is used as a scope parameter). If you are not implementing your own Resource Server (API), then you can use https://{$account.namespace}/userinfo as the audience parameter, which will return an opaque Access Token.audience parameter and the /userinfo endpoint (provided that the API uses RS256 as the signing algorithm and openid is used as a scope parameter). If you are not implementing your own Resource Server (API), then you can use https://${account.namespace}/userinfo as the audience parameter, which will return an opaque Access Token.device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.response_type parameter indicates that we want to receive both an Access Token and ID Token.prompt=none instead.response_type parameter indicates that we want to receive both an Access Token and ID Token.prompt=none instead.favorite_color is no longer a valid scope.audience parameter is optional.nonce parameter must be a cryptographically secure random string.audience parameter is optional.nonce parameter must be a cryptographically-secure random string.audience param uses RS256 as signing algorithm) and optionally the resource server specified by the audience parameter.audience param uses RS256 as signing algorithm) and optionally the resource server specified by the audience parameter.response_type=id_token, Auth0 will only return an ID Token.prompt=none instead.favorite_color claim must be namespaced and added through a rule.favorite_color claim must be namespaced and added through a rule.audience param uses RS256 as signing algorithm) as well as the resource server specified by the audience parameter.audience param uses RS256 as signing algorithm) as well as the resource server specified by the audience parameter.device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.device parameter is only needed if requesting a Refresh Token by passing the offline_access scope.POST /oauth/token HTTP 1.1
-Content-Type: application/json
-{
- "grant_type": "http://auth0.com/oauth/grant-type/password-realm",
- "client_id": "123",
- "username": "alice",
- "password": "A3ddj3w",
- "realm": "my-database-connection",
- "scope": "openid email offline_access",
- "audience": "https://api.example.com"
-}
+Content-Type: application/x-www-form-urlencoded
+
+grant_type=http%3A%2F%2Fauth0.com%2Foauth%2Fgrant-type%2Fpassword-realm&client_id=123&username=alice&password=A3ddj3w&realm=my-database-connection&scope=openid+email+offline_access&audience=https%3A%2F%2Fapi.example.com
+
/oauth/token.realm). The standard OIDC password grant is also supported, but it does not accept Auth0-specific parameters such as realm.audience param uses RS256 as signing algorithm) and optionally the resource server specified by the audience parameter.audience param uses RS256 as signing algorithm) and optionally the resource server specified by the audience parameter.offline_access scope was granted.favorite_color claim must be namespaced and added through a rule.favorite_color claim must be namespaced and added through a rule.audience param uses RS256 as signing algorithm) as well as the resource server specified by the audience parameter.audience param uses RS256 as signing algorithm) as well as the resource server specified by the audience parameter.POST /delegation
Content-Type: 'application/json'
{
@@ -41,17 +40,11 @@ Content-Type: 'application/json'
}
POST /oauth/token
-Content-Type: application/json
-{
- "grant_type": "refresh_token",
- "refresh_token": "...",
- "client_id": "...",
- "client_secret": "...",
- "scope": "openid profile",
- "audience": "https://api.example.com"
-}
+Content-Type: application/x-www-form-urlencoded
+
+grant_type=refresh_token&refresh_token=123&client_id=123&client_secret=123&scope=openid+profile&audience=https%3A%2F%2Fapi.example.com
audience and client_secret parameters are optional. The client_secret is not needed when requesting a refresh_token for a mobile app.x-forwarded-for (or, in general, data from application) as source for the end-user IP can be a big risk. This should not be done unless you know you can trust that header, since it is easy to spoof and makes possible to bypass the anomaly-detection validation.
-| Status | -Description | -
|---|---|
| 400 | -Bad Request | -
| 401 | -Unauthorized | -
| 403 | -Forbidden | -
| 404 | -Not Found | -
| 405 | -Method Not Allowed | -
| 429 | -Too Many Requests | -
| 500 | -Internal Server Error | -
| 503 | -Service Unavailable | -
| Status | -Response | -
|---|---|
| 400 | -{"error": "invalid_request", "error_description": "the connection was disabled"}The connection is not active or not enabled for your client_id |
-
| 400 | -{"error": "invalid_request", "error_description": "the connection was not found"} |
-
| 400 | -{"error": "invalid_request", "error_description": "missing client_id parameter"} |
-
| 400 | -{"error": "invalid_request", "error_description": "missing access_token parameter"} |
-
| 401 | -{"error": "invalid_request", "error_description": "invalid access_token: invalid_token"}The access_token is invalid or does not contain the scope you set |
-
| 403 | -{"error": "unauthorized_client", "error_description": "invalid client"} |
-
| Status | -Description | -
|---|---|
| 200 | -{"error": "invalid_request", "error_description": "..."}The Refresh Token is revoked, does not exist, or was not issued to the client making the revocation request. |
-
| 400 | -{"error": "invalid_request", "error_description": "..."}The required parameters were not sent in the request. |
-
| 401 | -<{"error": "invalid_client", "error_description": "..."}The request is not authorized. Check that the client credentials ( |
-
| Status | -Description | -
|---|---|
| 400 | -{"error": "invalid_request", "error_description": "missing device parameter"}You need to provide a device name for the caller device (like a browser, app, and so on) |
-
| 400 | -{"error": "invalid_request", "error_description": "missing id_token parameter"}For this grant type you need to provide a JWT ID Token |
-
| 400 | -{"error": "invalid_grant", "error_description": "..."}Errors related to an invalid ID Token or user |
-
| Status | -Description | -
|---|---|
| 400 | -{"error": "invalid_request", "error_description": "missing username parameter"} |
-
| 400 | -{"error": "invalid_request", "error_description": "missing password parameter"} |
-
| 400 | -{"error": "invalid_request", "error_description": "missing connection parameter"} |
-
| 400 | -{"error": "invalid_request", "error_description": "scope parameter must be a string"}Incorrect scope formatting; each scope must be separated by whitespace |
-
| 400 | -{"error": "invalid_request", "error_description": "specified strategy does not support requested operation"}The connection/provider does not implement username/password authentication |
-
| 401 | -{"error": "invalid_user_password", "error_description": "Wrong email or password."} |
-
| 401 | -{"error": "unauthorized", "error_description": "user is blocked"} |
-
| 401 | -{ "error": "password_leaked", "error_description": "This login has been blocked because your password has been leaked in another website. We’ve sent you an email with instructions on how to unblock it."} |
-
| 429 | -{"error": "too_many_attempts", "error_description": "..."}Some anomaly detections will return this error |
-
| 429 | -{"error": "too_many_logins", "error_description": "..."}Some anomaly detections will return this error |
-
| Status | -Description | -
|---|---|
| 400 | -{"error": "invalid_request", "error_description": "missing client_id parameter"} |
-
| 400 | -{"error": "invalid_request", "error_description": "the connection was not found"} |
-
| 400 | -{"error": "invalid_request", "error_description": "the connection was disabled"}Check the connection in the dashboard, you may have turned it off for the provided client_id |
-
| 400 | -{"error": "invalid_request", "error_description": "The connection is not yet configured..."}The connection is not properly configured with custom scripts |
-
| 400 | -{"error": "invalid_request", "error_description": "the connection was not found for tenant..."}The connection does not belong to the tenant; check your base url |
-
| 400 | -{"error": "invalid_request", "error_description": "Fields with "." are not allowed, please remove all dotted fields..."}If you are using rules, some field name contains dots |
-
| 403 | -{"error": "unauthorized_client", "error_description": "invalid client"}The provided client_id is not valid |
-
| 403 | -{"error": "access_denied", "error_description": "..."}Validation of specific points raised an access issue |
-
| Status | -Response | -
|---|---|
| 400 | -{"error": "bad.tenant","error_description": "error in tenant - tenant validation failed: invalid_tenant"} |
-
| 400 | -{"error": "bad.client_id", "error_description": "Missing required property: client_id"} |
-
| 400 | -{"error": "bad.connection", "error_description": "Missing required property: connection"} |
-
| 400 | -{"error": "bad.connection", "error_description": "Connection does not exist"} |
-
| 400 | -{"error": "bad.connection", "error_description": "Connection is disabled"} |
-
| 400 | -{"error": "bad.connection", "error_description": "Invalid connection strategy. It must either be a passwordless connection"} |
-
| 400 | -{"error": "bad.authParams", "error_description": "error in authParams - invalid type: string (expected object)"} |
-
| 400 | -{"error": "bad.request", "error_description": "the following properties are not allowed: |
-
| 400 | -{"error": "bad.phone_number", "error_description": "Missing required property: phone_number"} |
-
| 400 | -{"error": "bad.phone_number", "error_description": "String does not match pattern: ^\\+[0-9]{1,15}$"} |
-
| 400 | -{"error": "sms_provider_error", "error_description": " |
-
Try the Auth0 Authentication API in Postman.
- +Try the Auth0 Management API in Postman.
- +- An Auth0 deployment that exists in a dedicated area of Auth0's cloud, your cloud, or your own data center. + An Auth0 deployment that exists in a dedicated area of Auth0's cloud or your AWS cloud.
- In addition to providing tools for monitoring your PSaaS Appliance instances, Auth0 provides integration with select third-party utilities. + Learn how to monitor your PSaaS Appliance instances, so that you always know how it is performing.
- If your business needs require you to create tenants regularly, you may automate this process in your PSaaS Appliance instances. For example, you might need to create one tenant for each customer or project that goes live. -
-
diff --git a/articles/appliance/infrastructure/dns.md b/articles/appliance/infrastructure/dns.md
index 15c8486a9a..2466fa2ca1 100644
--- a/articles/appliance/infrastructure/dns.md
+++ b/articles/appliance/infrastructure/dns.md
@@ -8,6 +8,7 @@ topics:
contentType: reference
useCase: appliance
applianceId: appliance31
+sitemap: false
---
diff --git a/articles/appliance/infrastructure/extensions.md b/articles/appliance/infrastructure/extensions.md
index 82508fdc1c..f2a2e22e74 100644
--- a/articles/appliance/infrastructure/extensions.md
+++ b/articles/appliance/infrastructure/extensions.md
@@ -7,69 +7,70 @@ topics:
- extensions
contentType:
- Reference
- - Index
useCase: appliance
applianceId: appliance32
+sitemap: false
---
# Enable Webtasks, Extensions, and User Search
-Beginning with version `8986`, the PSaaS Appliance supports extensions. This is in addition to support for [Webtasks](appliance/webtasks).
+The PSaaS Appliance supports:
-::: note
-Some of the [Extensions](/extensions) available to users of the Auth0 public cloud are unavailable in the PSaaS Appliance. As such, these do not appear as options in the PSaaS Appliance's Dashboard.
-:::
+* Extensions
+* [Webtasks](appliance/webtasks)
+* User search using Elasticsearch
-Beginning with version `10755`, the PSaaS Appliance supports User Search using Elasticsearch. This allows you to use extensions that require User Search, including the [Delegated Admininstration extension](/extensions/delegated-admin)
+## Extensions
-## Requirements for Enabling User Search
+You can find a list of extensions available to you [in the Dashboard](${manage_url}/#/extensions).
-To enable User Search, you must increase the amount of storage available in your Development and Production environments.
+Some of the [Extensions available to users of the Auth0 public cloud](/extensions) are unavailable in the PSaaS Appliance. As such, these do not appear as options in the PSaaS Appliance's Dashboard.
-* If you have a *single non-Production/Development node*, you need an additional **50 GB** drive;
-* If you have a *three-node Production cluster*, you need an additional **100 GB** drive on *each* of your three Virtual Machines;
-* If you have a *Geographic High-Availability implementation*, you need an additional **100 GB** drive on *each* of your data nodes in the primary and secondary data centers.
+## Webtasks Requirements
-For all other configuration types, please consult with your Customer Success Engineer.
-
-## Enabling User Search
-
-Once you have added the additional drive(s), submit a Support ticket to request that Auth0:
-
-* Enable User Search;
-* Update your PSaaS Appliance to version `10755` or above. Auth0 will work with you to upgrade your Development environment first, so that you can test the changes. Auth0 will coordinate the Production upgrade after you've concluded testing in Development.
-
-## Requirements for Enabling Webtasks
-
-Your Development and/or Production environments must meet the following requirements before you can enable Webtasks and update to version `8986` or above.
+Your Development and Production environments must meet the following requirements before you can enable Webtasks:
* All nodes in the cluster have outbound access using **Port 443** to:
* `docker.it.auth0.com` (or `52.9.124.234`)
- * Please note that version 8293 required outbound access to `docker.it.auth0.com` (or `52.9.124.234`) on Port **5000**.
* `cdn.auth0.com`
-* All nodes are able to communicate with other nodes in the same cluster using ports **8721** and **8701**.
+* All nodes can communicate with other nodes in the same cluster using ports **8721** and **8701**.
* All [SSL certificates](/appliance/infrastructure/security#ssl-certificates) have the appropriate Webtask DNS entry. Examples:
* `webtask.Required by the PSaaS Appliance to resolve host names internal and external to your environment
Yes
+ This guidance is relevant to all project stakeholders. We recommend reading it in its entirety at least once, even if you've already started your journey with Auth0. We provide a Project Planning Guide in PDF format, details about how to get started with each phase of the implementation process, and checklists to help you manage the tasks in each phase. +
++ This guidance is relevant to all project stakeholders. We recommend reading it in its entirety at least once, even if you've already started your journey with Auth0. We provide a Project Planning Guide in PDF format, details about how to get started with each phase of the implementation process, and checklists to help you manage the tasks in each phase. +
++ This page describes the typical architecture scenarios we have identified when working with customers on implementing Auth0. +
+SaaS applications with users associated with third-party companies registered as tenants of the SaaS app.
+SaaS/eCommerce apps with customers as end users using the OpenID Connect protocol.
+Enterprise directory services using federation to allow employees to log in to applications using their existing enterprise credentials.
+Traditional web application which needs to authenticate users using OpenID Connect.
+Traditional web application which needs to authenticate users using OpenID Connect (OIDC).
Single Page Web Application which talks to an API. The application will use OpenID Connect with the Implicit Grant Flow to authenticate users with Auth0.
+Single-Page Web Application which talks to an API. The application will use OpenID Connect with the Implicit Grant Flow to authenticate users with Auth0.
Traditional web application which needs to authenticate users using SAML2.
-SaaS applications with users associated with third-party companies registered as tenants of the SaaS app.
-SaaS/eCommerce apps with customers as end users using the OpenID Connect protocol.
-Enterprise directory services using federation to allow employees to log in to applications using their existing enterprise credentials.
-Hybrid implementation involving aspects of the B2B and B2E scenarios.
-