> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Autenticación de Microsoft Entra ID para las API de PlayFab > Autentícate en las API Admin, Server y de entidad de PlayFab con tokens delegados de Microsoft Entra ID mediante flujos de OAuth 2.0 como PKCE, código de dispositivo o concesión implícita. PlayFab admite la autenticación de Microsoft Entra ID (anteriormente Azure Active Directory) para llamar a las API Admin, Server y de entidad. Con la autenticación de Entra ID, inicias sesión con tu identidad de Microsoft y usas un token de acceso delegado en lugar de una clave secreta de desarrollador. Tu aplicación gestiona la experiencia de inicio de sesión mediante flujos estándar de cliente público de OAuth 2.0, como el código de autorización con PKCE, el código de dispositivo o la concesión implícita. La autenticación de Entra ID es una alternativa a las claves secretas de desarrollador para las llamadas a las API Admin, Server y algunas API de entidad. Las API Client y de entidad orientadas a los jugadores siguen usando vales de sesión y tokens de entidad obtenidos mediante el inicio de sesión del jugador. Solo las API de entidad a las que se puede llamar con un token de entidad de *título* pueden usarse con Entra ID. Para obtener más información sobre las claves secretas, consulta [Administración de claves secretas](/services/playfab/live-service-management/gamemanager/secret-key-management). ## Por qué usar la autenticación de Entra ID Las claves secretas de desarrollador son fáciles de usar, pero la autenticación de Entra ID ofrece varias ventajas: * **Sin secretos compartidos**: los flujos de cliente público no requieren un secreto de cliente. Los tokens son de corta duración y su ámbito se limita al usuario que ha iniciado sesión. * **Responsabilidad individual**: cada llamada a la API está vinculada a una identidad de usuario específica, lo que facilita auditar quién hizo qué. * **Acceso condicional**: tu organización puede aplicar directivas de Entra ID como restricciones de IP, autenticación multifactor (MFA) y comprobaciones de cumplimiento de dispositivos. ## Cómo funciona la autenticación de Entra ID Si nunca has trabajado con Microsoft Entra ID, se trata del servicio de identidad en la nube de Microsoft: el mismo sistema de identidad que respalda Microsoft 365, las cuentas de desarrollador de XBOX y Azure. En lugar de que PlayFab emita a tu estudio una clave secreta de larga duración, tu herramienta pide a Entra ID que inicie la sesión de un desarrollador y devuelva un **token de acceso** de corta duración. PlayFab confía en los tokens que Entra ID emite para los usuarios que son miembros de tu estudio. Intervienen tres partes: * **El desarrollador.** Tú, con sesión iniciada mediante una cuenta Microsoft (personal) o una cuenta profesional o educativa (Entra ID). * **Un registro de aplicación en Entra ID.** Representa la herramienta que llama a PlayFab: una CLI, un script de compilación, un panel interno, etc. Le indica a Entra ID que "esta aplicación puede solicitar tokens de acceso de PlayFab en nombre de un usuario con sesión iniciada". * **El servicio de PlayFab.** PlayFab está registrado en Entra ID con el identificador de aplicación `448adbda-b8d8-4f33-a1b0-ac58cf44d4c1` y expone un permiso delegado llamado `plugin`. Cuando tu código solicita el ámbito `448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin`, Entra ID emite un token que PlayFab acepta. Una llamada típica tiene este aspecto: 1. Tu código usa la Biblioteca de autenticación de Microsoft (MSAL) para iniciar el inicio de sesión, normalmente una ventana emergente del explorador o una solicitud de código de dispositivo. 2. El usuario inicia sesión con su identidad de Microsoft y da su consentimiento para que tu aplicación llame a PlayFab en su nombre. 3. MSAL devuelve un token de acceso (un JWT) y almacena en caché un token de actualización para que las llamadas futuras puedan omitir la solicitud. 4. Tu código envía el token en el encabezado `Authorization: Bearer ` de cada solicitud a PlayFab. 5. PlayFab valida el token, lo asigna al usuario de estudio correspondiente y autoriza la llamada en función del rol de ese usuario. Para ver las definiciones de los términos de Entra ID usados a lo largo de este artículo, consulta el [Glosario](#glossary) al final. ## Requisitos previos * Una cuenta Microsoft respaldada por Entra ID (una cuenta profesional o educativa) o una cuenta Microsoft personal (MSA). * Un título de PlayFab. Para obtener más información, consulta [Crear una cuenta de PlayFab](/services/playfab/identity/dev-identity/pfab-account). * Permisos para registrar aplicaciones en tu inquilino de Microsoft Entra ID. * El usuario que realiza las llamadas debe agregarse al estudio de PlayFab y asignarse como administrador del título. Para obtener más información sobre los roles, consulta [Roles de usuario de PlayFab](/services/playfab/identity/dev-identity/permissions/playfab-user-roles). ## Registrar una aplicación de cliente público en Entra ID Debes registrar una aplicación en tu inquilino de Entra ID para que tu código pueda solicitar tokens delegados en nombre de un usuario con sesión iniciada. Para los flujos de cliente público (SPA, código de dispositivo, implícito), no se necesita un secreto de cliente. 1. Inicia sesión en [Azure Portal](https://portal.azure.com). 2. Busca y selecciona **App registrations** y, a continuación, selecciona **New registration**. 3. Escribe un nombre para tu aplicación (por ejemplo, `PlayFab API Client`). 4. En **Supported account types**, selecciona la opción que se ajuste a los requisitos de tu organización. Para obtener la máxima flexibilidad, selecciona **Accounts in any organizational directory (Any Microsoft Entra ID tenant - Multitenant) and personal Microsoft accounts**. Esta opción permite autenticarse con cualquier cuenta Microsoft. 5. Configura el **Redirect URI** según tu tipo de aplicación: * Para una aplicación de página única (SPA), selecciona **Single-page application (SPA)** y escribe tu URI de redireccionamiento (por ejemplo, `http://localhost:3000`). * Para una aplicación nativa o de consola que use el flujo de código de dispositivo, selecciona **Public client/native (mobile & desktop)** y escribe `http://localhost`. 6. Selecciona **Register**. En la página de información general, anota el **Application (client) ID**. Necesitarás este valor al solicitar tokens. 7. Agrega el permiso de la API de PlayFab a tu registro de aplicación: 1. En Azure Portal, ve a tu registro de aplicación y selecciona **API permissions**. 2. Selecciona **Add a permission** > **APIs my organization uses**. 3. Busca el identificador de aplicación de PlayFab `448adbda-b8d8-4f33-a1b0-ac58cf44d4c1` y selecciónalo. 4. Selecciona **Delegated permissions**, marca el permiso **plugin** y selecciona **Add permissions**. Si tu escenario requiere un cliente confidencial (aplicación web), también debes crear un secreto de cliente en **Certificates & secrets**. Este artículo se centra en los flujos de cliente público, que no requieren un secreto. Para obtener más información sobre los flujos de cliente confidencial, consulta [Plataforma de identidad de Microsoft y flujo de código de autorización de OAuth 2.0](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow). ## Configurar el acceso al estudio de PlayFab PlayFab valida los tokens de Entra ID en función de la pertenencia al estudio. El usuario que realiza las llamadas debe agregarse al estudio de PlayFab y recibir el rol adecuado. 1. Pide a un administrador del estudio que inicie sesión en [Game Manager](https://developer.playfab.com). 2. Ve a la sección **Users** del estudio. 3. Selecciona **Add User** y escribe el correo electrónico de la cuenta Microsoft del desarrollador que necesita acceso a la API. 4. Selecciona **Microsoft** como proveedor de autenticación. 5. Asigna al usuario un rol que incluya acceso a las API Admin o Server. Como mínimo, el usuario debe ser **administrador del título** en los títulos en los que necesite llamar a las API. 6. Selecciona **Add user** para enviar la invitación. Para obtener más información sobre cómo agregar usuarios y asignar roles, consulta [Autenticación de cuentas para Game Manager de PlayFab](/services/playfab/identity/dev-identity/authentication/aad-authentication). ## Obtener un token de acceso Tu aplicación es responsable de iniciar la sesión del usuario y obtener un token de acceso delegado de Entra ID. Los siguientes ejemplos muestran flujos comunes de cliente público. ### Flujo interactivo con explorador (recomendado para aplicaciones de escritorio y consola) El flujo interactivo con explorador abre una ventana del explorador del sistema para iniciar sesión. Es la opción recomendada para aplicaciones de escritorio y herramientas de desarrollo local. ```csharp theme={null} using Microsoft.Identity.Client; // Build an MSAL public client app. The client ID identifies your Entra app // registration; "common" lets users sign in from any Entra tenant or with a // personal Microsoft account. var app = PublicClientApplicationBuilder.Create("your-client-id") .WithAuthority("https://login.microsoftonline.com/common") .WithDefaultRedirectUri() .Build(); // The scope identifies the PlayFab API and the delegated permission ("plugin") // your app is requesting on behalf of the signed-in user. string[] scopes = ["448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin"]; AuthenticationResult result; try { // Try to get a token from MSAL's cache without prompting the user. // This succeeds on subsequent runs while the cached refresh token is valid. var accounts = await app.GetAccountsAsync(); result = await app.AcquireTokenSilent(scopes, accounts.FirstOrDefault()) .ExecuteAsync(); } catch (MsalUiRequiredException) { // No cached token, or it expired and can't be refreshed silently. // Open the system browser so the user can sign in interactively. result = await app.AcquireTokenInteractive(scopes) .WithUseEmbeddedWebView(false) .ExecuteAsync(); } // The access token is what you send to PlayFab in the Authorization header. string accessToken = result.AccessToken; ``` ### Código de autorización con PKCE (recomendado para SPA) El flujo de código de autorización con clave de prueba para el intercambio de código (PKCE) es el enfoque recomendado para las aplicaciones de página única. El siguiente ejemplo de JavaScript usa la Biblioteca de autenticación de Microsoft (MSAL): ```javascript theme={null} import { PublicClientApplication } from "@azure/msal-browser"; // MSAL config. clientId is your Entra app registration's Application (client) ID. // "common" lets users sign in from any tenant or with a personal account. // redirectUri must match a Single-page application redirect URI on the app registration. const msalConfig = { auth: { clientId: "your-client-id", authority: "https://login.microsoftonline.com/common", redirectUri: "http://localhost:3000" } }; const msalInstance = new PublicClientApplication(msalConfig); await msalInstance.initialize(); // loginPopup runs the auth code + PKCE flow in a pop-up window. The scope // asks Entra ID for a delegated token that PlayFab will accept. const loginResponse = await msalInstance.loginPopup({ scopes: ["448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin"] }); // Send this token to PlayFab in the Authorization header. const accessToken = loginResponse.accessToken; ``` ## Llamar a las API de PlayFab con el token de acceso Incluye el token de acceso de Entra ID en el encabezado `Authorization` como token de tipo Bearer en tus solicitudes a las API de PlayFab, en lugar de usar el encabezado `X-SecretKey`. ### Ejemplo de solicitud ```http theme={null} POST https://{titleId}.playfabapi.com/Server/GetPlayerProfile Content-Type: application/json Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOi... { "PlayFabId": "ABCDEF1234567890" } ``` No puedes usar `X-SecretKey` y `Authorization: Bearer` en la misma solicitud. Usa un método de autenticación por llamada. ### Ejemplo de C\# El siguiente ejemplo usa la Biblioteca de autenticación de Microsoft (MSAL) para obtener un token y llama a la API `Server/GetTime`. Reemplaza `your-client-id` por el **Application (client) ID** de tu registro de aplicación. ```csharp theme={null} using Microsoft.Identity.Client; using System.Net.Http.Headers; using System.Text; // PlayFab API endpoint. Every title gets its own subdomain on playfabapi.com. string titleId = "YOUR_TITLE_ID"; string host = $"{titleId}.playfabapi.com"; string url = $"https://{host}/Server/GetTime"; // MSAL configuration. // clientId - your Entra app registration's Application (client) ID. // authority - "common" lets any Entra tenant or personal Microsoft account sign in. // scopes - the PlayFab application ID + the "plugin" delegated permission. string clientId = "your-client-id"; string authority = "https://login.microsoftonline.com/common"; string[] scopes = ["448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin"]; // Build the MSAL public client. Public clients (desktop, CLI, mobile) don't use // a client secret; tokens are bound to the signed-in user instead. var app = PublicClientApplicationBuilder.Create(clientId) .WithAuthority(authority) .WithDefaultRedirectUri() .Build(); AuthenticationResult authResult; try { // Reuse a cached token if MSAL has one. Avoids prompting on every run. var accounts = await app.GetAccountsAsync(); authResult = await app.AcquireTokenSilent(scopes, accounts.FirstOrDefault()) .ExecuteAsync(); } catch (MsalUiRequiredException) { // First run, or the cached token expired. Open the system browser to sign in. authResult = await app.AcquireTokenInteractive(scopes) .WithUseEmbeddedWebView(false) .ExecuteAsync(); } // Call PlayFab. Replace X-SecretKey with an Authorization: Bearer header // containing the Entra ID access token. using var httpClient = new HttpClient(); var request = new HttpRequestMessage(HttpMethod.Post, url); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken); request.Content = new StringContent("{}", Encoding.UTF8, "application/json"); var response = await httpClient.SendAsync(request); var body = await response.Content.ReadAsStringAsync(); Console.WriteLine($"Status: {response.StatusCode}"); Console.WriteLine($"Response: {body}"); ``` ### Ejemplo de Node.js El siguiente ejemplo usa la biblioteca `@azure/msal-node` para obtener un token y llama a la API `Server/GetTime`. Reemplaza `your-client-id` por el **Application (client) ID** de tu registro de aplicación. ```javascript theme={null} import { PublicClientApplication } from "@azure/msal-node"; import open from "open"; // PlayFab API endpoint for your title. const titleId = "YOUR_TITLE_ID"; const host = `${titleId}.playfabapi.com`; const url = `https://${host}/Server/GetTime`; // MSAL configuration. // clientId - your Entra app registration's Application (client) ID. // authority - "common" accepts any Entra tenant or personal Microsoft account. const msalConfig = { auth: { clientId: "your-client-id", authority: "https://login.microsoftonline.com/common", }, }; const pca = new PublicClientApplication(msalConfig); // Token request: // scopes - PlayFab application ID + the "plugin" delegated permission. // redirectUri - must match a Public client redirect URI on the app registration. // openBrowser - MSAL calls this to launch the user's default browser for sign-in. const tokenRequest = { scopes: ["448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin"], redirectUri: "http://localhost:3000", openBrowser: async (url) => { await open(url); }, successTemplate: "

Authentication complete. You can close this window.

", }; // Sign the user in and obtain a delegated access token. const authResult = await pca.acquireTokenInteractive(tokenRequest); // Call PlayFab with the token in the Authorization header instead of X-SecretKey. const response = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${authResult.accessToken}`, }, body: JSON.stringify({}), }); const body = await response.json(); console.log(`Status: ${response.status}`); console.log("Response:", JSON.stringify(body, null, 2)); ``` ## Actualización de tokens Los tokens de acceso de Entra ID son de corta duración (normalmente entre 60 y 90 minutos). Si usas MSAL, llama a `AcquireTokenSilent` (C#) o comprueba la caché de tokens antes de cada solicitud: MSAL gestiona la actualización automáticamente cuando hay un token de actualización en caché disponible. Si administras los tokens manualmente, solicita un token nuevo mediante el mismo flujo de inicio de sesión antes de que expire el actual. Si un token expira durante su uso, PlayFab devuelve una respuesta `401 Unauthorized`. Tu aplicación debe gestionar este error solicitando un token nuevo y reintentando la llamada. ## Solución de problemas | Problema | Causa | Resolución | | ---------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------- | | `401 Unauthorized` | El token ha expirado o no es válido | Inicia sesión de nuevo y solicita un token nuevo | | `403 Forbidden` | El usuario no tiene el rol necesario en el título | Comprueba la pertenencia al estudio y el rol de administrador del título en Game Manager | | `AADSTS50076: Need multifactor authentication` | La directiva de acceso condicional requiere MFA | Completa el desafío de MFA y vuelve a intentarlo | | `AADSTS700016: Application not found` | El identificador de cliente es incorrecto o la aplicación no está en el inquilino esperado | Comprueba el identificador de cliente y el identificador de inquilino | ### Ejemplos de respuestas de error Una respuesta `401 Unauthorized` de PlayFab cuando falta el token de tipo Bearer, tiene un formato incorrecto o ha expirado tiene este aspecto: ```json theme={null} { "code": 401, "status": "Unauthorized", "error": "NotAuthenticated", "errorCode": 1074, "errorMessage": "Invalid \"Authorization\" header." } ``` Una respuesta `403 Forbidden` de PlayFab cuando el usuario con sesión iniciada está autenticado pero carece de permisos de administrador en el título tiene este aspecto: ```json theme={null} { "code": 403, "status": "Forbidden", "error": "NotAuthorizedByTitle", "errorCode": 1191, "errorMessage": "Developer does not have admin permission for this title." } ``` ## Limitaciones Los SDK de PlayFab no admiten actualmente la autenticación de Entra ID. Para llamar a las API de PlayFab con un token de Entra ID hoy en día, usa llamadas HTTP directas y establece tú mismo el encabezado `Authorization: Bearer `, como se muestra en los ejemplos de [C#](#c-example) y [Node.js](#nodejs-example). La compatibilidad con los SDK está prevista para una versión futura. ## Glosario | Término | Significado | | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inquilino** | Un directorio aislado en Entra ID. Tu empresa tiene uno; las cuentas Microsoft personales usan un inquilino compartido llamado *consumers*. La autoridad `common` usada en los ejemplos permite a los usuarios iniciar sesión desde cualquier inquilino. | | **Registro de aplicación** | El registro en Entra ID que describe tu aplicación cliente (su identificador de cliente, los URI de redireccionamiento permitidos, los permisos de API solicitados). | | **Permiso delegado** | Un permiso que tu aplicación recibe *en nombre de* un usuario con sesión iniciada, en lugar de actuar por sí misma. | | **Cliente público** | Un cliente que no puede almacenar un secreto de forma segura: una aplicación de escritorio o móvil, una CLI o una aplicación web de página única. Los clientes públicos usan flujos como el código de autorización con PKCE o el código de dispositivo en lugar de un secreto de cliente. | | **Ámbito** | El permiso de API que tu código solicita a Entra ID. Para PlayFab, el ámbito es `448adbda-b8d8-4f33-a1b0-ac58cf44d4c1/plugin`. | | **MSAL** | Biblioteca de autenticación de Microsoft. La biblioteca cliente oficial que implementa todos estos flujos para que no tengas que construir las solicitudes de OAuth a mano. | ## Consulte también * [Administración de claves secretas](/services/playfab/live-service-management/gamemanager/secret-key-management) * [Autenticación de cuentas para Game Manager de PlayFab](/services/playfab/identity/dev-identity/authentication/aad-authentication) * [Roles de usuario de PlayFab](/services/playfab/identity/dev-identity/permissions/playfab-user-roles) * [Directiva de acceso a la API](/services/playfab/api-references/api-access-policy) * [Documentación de Microsoft Entra ID](https://learn.microsoft.com/en-us/entra/fundamentals/whatis) ## Related topics - [Autenticación de su servicio con las API de Microsoft Store](/es/publishing/xstore-commerce/xstore-authenticating-service.md) - [Autenticación con cuentas Microsoft para PlayFab](/es/services/playfab/identity/dev-identity/authentication/aad-authentication.md) - [Conexión de Grafana a Insights](/es/services/playfab/data-analytics/legacy/connectivity/connecting-grafana-to-insights.md) - [Crear una aplicación de Microsoft Entra ID para PlayFab Insights](/es/services/playfab/data-analytics/legacy/connectivity/creating-AAD-app-for-insights.md) - [Solicitud de un identificador de la Tienda del usuario para la autenticación de servicio a servicio](/es/publishing/xstore-commerce/xstore-requesting-userstoreid.md)