# Get strongest password policy of a User

- Operation ID: `getStrongestPasswordSettingsUsingGET`
- HTTP method: `GET`
- Path: `/uauth/strongest-password-settings-by-email/{email}`
- [Human-readable API reference](https://hub.synerise.com/api-reference/identity-and-access-management#tag/Access-control/operation/getStrongestPasswordSettingsUsingGET)

## Self-contained OpenAPI method

The fenced document below contains this method's documentation and all of its local references. It is self-contained; no category or master specification fetch is required.

```yaml
openapi: 3.0.0
info:
  title: Synerise Public API
  version: 1.9.1
paths:
  /uauth/strongest-password-settings-by-email/{email}:
    get:
      tags:
        - Access control
      summary: Get strongest password policy of a User
      description: |
        If a user has access to more than one workspace, you can use this endpoint to find the strictest password policy of all the policies in these workspaces. The user's password must meet the requirements of that strictest policy.

        ---

        **Authentication:** Not required
      operationId: getStrongestPasswordSettingsUsingGET
      parameters:
        - name: email
          in: path
          description: User's email address
          required: true
          schema:
            type: string
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                type: object
                properties:
                  attempts:
                    type: integer
                    format: int32
                    description: The number of failed sign-in attempts after which an account is blocked
                  block:
                    type: integer
                    format: int32
                    description: The number of days after which an account is blocked after the password expires.
                  businessProfileId:
                    type: integer
                    description: ID of the workspace
                  different:
                    type: integer
                    format: int32
                    description: |
                      Defines how many previous passwords are compared.

                      For example, if set to 3, the new password must be different than the 3 last passwords.
                  digits:
                    type: integer
                    format: int32
                    description: The minimum number of digits in a password
                  expiration:
                    type: integer
                    format: int32
                    description: The number of days after which the passwords expire
                  lowerLetters:
                    type: integer
                    format: int32
                    description: The minimum number of lower-case letters in a password
                  maxIdleTime:
                    type: integer
                    format: int32
                    description: Time (in seconds) after which an idle user is signed out
                  maxLength:
                    type: integer
                    format: int32
                    description: The maximum number of characters in a password
                  minLength:
                    type: integer
                    format: int32
                    description: The minimum number of characters in a password
                  nextChange:
                    type: integer
                    format: int32
                    description: Currently not used
                  specialChars:
                    type: integer
                    format: int32
                    description: The minimum number of special characters in a password
                  upperLetters:
                    type: integer
                    format: int32
                    description: The minimum number of upper-case letters in a password
        "401":
          description: Unauthorized
        "403":
          description: Forbidden
        "404":
          description: Not Found
      security:
        - JWT: []
      x-snr-doc-urls:
        - /api-reference/identity-and-access-management#tag/Access-control/operation/getStrongestPasswordSettingsUsingGET
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: |-
            curl --request GET \
              --url https://api.synerise.com/uauth/strongest-password-settings-by-email/%7Bemail%7D \
              --header 'Authorization: Bearer REPLACE_BEARER_TOKEN'
        - lang: Python
          label: Python
          source: |-
            import http.client

            conn = http.client.HTTPSConnection("api.synerise.com")

            headers = { 'Authorization': "Bearer REPLACE_BEARER_TOKEN" }

            conn.request("GET", "/uauth/strongest-password-settings-by-email/%7Bemail%7D", headers=headers)

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

            print(data.decode("utf-8"))
        - lang: JavaScript
          label: JavaScript
          source: |-
            const data = null;

            const xhr = new XMLHttpRequest();
            xhr.withCredentials = true;

            xhr.addEventListener("readystatechange", function () {
              if (this.readyState === this.DONE) {
                console.log(this.responseText);
              }
            });

            xhr.open("GET", "https://api.synerise.com/uauth/strongest-password-settings-by-email/%7Bemail%7D");
            xhr.setRequestHeader("Authorization", "Bearer REPLACE_BEARER_TOKEN");

            xhr.send(data);
        - lang: Node.js
          label: Node.js
          source: |-
            const http = require("https");

            const options = {
              "method": "GET",
              "hostname": "api.synerise.com",
              "port": null,
              "path": "/uauth/strongest-password-settings-by-email/%7Bemail%7D",
              "headers": {
                "Authorization": "Bearer REPLACE_BEARER_TOKEN"
              }
            };

            const req = http.request(options, function (res) {
              const chunks = [];

              res.on("data", function (chunk) {
                chunks.push(chunk);
              });

              res.on("end", function () {
                const body = Buffer.concat(chunks);
                console.log(body.toString());
              });
            });

            req.end();
        - lang: PHP
          label: PHP
          source: |-
            <?php

            $request = new HttpRequest();
            $request->setUrl('https://api.synerise.com/uauth/strongest-password-settings-by-email/%7Bemail%7D');
            $request->setMethod(HTTP_METH_GET);

            $request->setHeaders([
              'Authorization' => 'Bearer REPLACE_BEARER_TOKEN'
            ]);

            try {
              $response = $request->send();

              echo $response->getBody();
            } catch (HttpException $ex) {
              echo $ex;
            }
        - lang: Java
          label: Java
          source: |-
            HttpResponse<String> response = Unirest.get("https://api.synerise.com/uauth/strongest-password-settings-by-email/%7Bemail%7D")
              .header("Authorization", "Bearer REPLACE_BEARER_TOKEN")
              .asString();
servers:
  - description: Microsoft Azure EU
    url: https://api.synerise.com
  - description: Microsoft Azure USA
    url: https://api.azu.synerise.com
  - description: Google Cloud Platform
    url: https://api.geb.synerise.com
tags:
  - name: Access control
components:
  securitySchemes:
    JWT:
      type: http
      scheme: bearer
      description: |-
        JWT Bearer token. The header looks like this: `Bearer {JWT}`

        Remember to include the space between 'Bearer' and the token.

        Generate a token via the **Authorization** endpoints.
```