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

> Llame a la API de un proveedor de identidad social o empresarial desde su aplicación de Auth0 con el token de acceso de upstream que Auth0 almacenó después de que el usuario iniciara sesión.

# Llamar a la API de un proveedor de identidad

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****ENMASCARADO*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si tiene [Token Vault](/es/docs/secure/tokens/token-vault) habilitado para su conexión, los tokens de acceso y de actualización ya no se almacenarán en el array `identities` del usuario. En su lugar, se almacenarán en un conjunto seguro de tokens dentro de Token Vault. Para habilitar Token Vault, consulte [Configure Token Vault](/es/docs/secure/tokens/token-vault/configure-token-vault).
</Callout>

Una vez que haya autenticado correctamente a un usuario con un <Tooltip tip="Proveedor de identidad (IdP): servicio que almacena y administra identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=Identity+Provider">Proveedor de identidad</Tooltip> (IdP) externo, como Facebook o GitHub, el IdP suele incluir un <Tooltip tip="Token de acceso: credencial de autorización, en forma de cadena opaca o JWT, que se usa para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=access+token">token de acceso</Tooltip> en el perfil del usuario que devuelve a Auth0.

Puede recuperar y usar este token para llamar a la API del IdP.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  En este artículo se asume que ya configuró la conexión con el IdP que elija. Si no es así, vaya a [Identity Providers Supported by Auth0](/es/docs/authenticate/identity-providers/social-identity-providers), seleccione el IdP que desee y siga los pasos de configuración.
</Callout>

El proceso que seguirá varía según si su código se ejecuta en el backend o en el frontend:

* Si su código se ejecuta en el backend, podemos asumir que su servidor es de confianza y puede almacenar secretos de forma segura (como verá, usamos un secreto en el escenario de backend). Si este es su caso, continúe en la [sección de backend](#from-the-backend) de este artículo.
* Si su código se ejecuta en el frontend (por ejemplo, si se trata de una SPA o de una aplicación nativa de escritorio o móvil), su aplicación no puede almacenar credenciales de forma segura y debe seguir un enfoque alternativo. En este caso, continúe en la [sección de frontend](#from-the-frontend) de este artículo.

<div id="from-the-backend">
  ## Desde el backend
</div>

Una vez que autenticas a un usuario, el IdP suele incluir un Token de acceso en el perfil del usuario que devuelve a Auth0.

Por motivos de seguridad y cumplimiento normativo, Auth0 no envía este token a tu aplicación como parte del perfil del usuario. Para obtenerlo, debes acceder a la <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip> de Auth0 y recuperar el perfil completo del usuario:

1. Obtén un Token de acceso que te permita llamar a la [Auth0 Management API](https://auth0.com/docs/api/management/v2).
2. Llama al [endpoint Get Users by ID](https://auth0.com/docs/api/management/v2#!/Users/get_users_by_id) de la Auth0 Management API con el Token de acceso obtenido en el paso 1. Este endpoint devuelve el perfil completo del usuario, que contiene el Token de acceso del IdP.
3. Extrae el Token de acceso del IdP de la respuesta y úsalo para llamar a la API del IdP.

<div id="step-1-get-a-token">
  ### Paso 1: Obtener un token
</div>

Necesitarás un Token de acceso para llamar a la [Management API](https://auth0.com/docs/api/management/v2).

<div id="create-a-test-application-for-the-management-api">
  #### Crear una aplicación de prueba para la Management API
</div>

Si es la primera vez que solicita un [token de la Management API v2](https://auth0.com/docs/api/management/v2/tokens), deberá crear y configurar una aplicación que pueda usarse para llamar a la Management API:

1. Vaya a [Auth0 Dashboard > Applications > APIs](https://manage.auth0.com/#/apis) y seleccione la [Auth0 Management API](https://manage.auth0.com/#/apis/management/authorized-clients).
2. Seleccione la vista **API Explorer** y haga clic en **Create & Authorize a Test Application**.

Esto creará una nueva aplicación y concederá todos los alcances de la Management API, lo que significa que los tokens generados para esta aplicación podrán acceder a todos los endpoints de la Management API.

<Card title="¿No ve el botón?">
  Si no ve este botón, significa que ya tiene al menos una aplicación autorizada para la Management API. En ese caso, puede actualizar los alcances de la aplicación existente y usarla, o crear una nueva siguiendo estos pasos:

  1. Vaya a [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) y seleccione **Create Application**.
  2. Seleccione **Machine to Machine Applications** y luego **Create**.
  3. En el menú desplegable **Select an API**, seleccione `Auth0 Management API`.
  4. Habilite los alcances requeridos y seleccione **Authorize**.
  5. Seleccione la vista **APIs** y active el interruptor de **Auth0 Management API**.
</Card>

<Warning>
  Por motivos de seguridad, le recomendamos asignar solo los alcances necesarios a la aplicación que va a usar. Para este caso concreto, los alcances que necesita son: `read:users`, `read:user_idp_tokens`. Los alcances requeridos se indican para cada endpoint en el [Management API Explorer](https://auth0.com/docs/api/management/v2).
</Warning>

Para conceder o quitar alcances de la [Auth0 Management API registrada](https://manage.auth0.com/#/apis/management/authorized-clients), seleccione la [vista **Machine to Machine Applications**](https://manage.auth0.com/#/apis/management/authorized-clients):

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6nuMjQMrTWhoVqtRwJBQz7/28a0f7c89c696426e273f43bd849b5e5/2025-02-25_11-11-36.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5a948f2961c567c0aa434569c9fabe68" alt="Edite los alcances concedidos a la aplicación" width="899" height="770" data-path="docs/images/cdy7uua7fh8z/6nuMjQMrTWhoVqtRwJBQz7/28a0f7c89c696426e273f43bd849b5e5/2025-02-25_11-11-36.png" />
</Frame>

<div id="get-the-management-api-token">
  #### Obtener el token de Management API
</div>

Ya ha completado la configuración y está listo para obtener su token de Management API:

1. En la [Management API de Auth0 registrada](https://manage.auth0.com/#/apis/management/authorized-clients), seleccione la vista [**Test**](https://manage.auth0.com/#/apis/management/test).
2. Elija su aplicación en el menú desplegable **Application** para rellenar automáticamente los fragmentos de código listos para usar con variables personalizadas.
3. Elija el idioma que prefiera para el fragmento de código, cópielo y ejecútelo.
4. Extraiga la propiedad `access_token` de la respuesta. Eso es lo que usará para acceder a la Management API.

<Card title="¿Qué hacen los fragmentos de código?">
  Los fragmentos de código realizan una operación `POST` al [endpoint /oauth/token de la Authentication API de Auth0](https://auth0.com/docs/api/authentication#client-credentials) mediante la **concesión Client Credentials de OAuth 2.0**. Esta es la concesión que usan los procesos de máquina a máquina para acceder a una API. Para obtener más información sobre este flujo, consulte [Client Credentials Flow](/es/docs/get-started/authentication-and-authorization-flow/client-credentials-flow).
</Card>

<div id="token-expiration">
  #### Expiración del token
</div>

De forma predeterminada, el token que recibió vence en 24 horas (86.400 segundos). Para cambiarlo:

1. Vaya a [Auth0 Dashboard > Applications > APIs](https://manage.auth0.com/#/apis) y seleccione la [Auth0 Management API](https://manage.auth0.com/#/apis/management/authorized-clients).
2. Seleccione la vista **Settings**, busque el campo **Token Expiration (Seconds)**, introduzca un nuevo valor y haga clic en **Save**. El valor máximo que puede establecer es de 2.592.000 segundos (30 días), aunque le recomendamos mantener el valor predeterminado.

El siguiente token que genere tendrá el tiempo de expiración actualizado.

<Warning>
  Estos tokens **no se pueden revocar**. Para minimizar el riesgo, recomendamos emitir tokens de corta duración y conceder solo los alcances necesarios para cada aplicación. En un entorno de producción, puede configurar una CLI sencilla para obtener un token nuevo cuando caduque el anterior.
</Warning>

<div id="step-2-get-the-full-user-profile">
  ### Paso 2: Obtener el perfil completo del usuario
</div>

Para obtener el perfil de un usuario, llama al [endpoint Get a User](https://auth0.com/docs/api/management/v2#!/Users/get_users_by_id) de la Management API con el Token de acceso que extrajiste en la sección anterior:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/api/v2/users/%7BuserId%7D' \
    --header 'authorization: Bearer {yourAccessToken}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/%7BuserId%7D");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {yourAccessToken}");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/%7BuserId%7D"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer {yourAccessToken}")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.get("https://{yourDomain}/api/v2/users/%7BuserId%7D")
    .header("authorization", "Bearer {yourAccessToken}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/api/v2/users/%7BuserId%7D',
    headers: {authorization: 'Bearer {yourAccessToken}'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/%7BuserId%7D",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {yourAccessToken}"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer {yourAccessToken}" }

  conn.request("GET", "/{yourDomain}/api/v2/users/%7BuserId%7D", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/%7BuserId%7D")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer {yourAccessToken}'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Reemplaza estos valores:

* `{userId}`: ID del usuario para el que quieres invocar la API del IdP.
* `{yourAccessToken}`: Token de acceso que extrajiste en la sección anterior.

<Card title="¿Dónde encuentro el ID del usuario?">
  - Para realizar pruebas, puedes encontrar un ID de usuario en [Auth0 Dashboard > User Management > Users](https://manage.auth0.com/#/users). Busca un usuario y copia el valor del campo **user\_id**.

  - Para tu implementación, puedes extraer el ID del usuario del claim `sub` del [ID Token](/es/docs/secure/tokens/id-tokens), o llamar al [endpoint /userinfo](https://auth0.com/docs/api/authentication#get-user-info) de la Authentication API y extraerlo de la propiedad `user_id` de la respuesta.
</Card>

<div id="step-3-extract-the-idp-access-token">
  ### Paso 3: Extrae el Token de acceso del IdP
</div>

Puedes encontrar el Token de acceso que se usa para llamar a la API del IdP en el arreglo `identities` del usuario: `user.identities[0].access_token`.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Para ciertos Proveedores de identidad, Auth0 también almacenará un Token de actualización, que puedes usar para obtener un nuevo Token de acceso para el IdP. Esto funciona con: BitBucket, Google (OAuth 2.0), OAuth 2.0, SharePoint y Azure AD. Para obtener más información, consulta [Tokens de acceso del Proveedor de identidad](/es/docs/secure/tokens/access-tokens/identity-provider-access-tokens).
</Callout>

En la mayoría de los casos, el usuario solo tendrá una identidad, pero si ha iniciado sesión varias veces a través de distintas conexiones y has usado [la vinculación de cuentas](/es/docs/manage-users/user-accounts/user-account-linking/link-user-accounts), puede haber más.

En esta respuesta de ejemplo, vemos que nuestro usuario solo tiene una identidad: `google-oauth2`.

```json lines expandable theme={null}
{
  "email": "john.doe@test.com",
  "email_verified": true,
  "name": "John Doe",
  "given_name": "John",
  "family_name": "Doe",
  "picture": "https://myavatar/photo.jpg",
  "gender": "male",
  "locale": "en",
  "updated_at": "2017-03-15T07:14:32.451Z",
  "user_id": "google-oauth2|111199914890750704174",
  "nickname": "john.doe",
  "identities": [
    {
      "provider": "google-oauth2",
      "access_token": "ya29.GlsPBCS6ahokDlgCYnVLnDKNE71HBXPEzNhAPoKJLAGKDSe1De3_xclahNcdZXoU-26hCpa8h6240TV86dtaEQ4ZWoeeZduHDq_yeu9QyQqUr--S9B2CR9YJrLTD",
      "expires_in": 3599,
      "user_id": "111199914890750704174",
      "connection": "google-oauth2",
      "isSocial": true
    }
  ],
  "created_at": "2017-03-15T07:13:41.134Z",
  "last_ip": "127.0.0.1",
  "last_login": "2017-03-15T07:14:32.451Z",
  "logins_count": 99
}
```

Ahora ya puede llamar a la API del IdP. Consulte la documentación del IdP para obtener información específica sobre cómo hacerlo.

<Warning>
  No exponga los tokens del IdP en su aplicación del lado del cliente. Si su aplicación es pública, consulte la [sección de frontend](#from-the-frontend) de este artículo.
</Warning>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Para obtener más información sobre cómo solicitar alcances específicos para un token de acceso del Proveedor de identidad, consulte [Agregar alcances/permisos para llamar a las API del Proveedor de identidad](/es/docs/authenticate/identity-providers/adding-scopes-for-an-external-idp).
</Callout>

<div id="from-the-frontend">
  ## Desde el frontend
</div>

Si está trabajando con una aplicación pública (SPA, aplicación nativa de escritorio o aplicación móvil), este es el lugar indicado.

Al trabajar con una aplicación de frontend, el proceso para llamar a las API del IdP difiere del proceso de backend porque las aplicaciones de frontend son aplicaciones públicas que **no pueden proteger credenciales de forma segura**. Como el código de una SPA se puede ver y modificar, y las aplicaciones nativas o móviles se pueden descompilar e inspeccionar, no se puede confiar en ellas para guardar información confidencial, como claves secretas o contraseñas.

En concreto, no pueden guardar de forma segura el **<Tooltip tip="Secreto del cliente: secreto que usa un cliente (aplicación) para autenticarse con el Servidor de autorización; solo deberían conocerlo el cliente y el Servidor de autorización, y debe ser lo suficientemente aleatorio como para que no pueda adivinarse." cta="Ver glosario" href="/es/docs/glossary?term=Client+Secret">Secreto del cliente</Tooltip>** de la aplicación de máquina a máquina, que se utiliza para llamar a `/oauth/token` durante el primer paso del proceso de backend.

En su lugar, debe crear un proxy para su backend y exponerlo a su aplicación como una API.

<div id="build-a-proxy">
  ### Crear un proxy
</div>

Primero, crearás un proceso en tu backend que implementará los pasos incluidos en [la sección del backend](#from-the-backend) de este artículo y lo expondrás a tu aplicación como una API.

Llamarás a la API del IdP desde ese mismo proceso del backend, para que el Token de acceso nunca quede expuesto a tu aplicación pública.

Luego, llamarás a la API de tu proxy desde tu aplicación pública mediante el [Authorization Code Flow with Proof Key for Code Exchange (PKCE)](/es/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).

<Card title="Muéstrame cómo">
  Si no has implementado esto antes, puede que te resulte útil nuestro escenario de arquitectura [Single-page Applications (SPA) with API](/es/docs/get-started/architecture-scenarios/spa-api). Cubre un caso diferente, pero explica cómo configurar Auth0, cómo llamar a una API desde una SPA y cómo implementar validaciones de la API. Incluye un ejemplo que usa [Angular 2](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-spa/angular) y [Node.js](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-api/node).

  También ofrecemos una variante de [Mobile Applications with API](/es/docs/get-started/architecture-scenarios/mobile-api) (el ejemplo usa [Android](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-mobile/android) y [Node.js](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-api/node)).
</Card>