> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Supprimer une méthode d’authentification
> Supprime une méthode d’authentification de l’utilisateur authentifié.
export const Scopes = ({scopes = []}) => {
return
Scopes
{"Les scopes définissent les autorisations et les niveaux d’accès des requêtes d’API et des jetons d’authentification."}
;
};
## OpenAPI
````yaml fr-CA/docs/oas/myaccount/myaccount-api-oas.json DELETE /authentication-methods/{authentication_method_id}
openapi: 3.1.0
info:
description: >-
L’API My Account d’Auth0 fournit un ensemble dédié de points de terminaison
permettant aux utilisateurs de gérer les renseignements de leur propre
compte. Les clients peuvent utiliser ces API pour créer des expériences
libre-service dans leurs applications ou ajouter progressivement des
renseignements à un compte utilisateur.
L’API My Account fonctionne dans le contexte de l’utilisateur actuellement
connecté et peut être utilisée directement dans les applications destinées
aux utilisateurs.
:::tip Utilisation du domaine Auth0 ou d’un domaine personnalisé
L’API My Account prend en charge l’utilisation de votre domaine Auth0
canonique ou de votre domaine personnalisé, mais vous devez utiliser le même
tout au long du processus, y compris pour les opérations suivantes :
- Obtenir un jeton d’accès
- Définir la valeur d’audience
- Appeler le point de terminaison de l’API My Account
Pour en savoir plus, consultez [Domaines
personnalisés](https://auth0.com/docs/customize/custom-domains).
:::
## Activer l’API My Account
Vous pouvez activer l’API My Account pour votre locataire dans le Auth0
Dashboard :
1. Accédez à Authentification > API.
2. Repérez la bannière MyAccount API.
3. Sélectionnez Activate.
Par défaut, l’API My Account est créée avec les stratégies d’accès des
applications aux API suivantes :
`require_client_grant` pour les flux utilisateur
`deny_all` pour les flux d’application (machine à machine)
Pour qu’une application puisse accéder à l’API My Account au nom de
l’utilisateur, vous devez créer explicitement une autorisation d’application
pour cette application, ce qui vous permet de définir les scopes maximums
que l’application peut demander. Vous pouvez aussi modifier la stratégie des
flux d’accès utilisateur afin d’utiliser allow_all, ce qui permet à toute
application de votre locataire de demander n’importe quel scope à l’API My
Account.
Comme l’API My Account expose des renseignements et des opérations
sensibles, Auth0 ne recommande pas d’utiliser allow_all pour les flux
d’accès utilisateur. Vous devriez appliquer le principe du privilège minimal
avec l’API My Account afin de vous assurer que les applications n’obtiennent
que l’accès dont elles ont réellement besoin, ce qui réduit les risques
potentiels pour la sécurité.
Les permissions finales accordées à l’application seront déterminées par
l’intersection des scopes autorisés par la stratégie d’accès des
applications aux API, des permissions de Contrôle d’accès basé sur les rôles
(RBAC) attribuées à l’utilisateur final et de tout consentement accordé par
l’utilisateur (le cas échéant).
:::info Flux pris en charge
Vous ne pouvez pas mettre à jour la stratégie d’accès des applications à
l’API My Account pour les flux client, ce qui signifie que vous ne pouvez
pas accéder à l’API My Account à l’aide du flux d’identification du client.
:::
Pour en savoir plus sur la gestion des stratégies d’accès des applications
aux API et des autorisations d’application associées, consultez [Accès des
applications aux API : autorisations
d’application](https://auth0.com/docs/get-started/applications/application-access-to-apis-client-grants).
## Obtenir un jeton d’accès
Vous pouvez obtenir un jeton d’accès pour l’API My Account de la même
manière que pour l’une de vos propres API.
:::info
Si vous comptez autoriser l’API My Account à effectuer des opérations
sensibles (comme l’inscription d’une méthode d’authentification), nous vous
recommandons fortement d’utiliser l’[authentification
renforcée](https://auth0.com/docs/secure/multi-factor-authentication/step-up-authentication)
afin d’appliquer des stratégies de sécurité supplémentaires au moyen de
l’[authentification multifacteur
(MFA)](https://auth0.com/docs/secure/multi-factor-authentication).
:::
Si vous utilisez Universal Login, consultez les articles suivants :
- [Appeler votre API à l’aide du flux de code
d’autorisation](https://auth0.com/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/call-your-api-using-the-authorization-code-flow)
- [Appeler votre API à l’aide du flux de code d’autorisation avec
PKCE](https://auth0.com/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce)
Si vous utilisez la connexion intégrée, consultez les articles suivants :
- [Appeler votre API à l’aide du flux de mot de passe du propriétaire de la
ressource](https://auth0.com/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow)
- [Flux de connexion avec l’API de clés d’accès
natives](https://auth0.com/docs/native-passkeys-api#login-flow)
## Exemples
### Universal Login avec flux de code d’autorisation
**Étape 1 : Demander un code d’autorisation**
```
curl --request GET \
--url 'https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F'
```
**Étape 2 : Échanger le code contre un jeton d’accès**
```
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientSecret}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}'
```
### Connexion intégrée avec clés d’accès natives
**Étape 1 : Demander un défi de connexion**
```
curl --request POST \
--url 'https://{yourDomain}/passkey/challenge' \
--header 'content-type: application/json' \
--data '{"client_id": "{yourClientId}"}'
```
**Étape 2 : Authentifier un utilisateur existant**
```
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/", "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}'
```
title: My Account
version: '1.0'
servers:
- url: https://{host}/me/v1
variables:
host:
default: auth0.auth0.com
description: Nom d’hôte personnalisé ou nom d’hôte canonique
security: []
tags:
- description: Facteurs
name: factors
x-displayName: Factors
- description: Connected Accounts
name: connected-accounts
x-displayName: Connected Accounts
- description: Méthodes d’authentification
name: authentication-methods
x-displayName: Authentication Methods
- description: Consentements
name: consents
x-displayName: Consents
paths:
/authentication-methods/{authentication_method_id}:
delete:
tags:
- authentication-methods
summary: Supprimer une méthode d’authentification par id
description: Supprime une méthode d’authentification de l’utilisateur authentifié.
operationId: deleteAuthenticationMethod
parameters:
- $ref: '#/components/parameters/PathAuthenticationMethodId'
responses:
'204':
description: Méthode d’authentification supprimée avec succès
headers:
x-ratelimit-limit:
$ref: '#/components/headers/XRateLimitLimitHeader'
x-ratelimit-remaining:
$ref: '#/components/headers/XRateLimitRemainingHeader'
x-ratelimit-reset:
$ref: '#/components/headers/XRateLimitResetHeader'
'400':
$ref: '#/components/responses/BadRequest'
'401':
$ref: '#/components/responses/Unauthorized'
'403':
$ref: '#/components/responses/Forbidden'
'429':
$ref: '#/components/responses/TooManyRequests'
security:
- Bearer-DPoP:
- delete:me:authentication_methods
x-codeSamples: []
components:
parameters:
PathAuthenticationMethodId:
description: >-
ID de la méthode d’authentification. Cette valeur fait partie de
l’en-tête Location renvoyé lors de la création d’une méthode
d’authentification. Elle doit être utilisée telle quelle, sans aucune
modification.
in: path
name: authentication_method_id
required: true
schema:
$ref: '#/components/schemas/PathAuthenticationMethodId'
headers:
XRateLimitLimitHeader:
description: >-
Le nombre maximal de requêtes autorisées pendant la fenêtre de
limitation
required: true
schema:
type: number
XRateLimitRemainingHeader:
description: >-
Le nombre de requêtes restantes dans la fenêtre actuelle avant qu’elles
ne soient rejetées
required: true
schema:
type: number
XRateLimitResetHeader:
description: >-
L’heure prévue (sous forme d’horodatage UNIX, en secondes) à laquelle le
réservoir sera réapprovisionné
required: true
schema:
type: number
RetryAfterHeader:
description: >-
Le nombre de secondes que le client doit attendre avant d’effectuer une
nouvelle requête
required: true
schema:
type: number
XAuth0ErrorKindHeader:
description: >-
Indique si la limite de débit dépassée est une limite globale (par
locataire).
schema:
const: global-rate-limit
type: string
responses:
BadRequest:
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
description: Entrée non conforme au schéma.
Unauthorized:
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
description: Non autorisé.
Forbidden:
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
description: Interdit.
TooManyRequests:
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
description: Trop de requêtes.
headers:
retry-after:
$ref: '#/components/headers/RetryAfterHeader'
x-auth0-error-kind:
$ref: '#/components/headers/XAuth0ErrorKindHeader'
x-ratelimit-limit:
$ref: '#/components/headers/XRateLimitLimitHeader'
x-ratelimit-remaining:
$ref: '#/components/headers/XRateLimitRemainingHeader'
x-ratelimit-reset:
$ref: '#/components/headers/XRateLimitResetHeader'
schemas:
PathAuthenticationMethodId:
type: string
ErrorResponse:
additionalProperties: false
properties:
detail:
type: string
status:
type: number
title:
type: string
type:
type: string
validation_errors:
items:
$ref: '#/components/schemas/ValidationError'
type: array
required:
- type
- status
- title
- detail
type: object
ValidationError:
additionalProperties: false
properties:
detail:
type: string
field:
type: string
pointer:
type: string
source:
type: string
required:
- detail
type: object
securitySchemes:
Bearer-DPoP:
description: >-
Les jetons Bearer et DPoP sont pris en charge selon la configuration de
l’API
scheme: bearer
type: http
````