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

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.Users.Identities.LinkAsync(
            id: "id",
            request: new LinkUserIdentityRequestContent()
        );
    }

}

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.LinkUserIdentityRequestContent{}
    mgmt.Users.Identities.Link(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.users.types.LinkUserIdentityRequestContent;

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

        client.users().identities().link(
            "id",
            LinkUserIdentityRequestContent
                .builder()
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Users\Identities\Requests\LinkUserIdentityRequestContent;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->users->identities->link(
    'id',
    new LinkUserIdentityRequestContent([]),
);

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.users.identities.link("id", {});
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.users.identities.link("id", {});
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/users/{id}/identities \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "connection_id": "<string>",
  "link_with": "{SECONDARY_ACCOUNT_JWT}",
  "user_id": "abc"
}
'

[
  {
    "connection": "twitter",
    "provider": "twitter",
    "user_id": "abc",
    "access_token": "<string>",
    "access_token_secret": "<string>",
    "isSocial": true,
    "profileData": {
      "email": "<string>",
      "email_verified": true,
      "family_name": "<string>",
      "given_name": "<string>",
      "name": "<string>",
      "phone_number": "<string>",
      "phone_verified": true,
      "username": "johndoe"
    },
    "refresh_token": "<string>"
  }
]

Identités Post

deprecated

Lier deux comptes d’utilisateur pour établir une relation entre un compte principal et un compte secondaire. Si la liaison réussit, le point de terminaison renvoie le nouveau tableau des identités du compte principal.

Remarque : il existe deux façons d’appeler le point de terminaison :

Avec le JWT du compte principal authentifié dans l’en-tête Authorization, qui possède le scope update:current_user_identities :
```
POST /api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities
Authorization: "Bearer PRIMARY_ACCOUNT_JWT"
{
  "link_with": "SECONDARY_ACCOUNT_JWT"
}
```
Dans ce cas, seul le paramètre link_with est requis dans le corps, qui contient également le JWT obtenu lors de l’authentification du compte secondaire.
Avec un jeton généré par l’API V2 contenant le scope update:users :
```
POST /api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities
Authorization: "Bearer YOUR_API_V2_TOKEN"
{
  "provider": "SECONDARY_ACCOUNT_PROVIDER",
  "connection_id": "SECONDARY_ACCOUNT_CONNECTION_ID(OPTIONAL)",
  "user_id": "SECONDARY_ACCOUNT_USER_ID"
}
```
Dans ce cas, vous devez envoyer provider et user_id dans le corps. Vous pouvez aussi envoyer le paramètre connection_id, qui permet d’identifier une connexion de base de données particulière pour le fournisseur « auth0 ».

POST

https://{tenantDomain}/api/v2

users

{id}

identities

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

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.Users.Identities.LinkAsync(
            id: "id",
            request: new LinkUserIdentityRequestContent()
        );
    }

}

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.LinkUserIdentityRequestContent{}
    mgmt.Users.Identities.Link(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.users.types.LinkUserIdentityRequestContent;

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

        client.users().identities().link(
            "id",
            LinkUserIdentityRequestContent
                .builder()
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Users\Identities\Requests\LinkUserIdentityRequestContent;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->users->identities->link(
    'id',
    new LinkUserIdentityRequestContent([]),
);

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.users.identities.link("id", {});
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.users.identities.link("id", {});
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/users/{id}/identities \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "connection_id": "<string>",
  "link_with": "{SECONDARY_ACCOUNT_JWT}",
  "user_id": "abc"
}
'

[
  {
    "connection": "twitter",
    "provider": "twitter",
    "user_id": "abc",
    "access_token": "<string>",
    "access_token_secret": "<string>",
    "isSocial": true,
    "profileData": {
      "email": "<string>",
      "email_verified": true,
      "family_name": "<string>",
      "given_name": "<string>",
      "name": "<string>",
      "phone_number": "<string>",
      "phone_verified": true,
      "username": "johndoe"
    },
    "refresh_token": "<string>"
  }
]

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

ID du compte d’utilisateur principal auquel lier un second compte d’utilisateur.

Corps

connection_id

string

connection_id du compte d’utilisateur secondaire en cours de liaison lorsqu’il existe plus d’un fournisseur de base de données auth0.

Pattern: ^con_[A-Za-z0-9]{16}$

link_with

string

défaut:{SECONDARY_ACCOUNT_JWT}

JWT du compte secondaire en cours de liaison. Si ce paramètre est envoyé, provider, user_id et connection_id ne doivent pas être envoyés.

provider

enum<string>

Fournisseur d’identité du compte d’utilisateur secondaire en cours de liaison.

Options disponibles:

ad,

adfs,

amazon,

apple,

dropbox,

bitbucket,

auth0-oidc,

auth0,

baidu,

bitly,

box,

custom,

daccount,

dwolla,

email,

evernote-sandbox,

evernote,

exact,

facebook,

fitbit,

github,

google-apps,

google-oauth2,

instagram,

ip,

line,

linkedin,

oauth1,

oauth2,

office365,

oidc,

okta,

paypal,

paypal-sandbox,

pingfederate,

planningcenter,

salesforce-community,

salesforce-sandbox,

salesforce,

samlp,

sharepoint,

shopify,

shop,

sms,

soundcloud,

thirtysevensignals,

twitter,

untappd,

vkontakte,

waad,

weibo,

windowslive,

wordpress,

yahoo,

yandex

user_id

défaut:abc

user_id du compte d’utilisateur secondaire à associer.

Minimum string length: 1

Réponse

Identité ajoutée avec succès.

connection

string

défaut:twitter

requis

Nom de la connexion de cette identité.

provider

string

défaut:twitter

requis

Type de fournisseur d’identité.

user_id

défaut:abc

requis

user_id de cette identité.

Minimum string length: 1

access_token

string

Jeton d’accès IdP renvoyé si le scope read:user_idp_tokens est défini.

access_token_secret

string

Secret du jeton d’accès IdP renvoyé uniquement si scope read:user_idp_tokens est défini.

Indique si le fournisseur d’identité est un fournisseur social (true) ou non (false).

profileData

object

Show child attributes

refresh_token

string

Jeton d’actualisation IdP renvoyé uniquement si le scope read:user_idp_tokens est défini.