> ## 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.

> Esta guía muestra cómo integrar Auth0 con cualquier aplicación ASP.NET MVC, ya sea nueva o existente, mediante el SDK Auth0.AspNetCore.Authentication.

# Agrega el inicio de sesión a tu aplicación ASP.NET MVC

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<Accordion title="Usa IA para integrar Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si usas un asistente de programación con IA como Claude Code, Cursor o GitHub Copilot, puedes añadir la autenticación de Auth0 automáticamente en cuestión de minutos con [agent skills](https://agentskills.io/home).

  **Instala:**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-aspnetcore-authentication
  ```

  **Luego, pídele a tu asistente de IA lo siguiente:**

  ```text theme={null}
  Add Auth0 authentication to my ASP.NET Core MVC app
  ```

  Tu asistente de IA creará automáticamente tu aplicación en Auth0, obtendrá las credenciales, instalará el SDK Auth0 ASP.NET Core Authentication, configurará el middleware de autenticación e implementará los flujos de inicio y cierre de sesión. [Documentación completa sobre agent skills →](/es/docs/quickstart/agent-skills)
</Accordion>

<Note>
  **Requisitos previos:** Antes de comenzar, asegúrate de tener instalado lo siguiente:

  * **[.NET SDK](https://dotnet.microsoft.com/download)** 8.0 o una versión posterior
  * Tu editor de código preferido (Visual Studio, VS Code o Rider)
  * Una cuenta de Auth0 ([regístrate gratis](https://auth0.com/signup))
</Note>

<div id="get-started">
  ## Primeros pasos
</div>

Auth0 le permite agregar autenticación rápidamente y acceder a la información del perfil del usuario en su aplicación. Esta guía muestra cómo integrar Auth0 en cualquier aplicación ASP.NET MVC nueva o existente mediante el SDK `Auth0.AspNetCore.Authentication`.

<Steps>
  <Step title="Crear un nuevo proyecto" stepNumber={1}>
    Cree un nuevo proyecto de ASP.NET Core MVC para esta guía de inicio rápido

    ```shellscript theme={null}
    dotnet new mvc -n SampleMvcApp
    ```

    Abre el proyecto

    ```shellscript theme={null}
    cd SampleMvcApp
    ```
  </Step>

  <Step title="Instala el SDK de Auth0" stepNumber={2}>
    ```shellscript theme={null}
    dotnet add package Auth0.AspNetCore.Authentication
    ```
  </Step>

  <Step title="Configura tu aplicación en Auth0" stepNumber={3}>
    A continuación, debes crear una nueva aplicación en tu tenant de Auth0 y agregar la configuración a tu proyecto.

    Puede hacerlo automáticamente ejecutando un comando de CLI o de forma manual desde el Dashboard:

    <Tabs>
      <Tab title="CLI">
        Ejecute el siguiente comando de shell en el directorio raíz del proyecto para crear una aplicación de Auth0 y actualizar `appsettings.json`:

        <Tabs>
          <Tab title="Mac/Linux">
            ```shellscript theme={null}
            AUTH0_APP_NAME="My App" && brew tap auth0/auth0-cli && brew install auth0 && auth0 login --no-input && auth0 apps create -n "${AUTH0_APP_NAME}" -t regular -c http://localhost:5000/callback -l http://localhost:5000 -o http://localhost:5000 --reveal-secrets --json --metadata created_by="quickstart-docs-cli" > auth0-app-details.json && CLIENT_ID=$(jq -r '.client_id' auth0-app-details.json) && CLIENT_SECRET=$(jq -r '.client_secret' auth0-app-details.json) && DOMAIN=$(auth0 tenants list --json | jq -r '.[] | select(.active == true) | .name') && rm auth0-app-details.json && cat > appsettings.json << EOF
            {
              "Logging": {
                "LogLevel": {
                  "Default": "Information",
                  "Microsoft.AspNetCore": "Warning"
                }
              },
              "AllowedHosts": "*",
              "Auth0": {
                "Domain": "${DOMAIN}",
                "ClientId": "${CLIENT_ID}",
                "ClientSecret": "${CLIENT_SECRET}"
              }
            }
            EOF
            echo "appsettings.json se creó con los datos de Auth0:" && cat appsettings.json
            ```
          </Tab>

          <Tab title="Windows (PowerShell)">
            ```powershell theme={null}
            $AUTH0_APP_NAME = "My MVC App"
            $latestRelease = Invoke-RestMethod -Uri "https://api.github.com/repos/auth0/auth0-cli/releases/latest"
            $latestVersion = $latestRelease.tag_name
            $version = $latestVersion -replace "^v"
            Invoke-WebRequest -Uri "https://github.com/auth0/auth0-cli/releases/download/${latestVersion}/auth0-cli_${version}_Windows_x86_64.zip" -OutFile ".\auth0.zip"
            Expand-Archive ".\auth0.zip" .\
            [System.Environment]::SetEnvironmentVariable('PATH', $Env:PATH + ";${pwd}")
            auth0 login --no-input
            auth0 apps create -n "${AUTH0_APP_NAME}" -t regular -c http://localhost:5000/callback -l http://localhost:5000 -o http://localhost:5000 --reveal-secrets --json --metadata created_by="quickstart-docs-cli" | Set-Content -Path auth0-app-details.json
            $AppDetails = Get-Content -Raw auth0-app-details.json | ConvertFrom-Json
            $ClientId = $AppDetails.client_id
            $ClientSecret = $AppDetails.client_secret
            $Domain = (auth0 tenants list --json | ConvertFrom-Json | Where-Object { $_.active -eq $true }).name
            $Config = Get-Content -Raw appsettings.json | ConvertFrom-Json
            if (-not $Config.Auth0) { $Config | Add-Member -MemberType NoteProperty -Name Auth0 -Value @{} }
            $Config.Auth0.Domain = $Domain
            $Config.Auth0.ClientId = $ClientId
            $Config.Auth0.ClientSecret = $ClientSecret
            $Config | ConvertTo-Json -Depth 10 | Set-Content appsettings.json
            Remove-Item auth0-api-details.json
            Write-Output "✅ appsettings.json se actualizó con los datos de la API de Auth0:"
            Get-Content appsettings.json
            ```
          </Tab>
        </Tabs>
      </Tab>

      <Tab title="Panel">
        Antes de empezar, crea o actualiza `appsettings.json` en el directorio raíz del proyecto

        ```json appsettings.json theme={null}
        {
          "Logging": {
            "LogLevel": {
              "Default": "Information",
              "Microsoft.AspNetCore": "Warning"
            }
          },
          "AllowedHosts": "*",
          "Auth0": {
            "Domain": "YOUR_AUTH0_DOMAIN",
            "ClientId": "YOUR_CLIENT_ID",
            "ClientSecret": "YOUR_CLIENT_SECRET"
          }
        }
        ```

        1. Ve al [Auth0 Dashboard](https://manage.auth0.com/dashboard/)
        2. Haz clic en **Applications → Applications → Create Application**
        3. Introduce un nombre para tu aplicación (por ejemplo, "My MVC App")
        4. Selecciona **Regular Web Application** como tipo de aplicación
        5. Haz clic en **Create**
        6. Ve a la pestaña **Settings**
        7. Reemplaza `YOUR_AUTH0_DOMAIN`, `YOUR_CLIENT_ID` y `YOUR_CLIENT_SECRET` en el archivo `appsettings.json` por los valores de **Dominio**, **ID de cliente** y **Secreto del cliente** del Auth0 Dashboard
      </Tab>
    </Tabs>

    **Configurar las URL de callback:**

    En la pestaña **Settings**, configure las siguientes URL:

    * **Allowed Callback URLs**: `http://localhost:5000/callback`
    * **URLs de cierre de sesión permitidas**: `http://localhost:5000`
    * **Orígenes web permitidos**: `http://localhost:5000`

    Haz clic en **Save Changes**

    <Info>
      **Importante:** Asegúrese de [configurar las conexiones](https://auth0.com/docs/get-started/applications/set-up-database-connections) y habilitarlas para su aplicación en el Auth0 Dashboard, en la pestaña **Conexiones**.
    </Info>
  </Step>

  <Step title="Configurar la autenticación" stepNumber={4}>
    Actualiza tu archivo `Program.cs` para configurar la autenticación de Auth0:

    ```csharp Program.cs lines theme={null}
    using Auth0.AspNetCore.Authentication;

    var builder = WebApplication.CreateBuilder(args);

    builder.Services.AddAuth0WebAppAuthentication(options =>
    {
        options.Domain = builder.Configuration["Auth0:Domain"];
        options.ClientId = builder.Configuration["Auth0:ClientId"];
        options.ClientSecret = builder.Configuration["Auth0:ClientSecret"];
    });

    builder.Services.AddControllersWithViews();

    var app = builder.Build();

    if (!app.Environment.IsDevelopment())
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");

    app.Run();
    ```
  </Step>

  <Step title="Agregar funcionalidad de inicio y cierre de sesión" stepNumber={5}>
    Cree un archivo `AccountController.cs` en la carpeta `Controllers`:

    ```csharp Controllers/AccountController.cs lines theme={null}
    using Auth0.AspNetCore.Authentication;
    using Microsoft.AspNetCore.Authentication;
    using Microsoft.AspNetCore.Authentication.Cookies;
    using Microsoft.AspNetCore.Authorization;
    using Microsoft.AspNetCore.Mvc;

    public class AccountController : Controller
    {
        public async Task Login(string returnUrl = "/")
        {
            var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
                .WithRedirectUri(returnUrl)
                .Build();

            await HttpContext.ChallengeAsync(Auth0Constants.AuthenticationScheme, authenticationProperties);
        }

        [Authorize]
        public async Task Logout()
        {
            var authenticationProperties = new LogoutAuthenticationPropertiesBuilder()
                .WithRedirectUri(Url.Action("Index", "Home"))
                .Build();

            await HttpContext.SignOutAsync(Auth0Constants.AuthenticationScheme, authenticationProperties);
            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        }

        [Authorize]
        public IActionResult Profile()
        {
            return View();
        }
    }
    ```
  </Step>

  <Step title="Vista de creación de perfil" stepNumber={6}>
    Cree un archivo nuevo `Views/Account/Profile.cshtml`:

    ```html Views/Account/Profile.cshtml lines theme={null}
    @{
        ViewData["Title"] = "User Profile";
    }

    <div class="row">
        <div class="col-md-12">
            <h2>@ViewData["Title"]</h2>
            <div class="row">
                <div class="col-md-2">
                    <img src="@User.FindFirst(c => c.Type == "picture")?.Value" alt="User's profile picture" class="img-fluid rounded-circle" />
                </div>
                <div class="col-md-10">
                    <h3>@User.Identity.Name</h3>
                    <p><strong>Email:</strong> @User.FindFirst(c => c.Type == System.Security.Claims.ClaimTypes.Email)?.Value</p>
                    <p><strong>Email Verified:</strong> @User.FindFirst(c => c.Type == "email_verified")?.Value</p>
                    <p><strong>User ID:</strong> @User.FindFirst(c => c.Type == System.Security.Claims.ClaimTypes.NameIdentifier)?.Value</p>
                </div>
            </div>
            
            <h4 class="mt-4">User Claims</h4>
            <table class="table">
                <thead>
                    <tr>
                        <th>Claim Type</th>
                        <th>Claim Value</th>
                    </tr>
                </thead>
                <tbody>
                    @foreach (var claim in User.Claims)
                    {
                        <tr>
                            <td>@claim.Type</td>
                            <td>@claim.Value</td>
                        </tr>
                    }
                </tbody>
            </table>
        </div>
    </div>
    ```

    <Info>
      **Nota:** Primero tendrás que crear el directorio `Views/Account` si no existe.
    </Info>
  </Step>

  <Step title="Actualiza tu diseño" stepNumber={7}>
    Actualiza tu archivo de diseño para añadir botones de inicio y cierre de sesión. En `Views/Shared/_Layout.cshtml`, busca el elemento `<nav>` y sustitúyelo por:

    ```html Views/Shared/_Layout.cshtml lines theme={null}
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container-fluid">
            <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">SampleMvcApp</a>
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                    </li>
                </ul>
                <ul class="navbar-nav">
                    @if (User.Identity.IsAuthenticated)
                    {
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-controller="Account" asp-action="Profile">@User.Identity.Name</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-controller="Account" asp-action="Logout">Logout</a>
                        </li>
                    }
                    else
                    {
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-controller="Account" asp-action="Login">Login</a>
                        </li>
                    }
                </ul>
            </div>
        </div>
    </nav>
    ```

    <Info>
      **Importante:** Reemplace únicamente el elemento `<nav>`. Mantenga intactas todas las demás partes de \_Layout.cshtml, especialmente la llamada a `@RenderBody()`, que es necesaria para mostrar el contenido de la página.
    </Info>
  </Step>

  <Step title="Ejecuta tu aplicación" stepNumber={8}>
    ```shellscript theme={null}
    dotnet run
    ```

    Tu aplicación debería iniciarse y mostrar la URL en la que está escuchando:

    ```
    info: Microsoft.Hosting.Lifetime[14]
          Now listening on: http://localhost:5000
    ```

    Abre el navegador y ve a `http://localhost:5000`. Haz clic en el enlace **Login** de la barra de navegación. Se te redirigirá a la página de inicio de sesión de Auth0. Después de iniciar sesión, se te redirigirá de nuevo a tu aplicación y deberías ver tu nombre en la barra de navegación.
  </Step>
</Steps>

<Check>
  **Punto de verificación**

  Ahora debería tener una aplicación MVC protegida con Auth0 en ejecución y totalmente funcional en [http://localhost:5000](http://localhost:5000). Los usuarios pueden iniciar sesión, ver su perfil y cerrar sesión.
</Check>

***

<div id="advanced-usage">
  ## Uso avanzado
</div>

<Accordion title="Acceder a la información del perfil del usuario">
  Puedes acceder a la información del perfil del usuario a través de la propiedad `User` en tus controladores o vistas:

  ```csharp Controllers/AccountController.cs theme={null}
  [Authorize]
  public IActionResult Profile()
  {
      var user = new
      {
          Name = User.Identity.Name,
          EmailAddress = User.FindFirst(c => c.Type == System.Security.Claims.ClaimTypes.Email)?.Value,
          ProfileImage = User.FindFirst(c => c.Type == "picture")?.Value,
          UserId = User.FindFirst(c => c.Type == System.Security.Claims.ClaimTypes.NameIdentifier)?.Value
      };
      
      return View(user);
  }
  ```

  Las claims del usuario contienen información estándar de OIDC:

  * **Name**: Nombre para mostrar del usuario
  * **Email**: Correo electrónico del usuario
  * **Picture**: URL de la imagen de perfil del usuario
  * **NameIdentifier** (sub): ID único del usuario
</Accordion>

<Accordion title="Personalizar los parámetros de inicio de sesión">
  Puedes pasar parámetros personalizados a la página de inicio de sesión de Auth0:

  ```csharp Controllers/AccountController.cs theme={null}
  public async Task Login(string returnUrl = "/")
  {
      var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
          .WithRedirectUri(returnUrl)
          .WithParameter("screen_hint", "signup")  // Mostrar la página de registro
          .WithParameter("ui_locales", "es")       // Establecer el idioma en español
          .Build();

      await HttpContext.ChallengeAsync(Auth0Constants.AuthenticationScheme, authenticationProperties);
  }
  ```
</Accordion>

<Accordion title="Almacenar tokens para llamadas a API">
  Si necesitas llamar a API externas en nombre del usuario, puedes recuperar y almacenar tokens:

  ```csharp Program.cs theme={null}
  builder.Services.AddAuth0WebAppAuthentication(options =>
  {
      options.Domain = builder.Configuration["Auth0:Domain"];
      options.ClientId = builder.Configuration["Auth0:ClientId"];
      options.ClientSecret = builder.Configuration["Auth0:ClientSecret"];
  })
  .WithAccessToken(options =>
  {
      options.Audience = "https://your-api.example.com";
  });
  ```

  Luego, recupera el token de acceso en el controlador:

  ```csharp Controllers/ApiController.cs theme={null}
  [Authorize]
  public async Task<IActionResult> CallApi()
  {
      var accessToken = await HttpContext.GetTokenAsync("access_token");
      
      // Usa el token de acceso para llamar a tu API
      var client = new HttpClient();
      client.DefaultRequestHeaders.Authorization = 
          new AuthenticationHeaderValue("Bearer", accessToken);
      
      var response = await client.GetAsync("https://your-api.example.com/data");
      var data = await response.Content.ReadAsStringAsync();
      
      return View(data);
  }
  ```
</Accordion>

<Accordion title="Manejar eventos de autenticación">
  Personaliza el comportamiento de la autenticación manejando eventos:

  ```csharp Program.cs theme={null}
  builder.Services.AddAuth0WebAppAuthentication(options =>
  {
      options.Domain = builder.Configuration["Auth0:Domain"];
      options.ClientId = builder.Configuration["Auth0:ClientId"];
      options.ClientSecret = builder.Configuration["Auth0:ClientSecret"];
  })
  .WithAccessToken(options =>
  {
      options.Events = new Auth0WebAppWithAccessTokenEvents
      {
          OnMissingRefreshToken = async (context) =>
          {
              await context.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
              var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
                  .WithRedirectUri("/")
                  .Build();
              
              await context.ChallengeAsync(Auth0Constants.AuthenticationScheme, authenticationProperties);
          }
      };
  });
  ```
</Accordion>

***

<div id="additional-resources">
  ## Recursos adicionales
</div>

<CardGroup cols={2}>
  <Card title="Repositorio de GitHub" icon="github" href="https://github.com/auth0/auth0-aspnetcore-authentication">
    Código fuente y seguimiento de problemas
  </Card>

  <Card title="Referencia de la API" icon="code" href="https://auth0.github.io/auth0-aspnetcore-authentication/">
    Documentación detallada de la API
  </Card>

  <Card title="Foro de la comunidad" icon="comments" href="https://community.auth0.com/">
    Obtén ayuda de la comunidad de Auth0
  </Card>
</CardGroup>

***

<div id="common-issues">
  ## Problemas comunes
</div>

<AccordionGroup>
  <Accordion title="No se puede obtener la configuración">
    **Problema:** `Unable to obtain configuration from: https://your-tenant.auth0.com/.well-known/openid-configuration`

    **Solución:** Verifique que su dominio sea correcto y que no incluya `https://`. La biblioteca construye la autoridad automáticamente.

    ```json theme={null}
    {
      "Auth0": {
        "Domain": "your-tenant.auth0.com"  // Correcto: sin protocolo
      }
    }
    ```

    Asegúrese también de lo siguiente:

    * Que no haya una barra diagonal al final del valor del dominio
    * Que su aplicación tenga acceso a Internet para conectarse a Auth0
    * Que el formato del dominio coincida con la región de su inquilino (`.auth0.com`, `.us.auth0.com`, `.eu.auth0.com`)
  </Accordion>

  <Accordion title="No se encontraron los valores de configuración">
    **Problema:** `ArgumentNullException: Value cannot be null. (Parameter 'Domain')` o similar.

    **Solución:** Asegúrese de que `appsettings.json` contenga la sección de Auth0 con los valores de Domain, ClientId y ClientSecret. Compruebe que la configuración se esté leyendo correctamente:

    ```csharp Program.cs theme={null}
    builder.Services.AddAuth0WebAppAuthentication(options =>
    {
        options.Domain = builder.Configuration["Auth0:Domain"]
            ?? throw new InvalidOperationException("Auth0:Domain is required");
        options.ClientId = builder.Configuration["Auth0:ClientId"]
            ?? throw new InvalidOperationException("Auth0:ClientId is required");
        options.ClientSecret = builder.Configuration["Auth0:ClientSecret"]
            ?? throw new InvalidOperationException("Auth0:ClientSecret is required");
    });
    ```
  </Accordion>

  <Accordion title="Problemas con el orden del middleware">
    **Problema:** La autenticación no funciona a pesar de que la configuración es correcta.

    **Solución:** Asegúrese de que el middleware esté en el orden correcto. `UseAuthentication()` debe ir antes de `UseAuthorization()`:

    ```csharp Program.cs theme={null}
    app.UseRouting();
    app.UseAuthentication();  // Debe ir antes de UseAuthorization
    app.UseAuthorization();
    app.MapControllerRoute(...);
    ```
  </Accordion>
</AccordionGroup>

***

<div id="sample-application">
  ## Aplicación de ejemplo
</div>

Puedes encontrar una aplicación de ejemplo junto al código fuente del SDK:

<Card title="Aplicación Playgroud de ASP.NET Core MVC" icon="github" href="https://github.com/auth0/auth0-aspnetcore-authentication/tree/main/playground/Auth0.AspNetCore.Authentication.Playground">
  Incluye ejemplos de inicio de sesión, cierre de sesión, perfil del usuario y más.
</Card>

Clona y ejecuta:

```bash theme={null}
git clone https://github.com/auth0/auth0-aspnetcore-authentication.git
cd auth0-aspnetcore-authentication/playground/Auth0.AspNetCore.Authentication.Playground
# Actualiza appsettings.json con tu configuración de Auth0
dotnet run
```

***