> ## 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 récupérer des listes d’utilisateurs à l’aide du point de terminaison get_users.

# Récupérer des utilisateurs à l’aide du point de terminaison Get Users

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

Le [point de terminaison `GET /api/v2/users`](https://auth0.com/docs/api/management/v2#!/Users/get_users) vous permet de récupérer une liste d’utilisateurs. Avec ce point de terminaison, vous pouvez :

* Effectuer une recherche selon divers critères
* Sélectionner les champs à renvoyer
* Trier les résultats renvoyés

Ce point de terminaison présente une **cohérence éventuelle**; par conséquent, nous vous recommandons de l’utiliser pour les processus de back-office, comme la modification du nom d’affichage d’un utilisateur existant.

<div id="request-example">
  ## Exemple de requête
</div>

Pour rechercher des utilisateurs, faites une requête `GET` au [point de terminaison `/api/v2/users`](https://auth0.com/docs/api/management/v2#!/Users/get_users). La requête doit inclure un [jeton d’accès à la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens). Passez votre requête de recherche dans le paramètre `q` et définissez le paramètre `search_engine` à `v3`.

Par exemple, pour rechercher un utilisateur dont le courriel correspond exactement à `jane@exampleco.com`, utilisez `q=email:"jane@exampleco.com"` :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {yourMgmtApiAccessToken}");
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3"

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

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

  	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.get("https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3")
    .header("authorization", "Bearer {yourMgmtApiAccessToken}")
    .asString();
  ```

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

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/api/v2/users',
    params: {q: 'email:"jane@exampleco.com"', search_engine: 'v3'},
    headers: {authorization: 'Bearer {yourMgmtApiAccessToken}'}
  };

  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/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3",
    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 {yourMgmtApiAccessToken}"
    ],
  ]);

  $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("")

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

  conn.request("GET", "/{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3", headers=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/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3")

  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 {yourMgmtApiAccessToken}'

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

Si la requête réussit, vous recevrez une réponse comme celle-ci :

```json lines expandable theme={null}
[
  {
    "email": "jane@exampleco.com",
    "email_verified": false,
    "username": "janedoe",
    "phone_number": "+199999999999999",
    "phone_verified": false,
    "user_id": "auth0|5457edea1b8f22891a000004",
    "created_at": "",
    "updated_at": "",
    "identities": [
      {
        "connection": "Initial-Connection",
        "user_id": "5457edea1b8f22891a000004",
        "provider": "auth0",
        "isSocial": false
      }
    ],
    "app_metadata": {},
    "user_metadata": {},
    "picture": "",
    "name": "",
    "nickname": "",
    "multifactor": [
      ""
    ],
    "last_ip": "",
    "last_login": "",
    "logins_count": 0,
    "blocked": false,
    "given_name": "",
    "family_name": ""
  }
]
```

<div id="query-examples">
  ## Exemples de requêtes
</div>

Vous trouverez ci-dessous quelques exemples des types de requêtes que vous pouvez effectuer avec la <Tooltip tip="Management API : un 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>.

| Cas d’utilisation                                                                                                                                                                        | Requête                                                                    |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| Rechercher tous les utilisateurs dont le nom contient "john"                                                                                                                             | `name:\*john\*`                                                            |
| Rechercher tous les utilisateurs dont le nom est exactement "jane"                                                                                                                       | `name:"jane"`                                                              |
| Rechercher tous les noms d’utilisateurs qui commencent par "john"                                                                                                                        | `name:john*`                                                               |
| Rechercher les noms d’utilisateurs qui commencent par "jane" et se terminent par "smith"                                                                                                 | `name:jane*smith`                                                          |
| Rechercher tous les utilisateurs dont le courriel est exactement "[john@exampleco.com](mailto:john@exampleco.com)"                                                                       | `email:"john@exampleco.com"`                                               |
| Rechercher tous les utilisateurs dont le courriel est exactement "[john@exampleco.com](mailto:john@exampleco.com)" ou "[jane@exampleco.com](mailto:jane@exampleco.com)" à l’aide de `OR` | `email:("john@exampleco.com" OR "jane@exampleco.com")`                     |
| Rechercher les utilisateurs sans courriel vérifié                                                                                                                                        | `email_verified:false OR NOT \_exists_\:email_verified`                    |
| Rechercher les utilisateurs dont le champ `user_metadata` `full_name` a pour valeur "John Smith"                                                                                         | `user_metadata.full_name:"John Smith"`                                     |
| Rechercher les utilisateurs provenant d’une connexion précise                                                                                                                            | `identities.connection:"google-oauth2"`                                    |
| Rechercher tous les utilisateurs qui ne se sont jamais connectés                                                                                                                         | `(NOT \_exists_\:logins_count OR logins_count:0)`                          |
| Rechercher tous les utilisateurs qui se sont connectés avant 2018                                                                                                                        | `last_login:[* TO 2017-12-31]`                                             |
| Rechercher tous les utilisateurs dont la dernière connexion a eu lieu en décembre 2017                                                                                                   | `last_login:[2017-11 TO 2017-12]`, `last_login:[2017-12-01 TO 2017-12-31]` |
| Rechercher tous les utilisateurs dont le nombre de connexions est >= 100 et \<= 200                                                                                                      | `logins_count:[100 TO 200]`                                                |
| Rechercher tous les utilisateurs dont le nombre de connexions est >= 100                                                                                                                 | `logins_count:[100 TO *]`                                                  |
| Rechercher tous les utilisateurs dont le nombre de connexions est > 100 et \< 200                                                                                                        | `logins_count:\{100 TO 200}`                                               |
| Rechercher tous les utilisateurs dont le domaine du courriel est "exampleco.com"                                                                                                         | `email.domain:"exampleco.com"`                                             |

<div id="limitations">
  ## Limitations
</div>

* Le point de terminaison renvoie un maximum de 50 utilisateurs, même si plus de 50 utilisateurs correspondent à votre requête.
* Si vous devez renvoyer plus de 50 utilisateurs, utilisez le paramètre `page` pour afficher davantage de pages de résultats. Chaque page contient 50 utilisateurs. Par exemple, vous pouvez préciser `&page=2` pour afficher les résultats 51 à 100, `&page=3` pour afficher les résultats 101 à 150, et ainsi de suite. Toutefois, ce point de terminaison ne renvoie jamais plus de 1000 utilisateurs au total pour les mêmes critères de recherche, même avec la pagination.
* Une limite de 1 Mo par utilisateur s’applique aux données utilisateur pouvant être indexées, interrogées et renvoyées par le [point de terminaison de recherche d’utilisateurs](https://auth0.com/docs/api/management/v2/users/get-users). Pour en savoir plus sur l’incidence de cette limite sur les métadonnées personnalisées de plus de 1 Mo, consultez [Metadata Field Names and Data Types](/fr-CA/docs/manage-users/user-accounts/metadata/metadata-fields-data#size-limits-and-storage). Vous devez utiliser le [point de terminaison d’obtention d’un utilisateur](https://auth0.com/docs/api/management/v2/users/get-users-by-id) pour récupérer tous les attributs utilisateur des profils utilisateur qui dépassent cette taille.
* Par défaut, le point de terminaison `GET /api/v2/users` renvoie les résultats dans un ordre déterministe afin qu’une même requête produise chaque fois les mêmes résultats, dans le même ordre logique. Ce comportement est contrôlé par le paramètre de requête `primary_order` :

  * `primary_order=true` (par défaut) : les résultats de requêtes identiques sont systématiquement triés dans le même ordre.
  * `primary_order=false` : les résultats sont renvoyés dans un ordre non déterministe, ce qui peut améliorer les performances pour les requêtes complexes.
* Si votre application n’a pas besoin d’un ordre cohérent des résultats de recherche et que vos requêtes sont suffisamment courtes pour ne pas dépendre de la pagination, définissez `primary_order=false` afin d’améliorer les performances des requêtes.
* Si vous avez besoin d’une exportation complète de tous vos utilisateurs, utilisez la [tâche d’exportation](https://auth0.com/docs/api/management/v2#!/Jobs/post_users_exports) ou l’extension [User Import / Export](/fr-CA/docs/customize/extensions/user-import-export-extension).
* Si vous obtenez l’erreur `414 Request-URI Too Large`, cela signifie que votre chaîne de requête dépasse la longueur prise en charge. Dans ce cas, affinez votre recherche.

Nous ne recommandons **pas** d’utiliser ce point de terminaison pour :

* Les opérations qui exigent une cohérence immédiate. Utilisez plutôt le [point de terminaison Get Users by Email](/fr-CA/docs/manage-users/user-search/retrieve-users-with-get-users-by-email-endpoint) ou le [point de terminaison Get Users by ID](/fr-CA/docs/manage-users/user-search/retrieve-users-with-get-users-by-id-endpoint).
* Les exportations d’utilisateurs. Utilisez plutôt le [point de terminaison User Export](/fr-CA/docs/manage-users/user-migration/bulk-user-exports).
* Les opérations qui exigent une recherche d’utilisateurs dans le cadre de processus d’authentification. Utilisez plutôt le point de terminaison Get Users by Email ou le point de terminaison Get Users by ID.
* La recherche d’utilisateurs pour [Account Linking](/fr-CA/docs/manage-users/user-accounts/user-account-linking) par courriel. Utilisez plutôt le point de terminaison Get Users by Email.

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

* [Syntaxe des requêtes de recherche d’utilisateurs](/fr-CA/docs/manage-users/user-search/user-search-query-syntax)
* [Trier les résultats de recherche](/fr-CA/docs/manage-users/user-search/sort-search-results)
* [Afficher les résultats de recherche par page](/fr-CA/docs/manage-users/user-search/view-search-results-by-page)
* [Exportations groupées d’utilisateurs](/fr-CA/docs/manage-users/user-migration/bulk-user-exports)