> ## 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écrit comment configurer les notifications SMS et vocales pour l’authentification multifacteur (MFA).

# Configurer les notifications SMS et vocales pour l’authentification multifacteur (MFA)

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>;
};

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

<Warning>
  Unified Phone Experience regroupe toutes les configurations de vos fournisseurs de téléphone au même endroit dans votre locataire, ce qui vous évite de configurer plusieurs fois le même fournisseur de téléphone pour différents facteurs d’authentification par téléphone. Pour en savoir plus, consultez [Utiliser Unified Phone Experience d’Auth0 pour l’authentification multifacteur](/fr-CA/docs/customize/phone-messages/unified-phone/use-auth0s-unified-phone-experience-for-multi-factor-authentication).
</Warning>

Si vous utilisez les SMS ou la voix comme facteurs d’authentification, lorsqu’un utilisateur final tente de s’authentifier auprès de votre application, il reçoit un code par SMS ou par appel vocal, qu’il doit saisir pour finaliser la transaction. Cela signifie qu’il connaît ses identifiants de connexion et qu’il a en sa possession l’appareil qu’il a enregistré pour utiliser la <Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur supplémentaire au nom d’utilisateur et au mot de passe, comme un code envoyé par SMS." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=MFA">MFA</Tooltip>.

Vous pouvez configurer les facteurs SMS et vocaux à l’aide de l’Auth0 Dashboard ou de la <Tooltip tip="Management API : produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip> pour envoyer des messages par SMS ou par appel vocal, ou permettre aux utilisateurs finaux de choisir comment ils souhaitent recevoir le code. Vous pouvez configurer votre fournisseur d’envoi à l’aide d’Actions, configurer votre compte Twilio ou, si vous voulez envoyer uniquement des SMS aux clients, configurer le service d’envoi de messages par défaut d’Auth0. Vous devez utiliser l’expérience <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur le serveur d’autorisation d’Auth0, afin de vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Universal+Login">Universal Login</Tooltip> pour activer les notifications vocales pour la MFA.

<Card title="La disponibilité varie selon le forfait Auth0">
  Votre implémentation de connexion et votre forfait Auth0 ou votre entente personnalisée influencent la disponibilité de cette fonctionnalité. Pour en savoir plus, consultez [Tarification](https://auth0.com/pricing).
</Card>

<div id="how-it-works">
  ## Fonctionnement
</div>

Lorsque SMS et Voice sont activés, les utilisateurs peuvent s’inscrire en recevant le code par SMS ou par appel vocal :

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2Q4BViGl71sdrytUDgNJ10/693969bb00444c6bef030e90bb1015f2/2025-02-12_10-06-29.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=963199a983adf4d185cbace53b287c34" alt="Configurer SMS et Voice pour l’expérience utilisateur MFA Voice" width="901" height="834" data-path="docs/images/cdy7uua7fh8z/2Q4BViGl71sdrytUDgNJ10/693969bb00444c6bef030e90bb1015f2/2025-02-12_10-06-29.png" />
</Frame>

Si vous activez uniquement SMS, le flux est plus simple :

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/64PgR0CO1Wjfie2Hxy1Ptw/e6dcf80c0739f8235b473c0291a01e63/2025-02-12_10-07-15.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5681ef6de8dc55385d33d3ffc661f7c9" alt="Configurer SMS pour l’expérience utilisateur MFA SMS" width="899" height="312" data-path="docs/images/cdy7uua7fh8z/64PgR0CO1Wjfie2Hxy1Ptw/e6dcf80c0739f8235b473c0291a01e63/2025-02-12_10-07-15.png" />
</Frame>

Une fois les utilisateurs inscrits, la prochaine fois qu’ils s’authentifieront, ils recevront le message vocal ou le SMS à leur numéro de téléphone enregistré.

<div id="use-the-dashboard">
  ## Utiliser l’Auth0 Dashboard
</div>

1. Accédez à [Dashboard > Security > Multi-factor Auth](https://manage.auth0.com/#/multifactor-auth).
2. Cliquez sur **Phone Message** et activez le bouton bascule en haut de la page.
3. Sélectionnez votre fournisseur d’envoi de messages préféré.
4. Pour permettre aux utilisateurs de s’authentifier par SMS et par appel vocal, vous devez activer les facteurs SMS et d’appel vocal, puis sélectionner votre méthode d’envoi préférée :

   1. **Auth0** : Vous ne pouvez pas utiliser ce fournisseur pour envoyer des messages vocaux. Il envoie des SMS à l’aide du fournisseur d’envoi SMS configuré en interne par Auth0. Il peut être utilisé uniquement à des fins d’évaluation et de test, et il y a une limite maximale de 100 messages par locataire pour toute la durée de vie du locataire. Une fois la limite de 100 messages atteinte, vous ne recevrez plus de nouveaux codes.
   2. **Twilio** : Envoie les messages à l’aide de l’API [Twilio Programmable SMS API](https://www.twilio.com/sms) pour les SMS ou de l’API [Twilio Programmable Voice API](https://www.twilio.com/voice) pour la voix. Utilisez les identifiants Live de Twilio, et non les identifiants de test, qui sont uniquement destinés aux tests et non à l’envoi de messages dans un environnement de production.
   3. **Custom** : Envoie les messages en invoquant une Action dans le [flux Envoi de message téléphonique](/fr-CA/docs/customize/actions/explore-triggers/mfa-notifications-trigger).

   Vous pouvez aussi choisir d’offrir aux utilisateurs l’option de recevoir des SMS, des appels vocaux ou les deux.

<div id="twilio-configuration">
  ### Configuration de Twilio
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Veuillez noter que Twilio peut prendre jusqu’à huit (8) semaines pour traiter et vérifier les importations en lot. Pour en savoir plus, consultez le [Twilio Help Center](https://help.twilio.com/articles/223179468-How-long-does-it-take-to-port-a-number-to-Twilio).
</Callout>

Si vous choisissez d’envoyer des SMS par l’intermédiaire de Twilio, suivez ces étapes pour configurer votre facteur SMS.

1. Ouvrez un compte chez Twilio. Vous aurez besoin d’un [Twilio Account SID](https://www.twilio.com/help/faq/twilio-basics/what-is-an-application-sid) et d’un [Twilio Auth Token](https://www.twilio.com/help/faq/twilio-basics/what-is-the-auth-token-and-how-can-i-change-it). Il s’agit des identifiants de l’API Twilio qu’Auth0 utilisera pour envoyer un SMS à l’utilisateur.
2. Vous devrez peut-être aussi activer les autorisations pour votre région géographique pour les [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) ou la [voix](https://www.twilio.com/console/voice/calls/geo-permissions). Si vous utilisez la voix, votre compte doit avoir un numéro de téléphone Twilio activé pour passer des appels vocaux. Il peut s’agir d’un numéro de téléphone externe [vérifié avec Twilio](https://support.twilio.com/hc/en-us/articles/223180048-Adding-a-Verified-Phone-Number-or-Caller-ID-with-Twilio), ou vous pouvez acheter et configurer un numéro de téléphone Twilio à partir de votre compte.
3. Configurez la connexion. Accédez à [Auth0 Dashboard > Security - Multi-factor Auth](https://manage.auth0.com/#/security/mfa) et choisissez **Phone Message**.
4. Sous **Choose your delivery provider**, choisissez **Twilio** et sélectionnez une méthode d’envoi.
5. Entrez votre **Twilio Account SID** et votre **Twilio Auth Token** dans les champs appropriés.
6. Choisissez votre **SMS Source**.

   1. Si vous choisissez **Use From**, vous devrez entrer le numéro de téléphone **From** que les utilisateurs verront comme expéditeur du SMS. Vous pouvez aussi le configurer dans Twilio.
   2. Si vous choisissez **Use Messaging Services**, vous devrez entrer un [Messaging Service SID](https://www.twilio.com/docs/sms/services/services-send-messages).
   3. Si vous utilisez la voix, vous devez toujours configurer **From** même si vous utilisez **Messaging Services** pour les SMS. Assurez-vous que le numéro de téléphone est configuré pour envoyer à la fois des SMS et des messages vocaux.
7. Cliquez sur **Save**.

<div id="customize-sms-or-voice-message-templates">
  ### Personnaliser les modèles de messages SMS ou de messages vocaux
</div>

Vous pouvez personnaliser vos modèles de messages SMS et de messages vocaux. Pour en savoir plus, consultez [Personnaliser les messages SMS et vocaux](/fr-CA/docs/customize/customize-sms-or-voice-messages).

<div id="use-the-management-api">
  ## Utiliser la Management API
</div>

Vous pouvez utiliser la Management API pour configurer les méthodes d’envoi de messages activées en utilisant le point de terminaison `/api/v2/guardian/factors/phone/message-types`. Le paramètre `message_types` est un tableau qui peut contenir `["sms"]`, `["voice"]` ou `["sms", "voice"]`. Vous avez besoin d’un [jeton d’accès à la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens) avec le scope `update:guardian_factors`, sous forme de jeton Bearer, pour appeler l’API :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PUT \
    --url 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{ "message_types": ["sms", "voice"] }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/guardian/factors/phone/message-types");
  var request = new RestRequest(Method.PUT);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("application/json", "{ "message_types": ["sms", "voice"] }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{yourDomain}/api/v2/guardian/factors/phone/message-types"

  	payload := strings.NewReader("{ "message_types": ["sms", "voice"] }")

  	req, _ := http.NewRequest("PUT", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")

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

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

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

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.put("https://{yourDomain}/api/v2/guardian/factors/phone/message-types")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "message_types": ["sms", "voice"] }")
    .asString();
  ```

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

  var options = {
    method: 'PUT',
    url: 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN'
    },
    data: {message_types: ['sms', 'voice']}
  };

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

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

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/guardian/factors/phone/message-types",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_POSTFIELDS => "{ "message_types": ["sms", "voice"] }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

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

  curl_close($curl);

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

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

  conn = http.client.HTTPSConnection("")

  payload = "{ "message_types": ["sms", "voice"] }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN"
      }

  conn.request("PUT", "/{yourDomain}/api/v2/guardian/factors/phone/message-types", payload, headers)

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

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

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

  url = URI("https://{yourDomain}/api/v2/guardian/factors/phone/message-types")

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

  request = Net::HTTP::Put.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "message_types": ["sms", "voice"] }"

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

<div id="integrated-sms-messaging-providers">
  ## Fournisseurs SMS intégrés
</div>

Par défaut, Auth0 prend en charge l’envoi de messages avec Twilio. Toutefois, vous pouvez utiliser un autre fournisseur SMS et ajouter une logique spécifique avant l’envoi d’un message, ou envoyer un message différent selon l’utilisateur ou l’application. Pour ce faire, configurez la MFA par SMS afin d’utiliser l’une de nos [Actions](/fr-CA/docs/customize/actions) intégrées dans le [flux Envoi de message téléphonique](/fr-CA/docs/customize/actions/explore-triggers/mfa-notifications-trigger).

Les fournisseurs SMS intégrés comprennent :

* [Amazon SNS](https://marketplace.auth0.com/integrations/amazon-sms-provider)
* [ClickSend](https://marketplace.auth0.com/integrations/clicksend-sms)
* [Esendex](https://marketplace.auth0.com/integrations/esendex-sms-provider)
* [Infobip](https://marketplace.auth0.com/integrations/infobip-sms-provider)
* [Mitto](https://marketplace.auth0.com/integrations/mitto-sms-provider)
* [Telesign](https://marketplace.auth0.com/integrations/telesign-sms-verification)

<div id="custom-phone-providers">
  ## Fournisseurs téléphoniques personnalisés
</div>

Vous pouvez également configurer des fournisseurs téléphoniques personnalisés avec Actions. Pour en savoir plus, consultez [Configurer un fournisseur de téléphonie personnalisé](/fr-CA/docs/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider).

<div id="security-considerations">
  ## Considérations de sécurité
</div>

Lorsque vous utilisez un fournisseur de messagerie téléphonique, sachez que des attaquants qui abusent du flux d’inscription pourraient vous faire subir des pertes financières.

Auth0 limite chaque utilisateur à un maximum de 10 messages SMS ou vocaux par heure, et les flux OTP par courriel ou par authentificateur sont limités à cinq demandes toutes les cinq minutes. (Le débit de pointe est de 10, mais seulement 1 message vocal par heure sera envoyé pour les nouvelles demandes.) Pour mieux protéger votre compte, envisagez ce qui suit :

* Activer [Suspicious IP Throttling](/fr-CA/docs/secure/attack-protection/suspicious-ip-throttling#signup-attempts). Auth0 bloquera une adresse IP si elle tente d’effectuer plus de 50 demandes d’inscription par minute.
* Activer [Log Streaming](/fr-CA/docs/customize/log-streams) et créer des alertes à l’aide de votre outil de surveillance préféré lorsque vous constatez des pics dans le nombre d’[événements de journalisation](/fr-CA/docs/deploy-monitor/logs/log-event-type-codes) `gd_send_voice`, `gd_send_voice_failure`, `gd_send_sms` ou `gd_send_sms_failure`.

Les fournisseurs de messagerie téléphonique offrent des protections supplémentaires. Si vous utilisez Twilio, consultez le [Twilio's Anti-Fraud Developer Guide](https://www.twilio.com/docs/usage/anti-fraud-developer-guide). Envisagez les options suivantes :

* Limiter les pays vers lesquels vous envoyez des messages par [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) et par [voix](https://support.twilio.com/hc/en-us/articles/223180228-International-Voice-Dialing-Geographic-Permissions-Geo-Permissions-and-How-They-Work). Cela est particulièrement utile s’il existe des pays présentant un risque plus élevé de [fraude à la surtaxe téléphonique](https://www.twilio.com/learn/voice-and-video/toll-fraud) ou des tarifs d’appel plus élevés, et où vous n’exercez généralement pas d’activités.
* Activer les [déclencheurs d’utilisation](https://support.twilio.com/hc/en-us/articles/223132387-Protect-your-Twilio-project-from-Fraud-with-Usage-Triggers) de Twilio pour protéger votre compte contre la fraude et les erreurs de codage.

<div id="learn-more">
  ## En savoir plus
</div>

* [Inscrire des authentificateurs SMS et vocaux et lancer une vérification](/fr-CA/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Protection contre les attaques](/fr-CA/docs/secure/attack-protection)
* [Flux de journaux](/fr-CA/docs/customize/log-streams)