> ## 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.

> Découvrez comment configurer une passerelle SMS personnalisée pour les connexions Passwordless.

# Configurer une passerelle SMS personnalisée pour les connexions Passwordless

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

<Warning>
  Ce guide présente l’ancienne implémentation SMS personnalisée pour les connexions Passwordless et s’applique uniquement aux locataires Auth0 créés avant mars 2025.

  Les nouveaux locataires doivent suivre les [instructions d’authentification Passwordless avec un fournisseur de téléphone SMS](/fr-CA/docs/authenticate/passwordless/authentication-methods/sms-otp#configure-the-phone-provider).
</Warning>

Ce guide explique comment utiliser une passerelle SMS personnalisée pour envoyer vos codes à usage unique.

Par défaut, les [connexions SMS Passwordless](/fr-CA/docs/authenticate/passwordless/authentication-methods/sms-otp) utilisent [Twilio](https://www.twilio.com) pour envoyer des codes à usage unique. Toutefois, si vous disposez d’une passerelle SMS personnalisée, vous pouvez modifier votre connexion pour l’utiliser à la place.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Auth0 ne prend pas en charge l’authentification SMS standard.
</Callout>

1. Configurez une connexion SMS Passwordless. Pour savoir comment faire, consultez la section Implement Passwordless dans [Connexions Passwordless](/fr-CA/docs/authenticate/passwordless).
2. [Obtenez un Jeton d’accès pour la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens). Vous en aurez besoin pour effectuer des appels à la Management API afin de mettre à jour votre connexion Passwordless.
3. Utilisez le point de terminaison [GET Connections](https://auth0.com/docs/api/management/v2#!/Connections/get_connections) pour récupérer des renseignements sur les connexions associées à votre locataire. Plus précisément, vous devez obtenir l’ID de votre connexion SMS Passwordless afin de pouvoir l’utiliser dans un appel API ultérieur pour mettre à jour la connexion.
   Assurez-vous de remplacer `ACCESS_TOKEN` par le jeton que vous avez obtenu à l’étape 1 avant d’effectuer l’appel suivant à la Management API :

<AuthCodeGroup>
  ```bash cURL lines theme={null}
  curl --request GET \
    --url https://your-auth0-tenant.com/api/v2/connections \
    --header 'authorization: Bearer {yourAccessToken}'
  ```

  ```csharp C# lines theme={null}
  var client = new RestClient("https://your-auth0-tenant.com/api/v2/connections");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {yourAccessToken}");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go lines theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://your-auth0-tenant.com/api/v2/connections"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer {yourAccessToken}")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java lines theme={null}
  HttpResponse response = Unirest.get("https://your-auth0-tenant.com/api/v2/connections")
    .header("authorization", "Bearer {yourAccessToken}")
    .asString();
  ```

  ```javascript Node.JS lines theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://your-auth0-tenant.com/api/v2/connections',
    headers: {authorization: 'Bearer {yourAccessToken}'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP lines theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://your-auth0-tenant.com/api/v2/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {yourAccessToken}"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python lines theme={null}
  import http.client

  conn = http.client.HTTPSConnection("your-auth0-tenant.com")

  headers = { 'authorization': "Bearer {yourAccessToken}" }

  conn.request("GET", "/api/v2/connections", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby lines theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://your-auth0-tenant.com/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer {yourAccessToken}'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

La réponse du point de terminaison sera un tableau d’objets. Chaque objet représente une connexion associée à votre locataire.
4\. Repérez l’ID de votre connexion. Vous pouvez trouver l’ID associé à votre connexion Passwordless en examinant le tableau d’objets renvoyé par le [point de terminaison GET Connections](https://auth0.com/docs/api/management/v2#!/Connections/get_connections) à l’étape 2.
Pour trouver l’objet correspondant à votre connexion Passwordless, vous pouvez rechercher la propriété `"name": "sms"`. Notez que la connexion affiche actuellement les informations Twilio que vous avez fournies pendant le processus de configuration.

```json lines expandable theme={null}
   [
       {
           "id": "con_UX85K7K0N86INi9U",
           "options": {
               "disable_signup": false,
               "name": "sms",
               "twilio_sid": "TWILIO_SID",
               "twilio_token": "TWILIO_AUTH_TOKEN",
               "from": "+15555555555",
               "syntax": "md_with_macros",
               "template": "Your SMS verification code is: @@password@@",
               "totp": {
                   "time_step": 300,
                   "length": 6
               },
               "messaging_service_sid": null,
               "brute_force_protection": true
           },
           "strategy": "sms",
           "name": "sms",
           "is_domain_connection": false,
           "realms": [
               "sms"
           ],
       }
   ]
```

5. Mettez à jour la connexion. Vous pouvez le faire en envoyant une requête PATCH au point de terminaison [Mettre à jour une connexion](https://auth0.com/docs/api/management/v2#!/Connections/patch_connections_by_id). Plus précisément, vous allez mettre à jour l’objet `options` de la connexion afin de fournir des informations sur la passerelle SMS.

   <Warning>
     Vous devez envoyer l’objet `options` dans son intégralité à chaque appel; sinon, vous écraserez les données existantes qui ne sont pas incluses dans les requêtes suivantes.
   </Warning>

   Apportez les modifications suivantes :

   * Supprimez les paramètres `twilio_sid` et `twilio_token`
   * Ajoutez le paramètre `provider` et attribuez-lui la valeur `sms_gateway`
   * Ajoutez le paramètre `gateway_url` et attribuez-lui l’URL de votre passerelle SMS. Auth0 doit pouvoir joindre cette URL pour utiliser votre passerelle afin d’envoyer des messages en votre nom.

   Votre charge utile ressemblera à ceci :

   ```json lines theme={null}
   {
       "options": {
         "strategy": "sms",
         "provider": "sms_gateway",
         "gateway_url": "{urlOfYourGateway}",
         "from": "+1 234 567",
         "template": "Your verification code is: @@password@@",
         "brute_force_protection": true,
         "forward_req_info": "true",
         "disable_signup": false,
         "name": "sms",
         "syntax": "md_with_macros",
         "totp": {
           "time_step": 300,
           "length": 6
         }
       },
       "is_domain_connection": false,
   }
   ```

<div id="authenticated-requests">
  ## Requêtes authentifiées
</div>

Si votre passerelle SMS accepte les requêtes authentifiées par jeton, vous pouvez ajouter ce qui suit à votre objet `options` :

```json lines theme={null}
"gateway_authentication": {
    "method": "bearer",
    "subject": "urn:Auth0",
    "audience": "urn:MySmsGateway",
    "secret": "MySecretToSignTheToken",
    "secret_base64_encoded": false
}
```

Lorsque vous incluez `gateway_authentication` dans votre objet `options`, Auth0 ajoute un [JSON Web Token](/fr-CA/docs/secure/tokens/json-web-tokens) à l’en-tête `Authorization` chaque fois qu’il envoie des requêtes à votre passerelle SMS. Le jeton contient les valeurs `gateway_authentication.subject` et `gateway_authentication.audience`, et il est signé à l’aide de `gateway_authentication.secret`.

Si votre secret est encodé en base64url, définissez `secret_base64_encoded` à `true`.

Une fois la connexion mise à jour, Auth0 enverra ce qui suit à votre passerelle SMS chaque fois qu’un utilisateur s’inscrit ou se connecte avec votre connexion <Tooltip tip="Passwordless : forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Passwordless">Passwordless</Tooltip>.

```json lines theme={null}
{
  "recipient": "+1 399 999",
  "body": "Your verification code is: 12345",
  "sender": "+1 234 567"
}
```

Si vous définissez la propriété `forward_req_info` de l’objet `options` à `true`, la passerelle recevra également des informations sur la requête HTTP qui a déclenché le processus Passwordless. Cela comprend l’adresse IP de l’application qui appelle `/passwordless/start` et son agent utilisateur.

```json lines theme={null}
{
  "recipient": "+1 399 999",
  "body": "Your verification code is: 12345",
  "sender": "+1 234 567",
  "req" : { 
      "ip" : "167.56.227.117",
      "user-agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.109 Safari/537.36"
       }
}
```

<div id="error-handling">
  ## Gestion des erreurs
</div>

Auth0 ne tient compte que du code HTTP renvoyé par la passerelle SMS; il ignore le reste de la réponse (p. ex., le corps et le type de réponse).

Si la passerelle SMS renvoie un code HTTP autre que 200, le point de terminaison `/passwordless/start` renverra un code HTTP 400 ainsi qu’une réponse semblable à la suivante :

```json lines theme={null}
{
 "error":"sms_provider_error",
 "error_description":"Unexpected response while calling the SMS gateway: <HTTP Code Returned by the SMS Gateway>"}
}
```

Si la passerelle SMS renvoie un code HTTP 401, `error_description` sera **Échec de l’authentification lors de l’appel à la passerelle SMS : 401**. (Veuillez noter que le libellé de la description de l’erreur peut changer à tout moment.)

Auth0 impose un délai d’expiration de 30 secondes pour les appels HTTP aux passerelles SMS personnalisées. Si la passerelle SMS ne répond pas dans ce délai, le point de terminaison `/passwordless/start` renverra également un code HTTP 400. La réponse aura le format indiqué ci-dessus et le champ `error_description` sera **Délai d’expiration lors de l’appel à la passerelle SMS : \<Code d’expiration>**. (Là encore, le libellé de la description de l’erreur peut changer à tout moment.)