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

# Configuración de X (Twitter) para Embedded Wallet

> Aprenda cómo configurar OAuth de X (Twitter) para su instancia de Embedded Wallet. Esta guía cubre el uso del proxy de Sequence para OAuth 2.0 de X y los permisos necesarios.

Para integrar la autenticación de X (antes Twitter) en su Embedded Wallet, deberá configurar su aplicación para usar OAuth 2.0 de X.

## Agregue su Client ID en Sequence Builder

Primero, debe crear una aplicación en el X Developer Portal para obtener un Client ID y un Client Secret.

Después de crear su aplicación, debe agregar el Client ID a la configuración de su proyecto en Sequence Builder.

1. Vaya a su proyecto en [Sequence Builder](https://sequence.build).
2. Navegue a la configuración de **Embedded Wallet**.
3. En la sección de proveedores de autenticación, busque **X (Twitter)** y pegue su **Client ID** en el campo correspondiente.

Este paso es crucial para que Sequence pueda verificar las solicitudes de autenticación que provienen de su aplicación.

## Autenticación con el SDK

Una vez que tenga un access token de X, puede pasarlo al Sequence WaaS SDK para iniciar sesión al usuario. Esto es diferente a otros proveedores OIDC como Google o Epic Games, donde se utiliza un `idToken`. Para X, debe usar el parámetro `xAccessToken`.

```typescript
await sequence.signIn({ 
  xAccessToken: 'YOUR_X_ACCESS_TOKEN' 
});
```

Para más detalles sobre cómo implementar el flujo de inicio de sesión en su aplicación, consulte la [documentación de autenticación](/sdk/headless-wallet/authentication).

## Obtener un Access Token de X

Para obtener un access token, debe implementar el flujo OAuth 2.0 PKCE. Debido a problemas con la implementación OAuth 2.0 de X, Sequence ofrece un servicio proxy personalizado para garantizar un flujo de autenticación fluido y confiable.

### Uso del Sequence X Auth Proxy

En lugar de enviar solicitudes directamente a `api.x.com`, utilizará la URL del proxy de Sequence que facilita el flujo OAuth 2.0.

Al realizar el intercambio de tokens en su flujo OAuth 2.0 PKCE, debe apuntar a la siguiente URL:

```
https://xproxy.sequence.xyz/api.x.com/2/oauth2/token
```

### Ejemplo de implementación

Aquí tiene un ejemplo mínimo de cómo implementar el flujo de autenticación de X usando el proxy de Sequence.

<CodeGroup>
  ```typescript Step 1: Redirect to X
  // This function constructs the authorization URL and redirects the user.
  function redirectToXAuth() {
    const params = new URLSearchParams({
      response_type: 'code',
      client_id: 'YOUR_X_CLIENT_ID', // Replace with your X Client ID
      redirect_uri: 'YOUR_REDIRECT_URI', // Your callback URL
      scope: 'users.read email.read tweet.read', // Required scopes
      state: 'state', // A random string for security
      code_challenge: 'challenge', // A PKCE code challenge
      code_challenge_method: 'plain', // Use 'S256' in production
    });

    window.location.assign(`https://x.com/i/oauth2/authorize?${params.toString()}`);
  }
  ```

  ```typescript Step 2: Handle Callback & Get Access Token
  // On your callback page, handle the redirect from X and get the access token.
  async function handleXCallback() {
    const params = new URLSearchParams(window.location.search);
    const code = params.get('code');

    if (code) {
      try {
        // Exchange the authorization code for an access token.
        // Instead of calling X directly, we use the Sequence proxy.
        const tokenUrl = 'https://xproxy.sequence.xyz/api.x.com/2/oauth2/token';
        
        const tokenResponse = await fetch(tokenUrl, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
          },
          body: new URLSearchParams({
            code,
            grant_type: 'authorization_code',
            client_id: 'YOUR_X_CLIENT_ID', // Replace with your X Client ID
            redirect_uri: 'YOUR_REDIRECT_URI', // Must match the one in Step 1
            code_verifier: 'challenge', // The PKCE code verifier
          }),
        });

        const { access_token } = await tokenResponse.json();

        if (!access_token) {
          throw new Error('Failed to obtain access token');
        }

        // Now you have the access token. You can pass it to the signIn method.
        console.log('Access Token:', access_token);
        return access_token;

      } catch (error) {
        console.error('X sign-in failed:', error);
      }
    }
  }

  // Call this function when your callback page loads
  handleXCallback();
  ```
</CodeGroup>

<Note>
  Para aplicaciones en producción, debe usar el `S256` como `code_challenge_method` para PKCE, que es más seguro. Esto requiere generar una cadena aleatoria como `code_verifier`, hashearla con SHA-256 y enviar el hash codificado en Base64-URL como `code_challenge`. El `code_verifier` original se envía luego en la solicitud de token.
</Note>

## Scopes requeridos

Al configurar su aplicación de X y solicitar autorización a los usuarios, debe incluir al menos los siguientes scopes:

* `users.read`
* `email.read`
* `tweet.read`

Es importante incluir `tweet.read`. Debido a una particularidad en la API de X, si no se solicita este scope, los demás pueden no funcionar correctamente. Sequence no lee ningún tweet de usuario; este permiso se solicita únicamente para asegurar que el proceso de autenticación funcione correctamente.