Obtenir une connexion par ID

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.Connections.GetAsync(
            id: "id",
            request: new GetConnectionRequestParameters {
                Fields = "fields",
                IncludeFields = true
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    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
    }
    request := &management.GetConnectionRequestParameters{
        Fields: management.String(
            "fields",
        ),
        IncludeFields: management.Bool(
            true,
        ),
    }
    mgmt.Connections.Get(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

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

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

        client.connections().get(
            "id",
            GetConnectionRequestParameters
                .builder()
                .fields("fields")
                .includeFields(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Connections\Requests\GetConnectionRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->connections->get(
    'id',
    new GetConnectionRequestParameters([
        'fields' => 'fields',
        'includeFields' => true,
    ]),
);

from auth0.management import ManagementClient

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

client.connections.get(
    id="id",
    fields="fields",
    include_fields=True,
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.get("id", {
        fields: "fields",
        includeFields: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.get("id", {
        fields: "fields",
        includeFields: true,
    });
}
main();

{
  "authentication": {
    "active": true
  },
  "connected_accounts": {
    "active": true,
    "allow_missing_user_id": true,
    "cross_app_access": true
  },
  "cross_app_access_requesting_app": {
    "active": true
  },
  "cross_app_access_resource_app": {},
  "display_name": "<string>",
  "enabled_clients": [
    "<string>"
  ],
  "id": "con_0000000000000001",
  "is_domain_connection": true,
  "metadata": {},
  "name": "My connection",
  "options": {},
  "realms": [
    "<string>"
  ],
  "show_as_button": true,
  "strategy": "auth0"
}

GET

https://{tenantDomain}/api/v2

connections

{id}

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.Connections.GetAsync(
            id: "id",
            request: new GetConnectionRequestParameters {
                Fields = "fields",
                IncludeFields = true
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    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
    }
    request := &management.GetConnectionRequestParameters{
        Fields: management.String(
            "fields",
        ),
        IncludeFields: management.Bool(
            true,
        ),
    }
    mgmt.Connections.Get(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

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

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

        client.connections().get(
            "id",
            GetConnectionRequestParameters
                .builder()
                .fields("fields")
                .includeFields(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Connections\Requests\GetConnectionRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->connections->get(
    'id',
    new GetConnectionRequestParameters([
        'fields' => 'fields',
        'includeFields' => true,
    ]),
);

from auth0.management import ManagementClient

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

client.connections.get(
    id="id",
    fields="fields",
    include_fields=True,
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.get("id", {
        fields: "fields",
        includeFields: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.get("id", {
        fields: "fields",
        includeFields: true,
    });
}
main();

{
  "authentication": {
    "active": true
  },
  "connected_accounts": {
    "active": true,
    "allow_missing_user_id": true,
    "cross_app_access": true
  },
  "cross_app_access_requesting_app": {
    "active": true
  },
  "cross_app_access_resource_app": {},
  "display_name": "<string>",
  "enabled_clients": [
    "<string>"
  ],
  "id": "con_0000000000000001",
  "is_domain_connection": true,
  "metadata": {},
  "name": "My connection",
  "options": {},
  "realms": [
    "<string>"
  ],
  "show_as_button": true,
  "strategy": "auth0"
}

Autorisations

Authorization

string

header

requis

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

Paramètres de chemin

string

requis

L’ID de la connexion à récupérer

Paramètres de requête

fields

string

Une liste de champs séparés par des virgules à inclure dans le résultat ou à en exclure (selon include_fields); laissez vide pour récupérer tous les champs

include_fields

boolean

true si les champs indiqués doivent être inclus dans le résultat, false sinon (la valeur par défaut est true)

Réponse

La connexion a été récupérée.

authentication

object

Configure l’objectif d’une connexion à utiliser pour l’authentification pendant la connexion.

Show child attributes

connected_accounts

object

Configurer l’usage d’une connexion pour les comptes connectés et Token Vault.

Show child attributes

cross_app_access_requesting_app

object

Configurez la connexion à utiliser comme application demandeuse pour Cross App Access.

Show child attributes

cross_app_access_resource_app

object

Paramètres de l’application de ressources Cross App Access qui s’appliquent à cette connexion.

Show child attributes

display_name

string

Nom de la connexion utilisé dans l’écran de connexion

enabled_clients

string[]

deprecated

Propriété DEPRECATED. Utilisez le endpoint GET /connections/:id/clients pour obtenir les ID des clients pour lesquels la connexion est activée

L’ID du client

string

défaut:con_0000000000000001

L’identifiant de la connexion

is_domain_connection

boolean

True si la connexion est au domain level

metadata

object

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

Show child attributes

name

string

défaut:My connection

Le nom de la connexion

options

object

Pour renvoyer les options dans la réponse, le scope read:connections_options doit être présent

realms

string<connection-realm>[]

Définit les realms pour lesquels la connexion sera utilisée (c.-à-d. : les domaines de courriel). Si le tableau est vide ou si la propriété n’est pas précisée, le nom de la connexion sera ajouté comme realm.

Le realm auquel appartient cette connexion

show_as_button

boolean

Permet d’afficher un bouton pour la connexion dans la login page (nouvelle expérience seulement). Si false, elle sera utilisable uniquement par HRD.

strategy

string

défaut:auth0

Le type de connexion, lié à l’identity provider