> ## 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.
> Aprenda a permitir que sus usuarios administren la información de su propia cuenta con la My Account API.
# My Account API
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 {processedChildren};
};
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
{displayText}
;
};
La My Account API está disponible en acceso anticipado. Para solicitar acceso, contacta con tu gerente de cuenta de Auth0 o con [Auth0 Support](https://support.auth0.com). Para obtener más información sobre el ciclo de lanzamientos de productos de Auth0, consulta [Etapas de lanzamiento del producto](/es/docs/troubleshoot/product-lifecycle/product-release-stages).
La My Account API de Auth0 proporciona un conjunto específico de endpoints para que los usuarios administren la información de su propia cuenta. Los clientes pueden usar estas API para crear experiencias de autoservicio en sus aplicaciones o para añadir progresivamente más datos a la cuenta de un usuario.
La My Account API funciona en el contexto del usuario que ha iniciado sesión y puede usarse directamente en aplicaciones orientadas al usuario final.
**Uso del dominio de Auth0 frente al dominio personalizado**
La My Account API admite el uso de tu dominio canónico de Auth0 o de tu dominio personalizado, pero debes usar el mismo durante todo el proceso, lo que incluye:
* Obtener un token de acceso
* Establecer el valor de `audience`
* Llamar al endpoint de la My Account API
Para obtener más información, consulta [Dominio personalizado](/es/docs/customize/custom-domains).
## Activar la My Account API
Puede activar la My Account API para su inquilino en el Auth0 Dashboard:
1. Vaya a **Applications > APIs**.
2. Busque el banner de **MyAccount API**.
3. Seleccione **Activate**.
De forma predeterminada, la My Account API se crea con las siguientes políticas de acceso de aplicaciones a la API:
* `require_client_grant` para los flujos de usuario
* `deny_all` para los flujos de cliente (machine-to-machine)
Para que una aplicación acceda a la My Account API en nombre del usuario, debe crear explícitamente un client grant para esa aplicación, lo que le permite definir los alcances máximos que la aplicación puede solicitar. Como alternativa, puede cambiar la política de los flujos de acceso de usuario a `allow_all`, lo que permite que cualquier aplicación de su inquilino solicite cualquier alcance de la My Account API.
Auth0 no recomienda usar `allow_all` para los flujos de acceso de usuario, porque la My Account API expone información y operaciones sensibles. Debe seguir el principio de privilegio mínimo con la My Account API para garantizar que las aplicaciones solo obtengan acceso a lo que realmente necesitan y así minimizar los posibles riesgos de seguridad.
Los permisos finales concedidos a la aplicación estarán determinados por la intersección entre los alcances permitidos por la política de acceso de aplicaciones a la API, los permisos de control de acceso basado en roles (RBAC) asignados al usuario final y el consentimiento que haya otorgado el usuario (si corresponde).
No puede actualizar la política de acceso de aplicaciones a la API para el acceso de cliente a la My Account API, lo que significa que no puede acceder a la My Account API mediante el flujo de credenciales del cliente.
Para obtener más información sobre cómo administrar las políticas de acceso de aplicaciones a la API y sus client grants asociados, consulte [Acceso de aplicaciones a las API: Client Grants](/es/docs/get-started/applications/application-access-to-apis-client-grants).
## Configuración de Default Policy
El aseguramiento de autenticación para la **My Account API** se encuentra actualmente en acceso anticipado y solo ofrece una opción de política. Al usar esta función, aceptas los términos aplicables de la prueba gratuita del [Master Subscription Agreement](https://www.okta.com/legal) de Okta. Para obtener más información sobre el ciclo de lanzamiento de productos de Auth0, consulta [Etapas de lanzamiento de productos](/es/docs/troubleshoot/product-lifecycle/product-release-stages). Para participar en el programa, ponte en contacto con [Auth0 Support](https://support.auth0.com).
Default Policy proporciona aseguramiento de autenticación integrado para la My Account API al requerir [autenticación escalonada](/es/docs/secure/multi-factor-authentication/step-up-authentication). Cuando está habilitada, Auth0 exige automáticamente que los usuarios se hayan autenticado recientemente y con un segundo factor.
La política exige 2FA en un plazo de 15 minutos. Auth0 aplica esta regla al iniciar sesión y en cada intercambio del token de actualización:
* Si un usuario tiene un factor MFA inscrito, debe completar 2FA al iniciar sesión y de nuevo cuando sus tokens tengan más de 15 minutos de antigüedad.
* Si un usuario no tiene ningún factor disponible para inscribirse, Auth0 permite el acceso inicial, pero devuelve un error `unmet_authentication_requirements` en los intercambios del token de actualización después de 15 minutos.
Default Policy no es compatible con Classic Login. Habilita esta función si tu inquilino usa Universal Login o un flujo integrado compatible ([flujo de contraseña del propietario del recurso](/es/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow) o [claves de acceso nativas](/es/docs/authenticate/database-connections/passkeys/native-passkeys-api)).
### Habilitar Default Policy
Para habilitar Default Policy para la My Account API:
1. Vaya a [**Applications > APIs**](https://manage.auth0.com/#/apis) y seleccione **My Account API**.
2. Seleccione la pestaña **Settings**.
3. En **Default Policy**, active **Require 2FA**.
4. Seleccione **Save**.
Cuando la Default Policy está habilitada en su inquilino, se adjunta automáticamente cada vez que se crea una nueva **My Account API**.
### Jerarquía de requisitos de autenticación
La Default Policy se encuentra entre la política de MFA a nivel de inquilino y cualquier lógica de MFA que definas en Actions:
1. **Política de MFA del inquilino** — la configuración base que se aplica de forma predeterminada a toda la autenticación de tu inquilino
2. **Default Policy** — reemplaza la configuración a nivel de inquilino específicamente para la My Account API
3. **Actions** — cualquier comando de MFA en Actions siempre tiene prioridad sobre ambas
### Comportamiento de la Default Policy
El comportamiento depende de si el usuario tiene disponible un segundo factor para inscribirse.
**Usuarios con un factor MFA inscrito**
Para los usuarios inscritos con TOTP, correo electrónico u otro factor compatible:
1. Al iniciar sesión, Auth0 desafía al usuario con su factor inscrito antes de emitir los tokens.
2. El token de actualización registra el método de autenticación y la marca de tiempo (AMR).
3. En un intercambio del token de actualización dentro de los 15 minutos posteriores al último desafío, Auth0 emite un nuevo token de acceso sin volver a desafiarlo.
4. En un intercambio del token de actualización después de 15 minutos, Auth0 vuelve a desafiar al usuario antes de emitir los tokens.
**Usuarios sin un factor MFA inscrito**
Para los usuarios sin correo electrónico verificado y sin ningún factor inscrito:
1. Al iniciar sesión, Auth0 permite el acceso sin un segundo factor.
2. En un intercambio del token de actualización dentro de los 15 minutos, Auth0 emite un nuevo token de acceso sin presentar ningún desafío.
3. En un intercambio del token de actualización después de 15 minutos, Auth0 devuelve un error `unmet_authentication_requirements`.
Cuando se devuelve `unmet_authentication_requirements` en un intercambio del token de actualización, el token no se puede renovar. Su aplicación debe reiniciar todo el flujo de autenticación para obtener nuevos tokens.
El mismo error se devuelve en un inicio de sesión silencioso (`prompt=none`) cuando el usuario no puede cumplir la política después de 15 minutos.
## Obtenga un token de acceso
Puede obtener un token de acceso para la My Account API de la misma manera que obtendría un token de acceso para una de sus propias API.
Si necesita garantías de autenticación que vayan más allá de la Default Policy —por ejemplo, para exigir un factor específico o aplicar requisitos solo a determinadas operaciones—, puede usar la [autenticación escalonada](/es/docs/secure/multi-factor-authentication/step-up-authentication) con [Actions](/es/docs/customize/actions) para definir una lógica de MFA personalizada. Tenga en cuenta que Actions siempre prevalece sobre la Default Policy.
Si usa Universal Login, lea los siguientes artículos:
* [Llame a su API mediante el Flujo de código de autorización](/es/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/call-your-api-using-the-authorization-code-flow)
* [Llame a su API mediante el Flujo de código de autorización con PKCE](/es/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce)
Si usa inicio de sesión integrado, lea los siguientes artículos:
* [Llame a su API mediante el flujo de contraseña del propietario del recurso](/es/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow)
* [Flujo de inicio de sesión con Native Passkeys API](/es/docs/authenticate/database-connections/passkeys/native-passkeys-api#login-flow)
### Audiencia
La audiencia de la My Account API es `https://{yourDomain}/me/`.
### Alcance
La My Account API admite los siguientes alcances:
| Alcance | Descripción |
| ---------------------------------- | --------------------------------------------------------------------- |
| `create:me:authentication_methods` | Permite al usuario inscribirse en un nuevo método de autenticación. |
| `read:me:authentication_methods` | Permite al usuario ver los métodos de autenticación existentes. |
| `update:me:authentication_methods` | Permite al usuario modificar los métodos de autenticación existentes. |
| `delete:me:authentication_methods` | Permite al usuario eliminar los métodos de autenticación existentes. |
| `read:me:factors` | Permite al usuario ver los factores en los que puede inscribirse. |
Para [Cuentas conectadas con Token Vault](/es/docs/secure/call-apis-on-users-behalf/token-vault/connected-accounts-for-token-vault), la My Account API admite los siguientes alcances:
| Alcance | Descripción |
| ------------------------------ | ------------------------------------------------------------------------------------------- |
| `create:me:connected_accounts` | Permite al usuario vincular una nueva cuenta a su perfil de usuario. |
| `read:me:connected_accounts` | Permite al usuario ver las cuentas conectadas existentes vinculadas a su perfil de usuario. |
| `delete:me:connected_accounts` | Permite al usuario eliminar una cuenta conectada de su perfil de usuario. |
### Ejemplos
#### Universal Login con Flujo de código de autorización
##### Paso 1: Solicitar un código de autorización
```bash cURL theme={null}
curl --request GET \
--url 'https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F"
req, _ := http.NewRequest("GET", url, nil)
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 response = Unirest.get("https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://{yourDomain}/authorize',
params: {
response_type: 'code',
client_id: '{yourClientId}',
redirect_uri: '{yourRedirectUri}',
scope: 'create:me:authentication_methods',
offline_access: '',
audience: 'https://{yourDomain}/me/'
}
};
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}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$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("")
conn.request("GET", "/{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
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}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
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)
response = http.request(request)
puts response.read_body
```
##### Paso 2: Canjear el code por un token de acceso
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/oauth/token"
payload := strings.NewReader("{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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 response = Unirest.post("https://{yourDomain}/oauth/token")
.header("content-type", "application/json")
.body("{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/oauth/token',
headers: {'content-type': 'application/json'},
data: {
grant_type: 'authorization_code',
client_id: '{yourClientId}',
client_secret: '{yourClientId}',
code: '{yourAuthorizationCode}',
redirect_uri: '{yourRedirectUri}',
audience: '{yourAudience}',
scope: 'create:me:authentication_methods',
offline_access: ''
}
};
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}/oauth/token",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}",
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$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("")
payload = "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/{yourDomain}/oauth/token", payload, 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}/oauth/token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}"
response = http.request(request)
puts response.read_body
```
#### Inicio de sesión integrado con claves de acceso nativas
##### Paso 1: Solicitar desafío de inicio de sesión
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/passkey/challenge' \
--header 'content-type: application/json' \
--data '{"client_id": "{yourDomain}"}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/passkey/challenge");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{"client_id": "{yourDomain}"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/passkey/challenge"
payload := strings.NewReader("{"client_id": "{yourDomain}"}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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 response = Unirest.post("https://{yourDomain}/passkey/challenge")
.header("content-type", "application/json")
.body("{"client_id": "{yourDomain}"}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/passkey/challenge',
headers: {'content-type': 'application/json'},
data: {client_id: '{yourDomain}'}
};
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}/passkey/challenge",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "{"client_id": "{yourDomain}"}",
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$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("")
payload = "{"client_id": "{yourDomain}"}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/{yourDomain}/passkey/challenge", payload, 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}/passkey/challenge")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{"client_id": "{yourDomain}"}"
response = http.request(request)
puts response.read_body
```
##### Paso 2: Autenticar a un usuario existente
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/oauth/token"
payload := strings.NewReader("{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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 response = Unirest.post("https://{yourDomain}/oauth/token")
.header("content-type", "application/json")
.body("{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/oauth/token',
headers: {'content-type': 'application/json'},
data: '{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}'
};
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}/oauth/token",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}",
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$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("")
payload = "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby theme={null}
rrequire 'uri'
require 'net/http'
require 'openssl'
url = URI("https://{yourDomain}/oauth/token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}"
response = http.request(request)
puts response.read_body
```
## Solicitudes entre orígenes
Si piensa llamar a la My Account API directamente desde una aplicación basada en navegador (como una Single Page Application) que se ejecuta en un dominio distinto al de su inquilino de Auth0, se encontrará con las políticas de seguridad del navegador conocidas como Cross-Origin Resource Sharing (CORS). De forma predeterminada, los navegadores bloquean estas solicitudes entre orígenes.
Para permitir que su aplicación realice correctamente solicitudes a la API, debe agregar el dominio de su aplicación (su "origen") a la configuración de su cliente:
1. Vaya a [Dashboard > Applications](https://manage.auth0.com/#/applications). Seleccione la aplicación para ver sus detalles.
2. En **Cross-Origin Authentication**, active **Allow Cross-Origin Authentication**.
3. Busque **Allowed Origins (CORS)** e introduzca la URL de origen de su aplicación.
4. Seleccione **Save**.
Para obtener más información, consulte [Configurar Cross-Origin Resource Sharing](/es/docs/get-started/applications/set-up-cors).
Si no necesita usar CORS para su aplicación, asegúrese de que **Allow Cross-Origin Authentication** esté desactivado. Al agregar la URL de su aplicación a esta lista, le indica a Auth0 que confíe en las solicitudes de ese origen, lo que permite que su aplicación del lado del cliente acceda a la API.