> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Récupérer des utilisateurs avec le point de terminaison Obtenir utilisateur

> Apprenez à récupérer des listes d’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`](/docs/fr-ca/api/management/v2#!/Users/get_users) vous permet de récupérer une liste d’utilisateurs. Ce point de terminaison permet ce qui suit :

* Rechercher sur la base d’un grand nombre de critères
* Sélectionner les champs à envoyer
* Trier les résultats obtenus

Ce point de terminaison est **persistant** et, à ce titre, nous vous recommandons de l’utiliser pour les processus administratif tels que la modification du nom d’affichage d’un utilisateur existant.

## Exemple de demande

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

Par exemple, pour rechercher un utilisateur dont le courriel est 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);
  });
  ```

  ```objc Obj-C theme={null}
  #import <Foundation/Foundation.h>

  NSDictionary *headers = @{ @"authorization": @"Bearer {yourMgmtApiAccessToken}" };

  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3"]
                                                         cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                     timeoutInterval:10.0];
  [request setHTTPMethod:@"GET"];
  [request setAllHTTPHeaderFields:headers];

  NSURLSession *session = [NSURLSession sharedSession];
  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                  if (error) {
                                                      NSLog(@"%@", error);
                                                  } else {
                                                      NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                      NSLog(@"%@", httpResponse);
                                                  }
                                              }];
  [dataTask resume];
  ```

  ```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
  ```

  ```swift Swift theme={null}
  import Foundation

  let headers = ["authorization": "Bearer {yourMgmtApiAccessToken}"]

  let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/users?q=email%3A%22jane%40exampleco.com%22&search_engine=v3")! as URL,
                                          cachePolicy: .useProtocolCachePolicy,
                                      timeoutInterval: 10.0)
  request.httpMethod = "GET"
  request.allHTTPHeaderFields = headers

  let session = URLSession.shared
  let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
    if (error != nil) {
      print(error)
    } else {
      let httpResponse = response as? HTTPURLResponse
      print(httpResponse)
    }
  })

  dataTask.resume()
  ```
</AuthCodeGroup>

Si la recherche aboutit, vous recevrez une réponse semblable à celle-ci :

```json lines 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": ""
  }
]
```

## Exemples de requêtes

Vous trouverez ci-dessous quelques exemples des types de requêtes que vous pouvez effectuer à l’aide de Management API.

| 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 commençant par « john »                                                                                                                               | `name:john*`                                                               |
| Rechercher les noms d’utilisateurs commençant par « jane » et se terminant 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) » en utilisant `OR` | `email:("john@exampleco.com" OR "jane@exampleco.com")`                     |
| Rechercher des utilisateurs dont le courriel n’a pas été vérifié                                                                                                                              | `email_verified:false OR NOT _exists_:email_verified`                      |
| Rechercher les utilisateurs dont le champ `user_metadata` nommé `full_name` a pour valeur « John Smith »                                                                                      | `user_metadata.full_name:"John Smith"`                                     |
| Rechercher des utilisateurs à partir d’une connexion particulière                                                                                                                             | `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 ayant un nombre de connexions >= 100 et \<= 200                                                                                                              | `logins_count:[100 TO 200]`                                                |
| Rechercher tous les utilisateurs ayant un nombre de connexions >= 100                                                                                                                         | `logins_count:[100 TO *]`                                                  |
| Rechercher tous les utilisateurs ayant un nombre de connexions > 100 et \< 200                                                                                                                | `logins_count:{100 TO 200}`                                                |
| Rechercher tous les utilisateurs dont le domaine de courriel est « exempleco.com »                                                                                                            | `email.domain:"exampleco.com"`                                             |

## Limites

Le point de terminaison renvoie un maximum de 50 utilisateurs, même si davantage d’utilisateurs correspondent à votre requête.

Si vous voulez obtenir plus de 50 utilisateurs, utilisez le paramètre `page` pour afficher un plus grand nombre 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, préciser `&page=3` pour afficher les résultats 101-150, et ainsi de suite. Cependant, ce point de terminaison ne renvoie jamais un total de plus de 1 000 utilisateurs ayant les mêmes critères de recherche, même avec le paramètre page.

Les données utilisateur qui peuvent être indexées, interrogées et renvoyées par le [point de terminaison de recherche utilisateur](https://auth0.com/docs/api/management/v2/users/get-users) sont limitées à 1 Mo par utilisateur. Pour plus d’informations sur la manière dont cela affecte les métadonnées personnalisées de plus de 1 Mo, consultez [Noms des champs de métadonnées et types de données](/docs/fr-ca/manage-users/user-accounts/metadata/metadata-fields-data#size-limits-and-storage). [Le point de terminaison obtenir utilisateur](https://auth0.com/docs/api/management/v2/users/get-users-by-id) doit être utilisé pour récupérer tous les attributs de l’utilisateur pour les profils utilisateurs surdimensionnés.

Si vous avez besoin d’une exportation complète de tous vos utilisateurs, utilisez la [tâche d’exportation](/docs/fr-ca/api/management/v2#!/Jobs/post_users_exports) ou [l’extension Importation/Exportation des utilisateurs.](/docs/fr-ca/customize/extensions/user-import-export).

Si vous obtenez l’erreur `414 Request-URI Too Large`, cela signifie que votre chaîne de requête est plus longue que la longueur prise en charge. Dans ce cas, affinez votre recherche.

Nous ne recommandons **pas** l’utilisation de ce point de terminaison pour :

* Les opérations qui nécessitent une cohérence immédiate. Utilisez plutôt le point de terminaison [Obtenir des utilisateurs par courriel](/docs/fr-ca/manage-users/user-search/retrieve-users-with-get-users-by-email-endpoint) ou [Obtenir des utilisateurs par identifiant](/docs/fr-ca/manage-users/user-search/retrieve-users-with-get-users-by-id-endpoint).
* Les exportations d’utilisateurs. Utilisez plutôt le point de terminaison [Exportation utilisateur](/docs/fr-ca/manage-users/user-migration/bulk-user-exports).
* Les opérations qui nécessitent une recherche de l’utilisateur dans le cadre des processus d’authentification. Utilisez plutôt le point de terminaison Obtenir des utilisateurs par courriel ou Obtenir des utilisateurs par identifiant.
* La recherche d’utilisateurs pour l’[association de comptes](/docs/fr-ca/manage-users/user-accounts/user-account-linking) par courriel. Utilisez plutôt le point de terminaison Obtenir des utilisateurs par courriel.

## En savoir plus

* [Syntaxe de la requête de recherche de l’utilisateur](/docs/fr-ca/manage-users/user-search/user-search-query-syntax)
* [Trier les résultats de recherche](/docs/fr-ca/manage-users/user-search/sort-search-results)
* [Afficher les résultats de la recherche par page](/docs/fr-ca/manage-users/user-search/view-search-results-by-page)
* [Exportations d’utilisateurs en masse](/docs/fr-ca/manage-users/user-migration/bulk-user-exports)
* [Vérifier les appels d’API](/docs/fr-ca/troubleshoot/authentication-issues/check-api-calls)