> ## 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.
# Créer une demande de connexion de compte
> Démarrer un flux d’autorisation pour lier le compte de l’utilisateur authentifié à un fournisseur d’identité externe.
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 POST /connected-accounts/connect
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:
/connected-accounts/connect:
post:
tags:
- connected-accounts
summary: Créer une demande de compte connecté
description: >-
Démarrer un flux d’autorisation pour lier le compte de l’utilisateur
authentifié à un fournisseur d’identité externe.
operationId: createConnectedAccountRequest
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/CreateConnectedAccountsRequestContent'
required: true
responses:
'201':
$ref: '#/components/responses/CreateConnectedAccountsResponse'
'400':
$ref: '#/components/responses/BadRequest'
'401':
$ref: '#/components/responses/Unauthorized'
'403':
$ref: '#/components/responses/Forbidden'
'415':
$ref: '#/components/responses/UnsupportedMediaType'
'429':
$ref: '#/components/responses/TooManyRequests'
security:
- Bearer-DPoP:
- create:me:connected_accounts
x-codeSamples: []
components:
schemas:
CreateConnectedAccountsRequestContent:
additionalProperties: false
dependentRequired:
code_challenge:
- code_challenge_method
description: Corps de la requête pour créer une demande de liaison de compte.
properties:
authorization_params:
$ref: '#/components/schemas/AuthorizationParams'
code_challenge:
description: Le défi de code PKCE dérivé du vérificateur de code.
maxLength: 128
minLength: 43
type: string
code_challenge_method:
const: S256
description: >-
La méthode utilisée pour dériver le défi de code. Obligatoire
lorsque code_challenge est fourni.
type: string
connection:
description: >-
Le nom de la connexion avec laquelle lier le compte (p. ex. :
'google-oauth2', 'facebook').
maxLength: 128
minLength: 1
type: string
redirect_uri:
description: >-
L’URI de redirection à utiliser une fois le processus de liaison
terminé.
format: uri
maxLength: 2048
type: string
scopes:
description: >-
Définit les autorisations que l’application demande au fournisseur
d’identité. Doit inclure les scopes standard utilisés pour
identifier l’utilisateur (p. ex. 'openid', 'email', 'profile'), le
scope requis pour obtenir des Refresh Tokens au besoin (p. ex.
'offline_access'), ainsi que tout scope personnalisé dont
l’application a besoin pour accéder aux ressources protégées.
example:
- openid
- offline_access
- read:tasks
- write:tasks
items:
maxLength: 255
minLength: 1
type: string
maxItems: 100
minItems: 1
type: array
uniqueItems: true
state:
description: >-
Une valeur opaque utilisée pour maintenir l’état entre la requête et
le callback.
maxLength: 4096
minLength: 1
type: string
required:
- connection
- redirect_uri
type: object
AuthorizationParams:
additionalProperties: false
description: >-
Paramètres d’autorisation à envoyer au fournisseur d’identité (IdP)
sous-jacent pendant la requête d’autorisation. Ces paramètres
influencent la façon dont l’IdP traite le flux d’autorisation et les
autorisations demandées.
properties:
acr_values:
description: >-
Spécifie les valeurs souhaitées de la référence de classe du
contexte d’authentification, qui indiquent le niveau
d’authentification requis (p. ex. : multifacteur, Passwordless). Le
fournisseur d’identité (IdP) peut appliquer un niveau d’assurance
précis en fonction de ces valeurs.
maxLength: 1024
minLength: 1
type: string
audience:
description: >-
Définit le destinataire prévu du jeton d’accès, en indiquant
généralement à qui le jeton est destiné (p. ex. : un identifiant
d’API).
maxLength: 512
minLength: 1
type: string
display:
$ref: '#/components/schemas/DisplayEnum'
id_token_hint:
description: >-
Fournit un id_token déjà émis au fournisseur d’identité (IdP). Il
peut être utilisé pour indiquer quel utilisateur est en cours
d’authentification ou pour faciliter les requêtes de déconnexion.
maxLength: 4096
minLength: 1
type: string
login_hint:
description: >-
Fournit un indice sur l’identifiant de l’utilisateur (comme une
adresse de courriel ou un nom d’utilisateur) afin de préremplir le
formulaire de connexion.
maxLength: 255
minLength: 1
type: string
max_age:
description: >-
Indique le temps maximal (en secondes) écoulé depuis la dernière
authentification de l’utilisateur. Si cette durée est dépassée,
l’IdP force l’utilisateur à se réauthentifier.
maximum: 2147483647
minimum: 0
type: integer
prompt:
$ref: '#/components/schemas/PromptEnum'
resource:
description: >-
Spécifie à quel serveur de ressources l’application demande l’accès
(utilisé dans les indicateurs de ressource OAuth 2.0).
maxLength: 512
minLength: 1
type: string
ui_locales:
description: >-
Indique les langues préférées pour l’interface utilisateur,
transmises sous forme d’une liste de balises de langue BCP47
séparées par des espaces (p. ex. : 'en', 'es', 'fr').
maxLength: 100
minLength: 2
pattern: ^[a-zA-Z]{2}(-[a-zA-Z]{2})?(\s[a-zA-Z]{2}(-[a-zA-Z]{2})?)*$
type: string
title: Authorization Parameters
type: object
CreateConnectedAccountsResponseContent:
additionalProperties: false
properties:
auth_session:
description: L’identifiant de la session d’authentification.
maxLength: 64
type: string
connect_params:
$ref: '#/components/schemas/ConnectParams'
connect_uri:
description: L’URI de base pour lancer le flux de liaison de compte.
format: uri
type: string
expires_in:
description: Le nombre de secondes avant l’expiration du ticket.
minimum: 1
type: integer
required:
- connect_uri
- auth_session
- connect_params
- expires_in
type: object
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
DisplayEnum:
description: >-
Indique comment le fournisseur d’identité (IdP) doit présenter
l’interface d’authentification à l’utilisateur.
enum:
- page
- popup
- touch
- wap
PromptEnum:
description: >-
Contrôle si le fournisseur d’identité (IdP) doit inviter l’utilisateur à
s’authentifier ou à donner son consentement.
enum:
- none
- login
- consent
- select_account
ConnectParams:
additionalProperties: false
description: Paramètres à utiliser avec l’URI de connexion.
properties:
ticket:
description: L’identifiant du ticket à utiliser avec l’URI de connexion.
type: string
required:
- ticket
type: object
ValidationError:
additionalProperties: false
properties:
detail:
type: string
field:
type: string
pointer:
type: string
source:
type: string
required:
- detail
type: object
responses:
CreateConnectedAccountsResponse:
content:
application/json:
schema:
$ref: '#/components/schemas/CreateConnectedAccountsResponseContent'
description: Demande de liaison de compte créé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'
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.
UnsupportedMediaType:
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
description: Type de média non pris en charge.
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'
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
securitySchemes:
Bearer-DPoP:
description: >-
Les jetons Bearer et DPoP sont pris en charge selon la configuration de
l’API
scheme: bearer
type: http
````