> For the complete documentation index, see [llms.txt](https://docs.payments.thalescloud.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.payments.thalescloud.io/secure-card-display/es/integrate-d1-api/get-oauth2.0-access-token.md).

# Obtener token de acceso OAuth 2.0

Las API de D1 usan el flujo bearer JWT de OAuth 2.0 ([RFC 7523](https://datatracker.ietf.org/doc/html/rfc7523)).

Tu **backend del emisor** firma un JSON Web Token (JWT) y lo intercambia por un token de acceso de D1.

Usa el token de acceso de D1 para llamar a las API de D1.

<figure><img src="/spaces/62lLFDcmLCeqqwmy4Fee/files/G3vNReECvDpjaD6K8JIv" alt=""><figcaption><p>Flujo bearer JWT de OAuth 2.0 entre el backend del emisor y el backend de D1.</p></figcaption></figure>

Consulta los campos de solicitud y respuesta en la referencia de la API: [Obtener token de autorización](/secure-card-display/es/integrate-d1-api/d1-api-reference/inbound-api-to-d1/oauth2-api.md#post-oauth2-token).

### Usa el token de acceso de D1

Todas las API del backend del emisor al backend de D1 requieren un token de acceso de D1.

Envíalo en el `Authorization` encabezado usando el `Bearer` esquema:

`Authorization: Bearer <Base64_Encoded_JWT>`

El token de acceso de D1 es válido durante 15 minutos.

Reutiliza el token hasta que expire.

No llames a `/oauth2/token` antes de cada llamada a la API de D1.

### Aserción JWT

El `/oauth2/token` La API espera una aserción JWT ([RFC 7519](https://datatracker.ietf.org/doc/html/rfc7519)).

Tu backend del emisor debe generar un JWT válido y firmarlo.

Puedes:

* Generar JWT mediante un proveedor de identidades (por ejemplo, Keycloak).
* Generar JWT en tu backend del emisor.

En ambos casos, aprovisiona la clave pública usada para la verificación de la firma en el backend de D1.

Si no usas un proveedor de identidades, genera el par de claves y los JWT como se describe a continuación.

#### Algoritmos compatibles

Solo se admiten JWT firmados con `ES256` son compatibles ([RFC 7518](https://datatracker.ietf.org/doc/html/rfc7518)).

D1 usa criptografía asimétrica.

El backend de D1 solo almacena claves públicas.

#### Formato JWT

Un JWT consta de tres partes separadas por puntos (`.`):

* Encabezado
* Carga útil
* Firma

Ejemplo: `hhhhhhh.pppppppp.ssssssssss`

#### Encabezado

El encabezado contiene el algoritmo y el tipo de token.

`kid` es obligatorio.

El backend de D1 lo usa para seleccionar la clave pública correcta.

Ejemplo de encabezado:

```json
{
  "alg": "ES256",
  "typ": "JWT",
  "kid": "your_tenant_key_id"
}
```

#### Carga útil

La carga útil admite las siguientes claims:

| Claim | Tipo   | Obligatorio | Descripción                                                                                                                                                                             |
| ----- | ------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `iss` | cadena | Sí          | Usa el issuerId proporcionado durante la incorporación a D1. D1 lo usa para buscar la clave pública aprovisionada. Si usas un modelo de agregador, establece esto como el aggregatorId. |
| `sub` | cadena | Sí          | Usa el issuerId. (En caso de agregador, este valor es igual al aggregatorId.)                                                                                                           |
| `exp` | entero | Sí          | Tiempo de expiración en segundos de época UTC. El valor máximo es la hora actual + 15 minutos.                                                                                          |
| `aud` | cadena | No          | URL base del servidor de autorización de D1. Usa la URL para tu entorno de destino: Sandbox = `https://api.d1-stg.thalescloud.io`, Production = `https://api.d1.thalescloud.io`.        |

{% hint style="info" %}
D1 aplica el período máximo de expiración. Si `exp` supera la ventana permitida, D1 rechaza la solicitud.
{% endhint %}

Ejemplo de carga útil:

```json
{
  "iss": "your_issuer_id",
  "sub": "your_user_for_audit",
  "exp": 1545222654,
  "aud": "https://api.d1.thalescloud.io"
}
```

#### Firma

La firma se calcula sobre el encabezado y la carga útil codificados en Base64URL.

Las tres partes del JWT se unen usando puntos (`.`).

### Genera el par de claves

Usa OpenSSL para generar un par de claves P-256:

Genera una clave privada para el backend del emisor.

Protégela en tu entorno.

```bash
openssl ecparam -name prime256v1 -genkey -noout -out issuerId-jwt-priv-key.pem
```

Genera una clave pública para aprovisionar en el backend de D1:

```bash
openssl ec -in issuerId-jwt-priv-key.pem -pubout > issuerId-jwt-pub-key.pem
```

El backend del emisor usa la clave privada para firmar JWT.

El backend de D1 usa la clave pública (y su `kid`) para verificar las firmas JWT.

Comparte la clave pública y `kid` con el equipo de entrega de Thales durante la incorporación a D1.

### Genera el JWT

Hay muchas maneras de generar JWT.

Este ejemplo usa la `jose` biblioteca de Node.js:

```js
/*
Instala la biblioteca *jose* en tu proyecto.
https://www.npmjs.com/package/jose

Para este ejemplo usamos 3.19.0
*/
const { SignJWT } = require("jose/jwt/sign");
const { createPrivateKey } = require("crypto");

const alg = "ES256";
const kid = "your_tenant_key_id";
const iss = "your_issuer_id";
const aud = "your_audience";
const expirationTime = "3mins";
const sub = "our_user_for_audit";

const privateKeyPem = `-----BEGIN EC PRIVATE KEY----- 
MHcCAQEEILlIXMnH1if8EuWykPmWw/LyXZuoNVCzMp3Yhbj9/sEUoAoGCCqGSM49 
AwEHoUQDQgAE6swczLIRn/lPxQPpdUb2pHjCr0YeC02lkG7vMmqCNpalwIQSl+TR 
fZVDwCKJmajRgK3+n5SyAgCp4oH8qNluwQ==
-----END EC PRIVATE KEY-----`;

async function generateJwt() {
  const privateKey = createPrivateKey(privateKeyPem);

  console.log(
    await new SignJWT({})
      .setProtectedHeader({ alg, kid })
      .setIssuedAt()
      .setIssuer(iss)
      .setAudience(aud)
      .setExpirationTime(expirationTime)
      .setSubject(sub)
      .sign(privateKey)
  );
}

(async () => {
  await generateJwt();
})();
```

Ejemplo de salida de JWT:

```shellscript
eyJhbGciOiJFUzI1NiIsImtpZCI6InlvdXJfdGVuYW50X2tleV9pZCJ9.eyJpYXQiOjE2MzYwMzMxODYsImlzcyI6InlvdXJfaXNzdWVyX2lkIiwiYXVkIjoieW91cl9hdWRpZW5jZSIsImV4cCI6MTYzNjAzMzM2Niwic3ViIjoib3VyX3VzZXJfZm9yX2F1ZGl0In0.lgVzN8k9IGcv1s-FZACpEyVxXcS9LAh4ahY3DO5Fg6MRl-Twa_wVAfw_Oe0XiH1Am-RFfafgDrepNi3Jz05Gvg
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.payments.thalescloud.io/secure-card-display/es/integrate-d1-api/get-oauth2.0-access-token.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
