Obtenir les domaines personnalisés

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.CustomDomains.ListAsync(
            new ListCustomDomainsRequestParameters {
                Q = "q",
                Fields = "fields",
                IncludeFields = true,
                Sort = "sort"
            }
        );
    }

}

package example

import (
    context "context"

    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    mgmt.CustomDomains.List(
        context.TODO(),
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.ListCustomDomainsRequestParameters;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.customDomains().list(
            ListCustomDomainsRequestParameters
                .builder()
                .q("q")
                .fields("fields")
                .includeFields(true)
                .sort("sort")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\CustomDomains\Requests\ListCustomDomainsRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->customDomains->list(
    new ListCustomDomainsRequestParameters([
        'q' => 'q',
        'fields' => 'fields',
        'includeFields' => true,
        'sort' => 'sort',
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.custom_domains.list(
    q="q",
    fields="fields",
    include_fields=True,
    sort="sort",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.custom_domains.list(
  q: "q",
  fields: "fields",
  include_fields: true,
  sort: "sort"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.list();
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.list();
}
main();

[
  {
    "custom_domain_id": "cd_0000000000000001",
    "domain": "login.mycompany.com",
    "primary": false,
    "status": "ready",
    "type": "self_managed_certs",
    "certificate": {
      "error_msg": "<string>",
      "renews_before": "<string>"
    },
    "custom_client_ip_header": "<string>",
    "domain_metadata": {},
    "is_default": false,
    "origin_domain_name": "mycompany_cd_0000000000000001.edge.tenants.auth0.com",
    "relying_party_identifier": "<string>",
    "tls_policy": "recommended",
    "verification": {
      "error_msg": "<string>",
      "last_verified_at": "<string>",
      "methods": [
        {
          "name": "txt",
          "record": "auth0-domain-verification=...",
          "domain": "_cf-custom-hostname.login.mycompany.com"
        }
      ]
    }
  }
]

GET

https://{tenantDomain}/api/v2

custom-domains

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.CustomDomains.ListAsync(
            new ListCustomDomainsRequestParameters {
                Q = "q",
                Fields = "fields",
                IncludeFields = true,
                Sort = "sort"
            }
        );
    }

}

package example

import (
    context "context"

    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    mgmt.CustomDomains.List(
        context.TODO(),
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.ListCustomDomainsRequestParameters;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.customDomains().list(
            ListCustomDomainsRequestParameters
                .builder()
                .q("q")
                .fields("fields")
                .includeFields(true)
                .sort("sort")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\CustomDomains\Requests\ListCustomDomainsRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->customDomains->list(
    new ListCustomDomainsRequestParameters([
        'q' => 'q',
        'fields' => 'fields',
        'includeFields' => true,
        'sort' => 'sort',
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.custom_domains.list(
    q="q",
    fields="fields",
    include_fields=True,
    sort="sort",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.custom_domains.list(
  q: "q",
  fields: "fields",
  include_fields: true,
  sort: "sort"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.list();
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.list();
}
main();

[
  {
    "custom_domain_id": "cd_0000000000000001",
    "domain": "login.mycompany.com",
    "primary": false,
    "status": "ready",
    "type": "self_managed_certs",
    "certificate": {
      "error_msg": "<string>",
      "renews_before": "<string>"
    },
    "custom_client_ip_header": "<string>",
    "domain_metadata": {},
    "is_default": false,
    "origin_domain_name": "mycompany_cd_0000000000000001.edge.tenants.auth0.com",
    "relying_party_identifier": "<string>",
    "tls_policy": "recommended",
    "verification": {
      "error_msg": "<string>",
      "last_verified_at": "<string>",
      "methods": [
        {
          "name": "txt",
          "record": "auth0-domain-verification=...",
          "domain": "_cf-custom-hostname.login.mycompany.com"
        }
      ]
    }
  }
]

Autorisations

Authorization

string

header

requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Paramètres de requête

take

integer

Nombre de résultats par page. La valeur par défaut est 50.

Plage requise: 1 <= x <= 100

from

string

ID facultatif à partir duquel commencer la sélection.

Maximum string length: 1000

string

Requête au format de la syntaxe de chaîne de requête Lucene.

Maximum string length: 1000

fields

string

Liste de champs séparés par des virgules à inclure ou à exclure (selon la valeur fournie pour include_fields) dans le résultat. Laissez ce champ vide pour récupérer tous les champs.

Maximum string length: 100

include_fields

boolean

Indique si les champs précisés doivent être inclus (true) ou exclus (false).

sort

string

Champ de tri. Seul domain:1 (ordre croissant par domaine) est pris en charge pour le moment.

Maximum string length: 15

Réponse

Domaines personnalisés récupérés avec succès.

object[]
object

custom_domain_id

string

défaut:cd_0000000000000001

requis

ID du domaine personnalisé.

domain

string

défaut:login.mycompany.com

requis

Nom de domaine.

primary

boolean

défaut:false

requis

Indique s’il s’agit du domaine principal (true) ou non (false).

status

enum<string>

défaut:ready

requis

Statut de la configuration du domaine personnalisé. Peut être failed, pending_verification ou ready.

Options disponibles:

pending_verification,

ready,

failed

type

enum<string>

défaut:self_managed_certs

requis

Type de provisionnement du domaine personnalisé. Peut être auth0_managed_certs ou self_managed_certs.

Options disponibles:

auth0_managed_certs,

self_managed_certs

certificate

object

Renseignements sur le certificat. Cet objet s’applique uniquement aux domaines personnalisés avec des certificats gérés par Auth0.

Show child attributes

custom_client_ip_header

string | null

Le header HTTP à utiliser pour récupérer l’adresse IP du client

domain_metadata

object

Métadonnées de domaine associées au domaine personnalisé, sous la forme d’un objet avec des valeurs de type chaîne (max. 255 caractères). Un maximum de 10 propriétés de métadonnées de domaine est autorisé.

Show child attributes

is_default

boolean

défaut:false

Indique s’il s’agit du domaine personnalisé par défaut (true) ou non (false).

origin_domain_name

string

défaut:mycompany_cd_0000000000000001.edge.tenants.auth0.com

Adresse intermédiaire.

relying_party_identifier

string<hostname>

ID de la partie de confiance (rpId) à utiliser pour les passkeys sur ce domaine personnalisé. S’il n’est pas fourni, le domaine complet sera utilisé.

tls_policy

string

défaut:recommended

La politique de version de TLS

verification

object

Paramètres de vérification du domaine.

Show child attributes