> ## Documentation Index
> Fetch the complete documentation index at: https://generaltranslation.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Cómo conectarse a endpoints usando el flujo de código de autorización OAuth 2.0 con PKCE

<div id="how-to-connect-to-endpoints-using-oauth-20-authorization-code-flow-with-pkce">
  ### Cómo conectarse a los puntos de conexión mediante el flujo de código de autorización de OAuth 2.0 con PKCE
</div>

<div id="how-to-connect-to-the-endpoints">
  #### Cómo conectar con los endpoints
</div>

Para autenticar a tus usuarios, tu App deberá implementar un flujo de autorización. Este flujo de autorización te permite dirigir a tus usuarios a un cuadro de diálogo de autorización en X. A partir de ahí, la experiencia principal de X mostrará el cuadro de diálogo de autorización y gestionará la autorización en nombre de tu App. Tus usuarios podrán autorizar tu App o rechazar el permiso. Después de que el usuario tome su decisión, X redirigirá al usuario a tu App, donde podrás intercambiar el código de autorización por un token de acceso (si el usuario autorizó tu App) o gestionar un rechazo (si el usuario no autorizó tu App).

<div id="working-with-confidential-clients">
  #### Trabajar con clientes confidenciales
</div>

Si estás trabajando con clientes confidenciales, deberás usar un esquema de [autenticación básica](https://datatracker.ietf.org/doc/html/rfc2617#section-2) para generar un encabezado de autorización con codificación base64 al realizar solicitudes a los endpoints de token.

Los parámetros `userid` y `password` se separan con un solo carácter de dos puntos (":") dentro de una cadena codificada en base64 en las credenciales.

Un ejemplo se vería así:

`-header 'Authorization: Basic V1ROclFTMTRiVWhwTWw4M2FVNWFkVGQyTldNNk1UcGphUTotUm9LeDN4NThKQThTbTlKSXQyZm1BanEzcTVHWC1icVozdmpKeFNlR3NkbUd0WEViUA=='`

Si el agente de usuario desea enviar el Client ID "Aladdin" y la contraseña "open sesame", usaría el siguiente campo de encabezado:

`Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==`

Para crear el encabezado de autorización básica, deberás aplicar codificación base64 a tu Client ID y a tu Client Secret, los cuales se pueden obtener en la página “Keys and Tokens” de tu App dentro de la [Consola de desarrollador.](https://developer.x.com/en/portal/dashboard)

<div id="steps-to-connect-using-oauth-20">
  #### Pasos para conectarse usando OAuth 2.0
</div>

**Paso 1: Construir una URL de autorización**

Tu App deberá construir una URL de autorización para X, indicando los scopes que tu App necesita autorizar. Por ejemplo, si tu App necesita consultar Tweets, usuarios y administrar seguimientos, debe solicitar los siguientes scopes:

`tweet.read%20users.read%20follows.read%20follows.write`

La URL también contendrá los parámetros `code_challenge` y `state`, además de los otros parámetros obligatorios. En producción debes usar una cadena aleatoria para el `code_challenge`.

**Paso 2: GET oauth2/authorize**

Haz que el usuario se autentique y envíe a la aplicación un código de autorización. Si has habilitado OAuth 2.0 para tu App, puedes encontrar tu Client ID en la página “Keys and Tokens” de tu App.

Un ejemplo de URL a la que redirigir al usuario se vería así:

```
https://x.com/i/oauth2/authorize?response_type=code&client_id=M1M5R3BMVy13QmpScXkzTUt5OE46MTpjaQ&redirect_uri=https://www.example.com&scope=tweet.read%20users.read%20follows.read%20follows.write&state=state&code_challenge=challenge&code_challenge_method=plain
```

Un ejemplo de URL con offline\_access tendría este aspecto:

```
https://x.com/i/oauth2/authorize?response_type=code&client_id=M1M5R3BMVy13QmpScXkzTUt5OE46MTpjaQ&redirect_uri=https://www.example.com&scope=tweet.read%20users.read%20follows.read%20offline.access&state=state&code_challenge=challenge&code_challenge_method=plain
```

Tras una autenticación correcta, en el redirect\_uri recibirás una solicitud que contiene el parámetro auth\_code. Tu aplicación debe verificar el parámetro state.

Un ejemplo de solicitud procedente de la redirección del cliente sería:

```
https://www.example.com/?state=state&code=VGNibzFWSWREZm01bjN1N3dicWlNUG1oa2xRRVNNdmVHelJGY2hPWGxNd2dxOjE2MjIxNjA4MjU4MjU6MToxOmFjOjE
```

**Paso 3: POST oauth2/token - Token de acceso**

Ahora puedes usar el código de autorización para crear un token de acceso y un token de actualización (solo si se solicita el scope `offline.access`). Puedes realizar una solicitud POST al siguiente endpoint:

```
https://api.x.com/2/oauth2/token
```

Deberás incluir el `Content-Type` de `application/x-www-form-urlencoded` en la cabecera. Además, tu solicitud debe incluir lo siguiente: `code`, `grant_type`, `client_id` y `redirect_uri`, y el `code_verifier`.

A continuación se muestra un ejemplo de solicitud de token para un cliente público:

```json theme={null}
curl --location --request POST 'https://api.x.com/2/oauth2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'code=VGNibzFWSWREZm01bjN1N3dicWlNUG1oa2xRRVNNdmVHelJGY2hPWGxNd2dxOjE2MjIxNjA4MjU4MjU6MToxOmFjOjE' \
--data-urlencode 'grant_type=authorization_code' \
--data-urlencode 'client_id=rG9n6402A3dbUJKzXTNX4oWHJ' \
--data-urlencode 'redirect_uri=https://www.example.com' \
--data-urlencode 'code_verifier=challenge'
```

Aquí se muestra un ejemplo con un cliente confidencial:

```json theme={null}
curl --location --request POST 'https://api.x.com/2/oauth2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic V1ROclFTMTRiVWhwTWw4M2FVNWFkVGQyTldNNk1UcGphUTotUm9LeDN4NThKQThTbTlKSXQyZm1BanEzcTVHWC1icVozdmpKeFNlR3NkbUd0WEViUA=='\
--data-urlencode 'code=VGNibzFWSWREZm01bjN1N3dicWlNUG1oa2xRRVNNdmVHelJGY2hPWGxNd2dxOjE2MjIxNjA4MjU4MjU6MToxOmFjOjE' \
--data-urlencode 'grant_type=authorization_code' \
--data-urlencode 'redirect_uri=https://www.example.com' \
--data-urlencode 'code_verifier=challenge'
```

**Paso 4: Conéctate a las APIs**

Ahora ya puedes conectarte a los endpoints usando OAuth 2.0. Para hacerlo, realizarás solicitudes a la API de la misma manera que lo harías usando la [autenticación con Bearer Token](/es/resources/fundamentals/authentication/oauth-2-0/application-only). En lugar de enviar tu Bearer Token, deberás usar el token de acceso que generaste en el último paso. Como respuesta, deberías ver el payload adecuado correspondiente al endpoint al que estás llamando. Esta solicitud es la misma tanto para clientes públicos como confidenciales. 

Un ejemplo de la solicitud que harías sería el siguiente:

```json theme={null}
curl --location --request GET 'https://api.x.com/2/tweets?ids=1261326399320715264,1278347468690915330' \
--header 'Authorization: Bearer Q0Mzb0VhZ0V5dmNXSTEyNER2MFNfVW50RzdXdTN6STFxQlVkTGhTc1lCdlBiOjE2MjIxNDc3NDM5MTQ6MToxOmF0OjE'
```

**Paso 5: POST oauth2/token - refresh token**

Un refresh token permite que una aplicación obtenga un nuevo access token sin volver a solicitar la autorización del usuario. Puedes crear un refresh token haciendo una solicitud POST al siguiente endpoint: [https://api.x.com/2/oauth2/token](https://api.x.com/2/oauth2/token). Deberás añadir el `Content-Type` de `application/x-www-form-urlencoded` mediante un encabezado HTTP. Además, también tendrás que enviar tu `refresh_token`, establecer tu `grant_type` como `refresh_token` y definir tu `client_id`.

Esta solicitud funcionará para clientes públicos:

```json theme={null}
POST 'https://api.x.com/2/oauth2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'refresh_token=bWRWa3gzdnk3WHRGU1o0bmRRcTJ5VUxWX1lZTDdJSUtmaWcxbTVxdEFXcW5tOjE2MjIxNDc3NDM5MTQ6MToxOnJ0OjE' \
--data-urlencode 'grant_type=refresh_token' \
--data-urlencode 'client_id=rG9n6402A3dbUJKzXTNX4oWHJ'
```

Este es un ejemplo de uno para clientes confidenciales:

```json theme={null}
POST 'https://api.x.com/2/oauth2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic V1ROclFTMTRiVWhwTWw4M2FVNWFkVGQyTldNNk1UcGphUTotUm9LeDN4NThKQThTbTlKSXQyZm1BanEzcTVHWC1icVozdmpKeFNlR3NkbUd0WEViUA=='\
--data-urlencode 'refresh_token=bWRWa3gzdnk3WHRGU1o0bmRRcTJ5VUxWX1lZTDdJSUtmaWcxbTVxdEFXcW5tOjE2MjIxNDc3NDM5MTQ6MToxOnJ0OjE'\
--data-urlencode 'grant_type=refresh_token'
```

**Paso 6: POST oauth2/revoke - Revocar el token**

Un token de revocación invalida un token de acceso o un token de actualización. Esto se utiliza para habilitar una función de «cierre de sesión» en los clientes, lo que te permite eliminar cualquier credencial de seguridad asociada con el flujo de autorización que ya no sea necesaria. El token de revocación es para que una App revoque un token y no para que lo haga un usuario. Puedes crear una solicitud de token de revocación realizando una solicitud POST a la siguiente URL si la App quiere revocar de forma programática el acceso que se le otorgó:

```
https://api.x.com/2/oauth2/revoke
```

Debes enviar el `Content-Type` de `application/x-www-form-urlencoded` a través de un encabezado, junto con tu token y tu client\_id.

En algunos casos, un usuario puede querer revocar el acceso que le otorgó a una App; puede hacerlo visitando la [página de Apps conectadas](https://x.com/settings/connected_apps).

```bash theme={null}
curl --location --request POST 'https://api.x.com/2/oauth2/revoke' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'token=Q0Mzb0VhZ0V5dmNXSTEyNER2MFNfVW50RzdXdTN6STFxQlVkTGhTc1lCdlBiOjE2MjIxNDc3NDM5MTQ6MToxOmF0OjE' \
--data-urlencode 'client_id=rG9n6402A3dbUJKzXTNX4oWHJ'
```

Esta solicitud funcionará para clientes confidenciales:

```bash theme={null}
curl --location --request POST 'https://api.x.com/2/oauth2/revoke' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic V1ROclFTMTRiVWhwTWw4M2FVNWFkVGQyTldNNk1UcGphUTotUm9LeDN4NThKQThTbTlKSXQyZm1BanEzcTVHWC1icVozdmpKeFNlR3NkbUd0WEViUA=='\
--data-urlencode 'token=Q0Mzb0VhZ0V5dmNXSTEyNER2MFNfVW50RzdXdTN6STFxQlVkTGhTc1lCdlBiOjE2MjIxNDc3NDM5MTQ6MToxOmF0OjE'
```