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.DeviceCredentials.CreatePublicKeyAsync(
            new CreatePublicKeyDeviceCredentialRequestContent {
                DeviceName = "device_name",
                Type = DeviceCredentialPublicKeyTypeEnum.PublicKey,
                Value = "value",
                DeviceId = "device_id"
            }
        );
    }

}

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.CreatePublicKeyDeviceCredentialRequestContent{
        DeviceName: "device_name",
        Type: management.DeviceCredentialPublicKeyTypeEnum(
            "public_key",
        ),
        Value: "value",
        DeviceId: "device_id",
    }
    mgmt.DeviceCredentials.CreatePublicKey(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreatePublicKeyDeviceCredentialRequestContent;
import com.auth0.client.mgmt.types.DeviceCredentialPublicKeyTypeEnum;

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

        client.deviceCredentials().createPublicKey(
            CreatePublicKeyDeviceCredentialRequestContent
                .builder()
                .deviceName("device_name")
                .type(DeviceCredentialPublicKeyTypeEnum.PUBLIC_KEY)
                .value("value")
                .deviceId("device_id")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\DeviceCredentials\Requests\CreatePublicKeyDeviceCredentialRequestContent;
use Auth0\SDK\API\Management\Types\DeviceCredentialPublicKeyTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->deviceCredentials->createPublicKey(
    new CreatePublicKeyDeviceCredentialRequestContent([
        'deviceName' => 'device_name',
        'type' => DeviceCredentialPublicKeyTypeEnum::PublicKey->value,
        'value' => 'value',
        'deviceId' => 'device_id',
    ]),
);

from auth0.management import ManagementClient

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

client.device_credentials.create_public_key(
    device_name="device_name",
    type="public_key",
    value="value",
    device_id="device_id",
)

require "auth0"

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

client.device_credentials.create_public_key(
  device_name: "device_name",
  type: "public_key",
  value: "value",
  device_id: "device_id"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/device-credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "device_id": "<string>",
  "device_name": "<string>",
  "type": "public_key",
  "value": "<string>",
  "client_id": "<string>"
}
'

{
  "id": "dcr_0000000000000001"
}

Informations d’identification de l’appareil par POST

Créer une clé publique d’identifiant d’appareil pour gérer la rotation des jetons d’actualisation pour un user_id donné. Les API Device Credentials sont conçues uniquement pour un usage administratif ponctuel, et la pagination est activée par défaut pour les requêtes GET.

Lorsque la rotation des jetons d’actualisation est activée, le endpoint devient cohérent. Pour en savoir plus, consultez Signing Keys.

POST

https://{tenantDomain}/api/v2

device-credentials

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.DeviceCredentials.CreatePublicKeyAsync(
            new CreatePublicKeyDeviceCredentialRequestContent {
                DeviceName = "device_name",
                Type = DeviceCredentialPublicKeyTypeEnum.PublicKey,
                Value = "value",
                DeviceId = "device_id"
            }
        );
    }

}

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.CreatePublicKeyDeviceCredentialRequestContent{
        DeviceName: "device_name",
        Type: management.DeviceCredentialPublicKeyTypeEnum(
            "public_key",
        ),
        Value: "value",
        DeviceId: "device_id",
    }
    mgmt.DeviceCredentials.CreatePublicKey(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreatePublicKeyDeviceCredentialRequestContent;
import com.auth0.client.mgmt.types.DeviceCredentialPublicKeyTypeEnum;

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

        client.deviceCredentials().createPublicKey(
            CreatePublicKeyDeviceCredentialRequestContent
                .builder()
                .deviceName("device_name")
                .type(DeviceCredentialPublicKeyTypeEnum.PUBLIC_KEY)
                .value("value")
                .deviceId("device_id")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\DeviceCredentials\Requests\CreatePublicKeyDeviceCredentialRequestContent;
use Auth0\SDK\API\Management\Types\DeviceCredentialPublicKeyTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->deviceCredentials->createPublicKey(
    new CreatePublicKeyDeviceCredentialRequestContent([
        'deviceName' => 'device_name',
        'type' => DeviceCredentialPublicKeyTypeEnum::PublicKey->value,
        'value' => 'value',
        'deviceId' => 'device_id',
    ]),
);

from auth0.management import ManagementClient

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

client.device_credentials.create_public_key(
    device_name="device_name",
    type="public_key",
    value="value",
    device_id="device_id",
)

require "auth0"

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

client.device_credentials.create_public_key(
  device_name: "device_name",
  type: "public_key",
  value: "value",
  device_id: "device_id"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/device-credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "device_id": "<string>",
  "device_name": "<string>",
  "type": "public_key",
  "value": "<string>",
  "client_id": "<string>"
}
'

{
  "id": "dcr_0000000000000001"
}

Autorisations

Authorization

string

header

requis

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

Corps

device_id

string

requis

Identifiant unique de l’appareil. Il est recommandé d’utiliser Android_ID sur Android et identifierForVendor.

Maximum string length: 36

Pattern: ^[-A-Fa-f0-9]+$

device_name

string

requis

Nom de cet appareil facilement reconnaissable par son propriétaire.

Minimum string length: 1

type

enum<string>

requis

Type d’information d’identification. Doit être public_key.

Options disponibles:

public_key

value

string

requis

Chaîne encodée en Base64 contenant l’information d’authentification.

Minimum string length: 1

client_id

string<client-id>

client_id du client (application) auquel cette information d’authentification est destinée.

Réponse

Identifiants d’appareil créés avec succès.

string

défaut:dcr_0000000000000001

requis

L’identifiant de l’information d’authentification