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

> Configurez les notifications par SMS et par appel vocal comme facteurs MFA Auth0 avec Twilio, le fournisseur Auth0 intégré ou un fournisseur personnalisé pour envoyer des codes à usage unique.

# Configurer les notifications par SMS et par appel vocal pour 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) + "*****MASQUÉ*****";
          }
          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 centralise toutes les configurations de votre fournisseur de téléphonie à un seul endroit dans votre tenant. Vous n’avez donc pas à configurer plusieurs fois le même fournisseur pour différents facteurs d’authentification téléphonique. Pour en savoir plus, consultez [Use Auth0's Unified Phone Experience for Multi-Factor Authentication](/docs/fr-ca/customize/phone-messages/unified-phone/use-auth0s-unified-phone-experience-for-multi-factor-authentication).
</Warning>

Si vous utilisez le SMS ou l’appel vocal comme facteurs d’authentification, lorsqu’un utilisateur final tente de s’authentifier auprès de votre application, un code lui est envoyé par SMS ou par appel vocal, qu’il devra saisir pour terminer la transaction. Cela signifie qu’il connaît ses informations de connexion et qu’il a en sa possession l’appareil qu’il a enregistré pour utiliser la <Tooltip tip="Multi-factor authentication (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur en plus du nom d’utilisateur et mot de passe, comme un code envoyé par SMS." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=MFA">MFA</Tooltip>.

Vous pouvez configurer le facteur SMS et appel vocal à l’aide du Dashboard ou de la <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> pour envoyer des messages par SMS ou par appel vocal, ou pour permettre aux utilisateurs finaux de choisir comment ils veulent recevoir le code. Vous pouvez configurer votre fournisseur d’envoi de messages à l’aide d’Actions, configurer votre compte Twilio ou, si vous souhaitez envoyer uniquement des SMS à vos 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 l’Authorization Server d’Auth0, pour vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip> pour activer les notifications par appel vocal pour la MFA.

<Card title="La disponibilité varie selon le plan Auth0">
  Votre mise en œuvre de connexion ainsi que votre plan Auth0 ou votre entente personnalisée déterminent si cette fonctionnalité est offerte. Pour en savoir plus, consultez [Pricing](https://auth0.com/pricing).
</Card>

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

Lorsque SMS and 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 and 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>

Lorsque vous activez seulement SMS, le processus 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 and Voice 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 un appel vocal ou un SMS à leur numéro de téléphone enregistré.

<div id="use-the-dashboard">
  ## Utiliser le Dashboard
</div>

1. Accédez à [**Auth0 Dashboard > Sécurité > Multi-factor Auth**](https://manage.auth0.com/#/multifactor-auth).
2. Sélectionnez **Phone Message** et activez le commutateur en haut.
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 Voice, puis sélectionner votre mode d’envoi préféré :

   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é à l’interne par Auth0. Il peut être utilisé uniquement à des fins d’évaluation et de test, et il y a un maximum de 100 messages par tenant pendant toute la durée de vie du tenant. Une fois la limite de 100 messages atteinte, les nouveaux codes ne sont plus reçus.
   2. **Twilio** : Envoie les messages à l’aide de l’[API Twilio Programmable SMS](https://www.twilio.com/sms) pour les SMS ou de l’[API Twilio Programmable Voice](https://www.twilio.com/voice) pour les appels vocaux. Utilisez les identifiants Live de Twilio, et non les identifiants Test, qui servent uniquement à envoyer des messages dans un environnement de production.
   3. **Custom** : Envoie les messages en invoquant une Action dans le [Send Phone Message Flow](/docs/fr-ca/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 qu’il peut falloir jusqu’à huit (8) semaines à Twilio pour transférer et vérifier des importations en bloc. 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). Ce sont les identifiants API Twilio qu’Auth0 utilisera pour envoyer un SMS à l’utilisateur.
2. Vous pourriez aussi devoir activer les permissions 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 effectuer 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 dans votre compte.
3. Configurez la connexion. Accédez à [**Auth0 Dashboard > Sécurité > Multi-factor Auth**](https://manage.auth0.com/#/security/mfa) et choisissez **Phone Message**.
4. Sous **Choose your delivery provider**, choisissez **Twilio** et sélectionnez un mode d’envoi.
5. Saisissez 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 saisir 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 saisir 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 **Message 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. Sélectionnez **Save**.

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

Vous pouvez personnaliser vos modèles de messages SMS et vocaux. Pour en savoir plus, consultez [Personnaliser les messages SMS et vocaux](/docs/fr-ca/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 modes de livraison des messages activés à l’aide du 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](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la portée `update:guardian_factors`, sous forme de bearer token, pour effectuer une requête à 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_PEER

  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 de messagerie SMS intégrés
</div>

Par défaut, Auth0 prend en charge l’envoi de messages au moyen de Twilio. Toutefois, vous pouvez utiliser un autre fournisseur SMS, ajouter une logique particulière 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 pour utiliser l’une de nos [Actions](/docs/fr-ca/customize/actions) intégrées au [Send Phone Message Flow](/docs/fr-ca/customize/actions/explore-triggers/mfa-notifications-trigger).

Les fournisseurs de messagerie 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 de téléphonie personnalisés
</div>

Vous pouvez aussi configurer des fournisseurs de téléphonie personnalisés à l’aide d’Actions. Pour en savoir plus, consultez [Configurer un fournisseur de téléphonie personnalisé](/docs/fr-ca/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 causer des pertes financières.

Auth0 limite chaque utilisateur à l’envoi d’un maximum de 10 messages SMS ou vocaux par heure, et les flux OTP par courriel ou au moyen d’authenticators sont limités à cinq requêtes toutes les cinq minutes. (Le taux de rafale est de 10, mais seulement 1 message vocal par heure est envoyé pour les nouvelles requêtes.) Pour mieux protéger votre compte, envisagez ce qui suit :

* Activer [Suspicious IP Throttling](/docs/fr-ca/secure/attack-protection/suspicious-ip-throttling#signup-attempts). Auth0 bloque une adresse IP si elle tente d’effectuer plus de 50 requêtes d’inscription par minute.
* Activer [Log Streaming](/docs/fr-ca/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](/docs/fr-ca/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 [guide Anti-Fraud pour les développeurs de Twilio](https://www.twilio.com/docs/usage/anti-fraud-developer-guide). Envisagez les options suivantes :

* Limitez les pays vers lesquels vous enverrez des messages pour [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) et [Voice](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 où le risque de [fraude aux appels surtaxés](https://www.twilio.com/learn/voice-and-video/toll-fraud) est plus élevé ou où les tarifs d’appel sont plus coûteux, et avec lesquels vous ne faites habituellement pas affaire.
* Activez 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 code.

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

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