> ## 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 nueva o existente de Blazor Server mediante el SDK Auth0.AspNetCore.Authentication.

# Agrega el inicio de sesión a tu aplicación Blazor Server

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

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>;
};

<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:**

  ```text theme={null}
  Add Auth0 authentication to my Blazor Server app
  ```

  Tu asistente de IA creará automáticamente tu aplicación en Auth0, recuperará las credenciales, instalará el SDK de autenticación de Auth0 para ASP.NET Core, configurará el middleware de autenticación e implementará los flujos de inicio y cierre de sesión. [Documentación completa de 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 posterior
  * Tu editor de código favorito (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 añadir 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 con cualquier aplicación de Blazor Server, nueva o existente, mediante el SDK `Auth0.AspNetCore.Authentication`.

<Steps>
  <Step title="Crea un proyecto nuevo" stepNumber={1}>
    Cree un proyecto nuevo de Blazor Server para esta guía de inicio rápido

    ```shellscript theme={null}
    dotnet new blazor -n SampleBlazorApp --interactivity Server
    ```

    Abre el proyecto

    ```shellscript theme={null}
    cd SampleBlazorApp
    ```
  </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 de 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 a través del Dashboard:

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

        <Tabs>
          <Tab title="Mac/Linux">
            ```shellscript theme={null}
            AUTH0_APP_NAME="My Blazor 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 sus datos de Auth0:" && cat appsettings.json
            ```
          </Tab>

          <Tab title="Windows (PowerShell)">
            ```powershell theme={null}
            $AUTH0_APP_NAME = "My Blazor 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-app-details.json
            Write-Output "✅ appsettings.json se actualizó con sus datos de Auth0:"
            Get-Content appsettings.json
            ```
          </Tab>
        </Tabs>
      </Tab>

      <Tab title="Dashboard">
        Antes de comenzar, cree o actualice `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. Escribe un nombre para tu aplicación (p. ej., "My Blazor App")
        4. Selecciona **Regular Web Application** como tipo de aplicación
        5. Haz clic en **Create**
        6. Ve a la pestaña **Settings**
        7. Sustituye `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 Dashboard
      </Tab>
    </Tabs>

    **Configurar las URL de callback:**

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

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

    Haz clic en **Save Changes**

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

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

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

    var builder = WebApplication.CreateBuilder(args);

    // Agregar autenticación de Auth0
    builder.Services.AddAuth0WebAppAuthentication(options =>
    {
        options.Domain = builder.Configuration["Auth0:Domain"];
        options.ClientId = builder.Configuration["Auth0:ClientId"];
        options.ClientSecret = builder.Configuration["Auth0:ClientSecret"];
    });

    // Agregar componentes Razor y Blazor Server
    builder.Services.AddRazorComponents()
        .AddInteractiveServerComponents();

    // Agregar estado de autenticación en cascada
    builder.Services.AddCascadingAuthenticationState();

    // Agregar Razor Pages para los endpoints de autenticación
    builder.Services.AddRazorPages();

    var app = builder.Build();

    if (!app.Environment.IsDevelopment())
    {
        app.UseExceptionHandler("/Error", createScopeForErrors: true);
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseAntiforgery();

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

    app.MapStaticAssets();
    app.MapRazorComponents<App>()
        .AddInteractiveServerRenderMode();

    // Mapear Razor Pages para autenticación
    app.MapRazorPages();

    app.Run();
    ```

    <Info>
      **Nota:** El orden del middleware es importante. `UseAuthentication()` debe llamarse antes que `UseAuthorization()`.
    </Info>
  </Step>

  <Step title="Agregar páginas de inicio de sesión y cierre de sesión" stepNumber={5}>
    Cree las páginas de Login y Logout para permitir que los usuarios se autentiquen.

    Primero, cree la carpeta `Pages` y los archivos:

    <Tabs>
      <Tab title="Mac/Linux">
        ```shellscript theme={null}
        mkdir -p Pages && touch Pages/Login.cshtml Pages/Login.cshtml.cs Pages/Logout.cshtml Pages/Logout.cshtml.cs Pages/_ViewImports.razor
        ```
      </Tab>

      <Tab title="Windows (PowerShell)">
        ```powershell theme={null}
        New-Item -ItemType Directory -Force -Path Pages; New-Item -ItemType File -Force -Path Pages/Login.cshtml, Pages/Login.cshtml.cs, Pages/Logout.cshtml, Pages/Logout.cshtml.cs, Pages/_ViewImports.razor
        ```
      </Tab>
    </Tabs>

    Luego, agregue los siguientes fragmentos de código:

    <AuthCodeGroup>
      ```razor Pages/Login.cshtml lines theme={null}
      @page
      @model LoginModel
      ```

      ```csharp Pages/Login.cshtml.cs lines theme={null}
      using Auth0.AspNetCore.Authentication;
      using Microsoft.AspNetCore.Authentication;
      using Microsoft.AspNetCore.Mvc.RazorPages;

      namespace SampleBlazorApp.Pages
      {
          public class LoginModel : PageModel
          {
              public async Task OnGet(string redirectUri = "/")
              {
                  var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
                      .WithRedirectUri(redirectUri)
                      .Build();

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

      ```razor Pages/Logout.cshtml lines theme={null}
      @page
      @using Microsoft.AspNetCore.Authorization
      @attribute [Authorize]
      @model LogoutModel
      ```

      ```csharp Pages/Logout.cshtml.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.RazorPages;

      namespace SampleBlazorApp.Pages
      {
          [Authorize]
          public class LogoutModel : PageModel
          {
              public async Task OnGet()
              {
                  var authenticationProperties = new LogoutAuthenticationPropertiesBuilder()
                      .WithRedirectUri("/")
                      .Build();

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

      ```razor Components/_Imports.razor lines theme={null}
      @using System.Security.Claims
      @using Microsoft.AspNetCore.Authorization
      @using Microsoft.AspNetCore.Components.Authorization
      ```

      ```razor Pages/_ViewImports.razor lines theme={null}
      @using SampleBlazorApp.Pages
      @namespace SampleBlazorApp.Pages
      @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Crear la página de perfil y actualizar el diseño" stepNumber={6}>
    Cree una página personalizada de perfil de usuario para mostrar el nombre y las claims del usuario, y actualice el layout para agregar enlaces de inicio y cierre de sesión.

    Primero, cree el componente Profile:

    <Tabs>
      <Tab title="Mac/Linux">
        ```shellscript theme={null}
        touch Components/Pages/Profile.razor
        ```
      </Tab>

      <Tab title="Windows (PowerShell)">
        ```powershell theme={null}
        New-Item -ItemType File -Force -Path Components/Pages/Profile.razor
        ```
      </Tab>
    </Tabs>

    Agregue los siguientes fragmentos de código. Tenga en cuenta que debe agregar el código de `MainLayout` en la sección superior de su layout, sin modificar el resto del contenido.

    <AuthCodeGroup>
      ```razor Components/Pages/Profile.razor expandable lines theme={null}
      @page "/profile"
      @attribute [Authorize]

      <PageTitle>User Profile</PageTitle>

      <AuthorizeView>
          <Authorized>
              <div class="profile-container">
                  <img src="@context.User.FindFirst("picture")?.Value" 
                       alt="Profile picture" 
                       class="profile-picture" />
                  
                  <h3>Welcome, @context.User.Identity?.Name!</h3>
                  
                  <div class="profile-details">
                      <p><strong>Email:</strong> @context.User.FindFirst("email")?.Value</p>
                      <p><strong>Email Verified:</strong> @context.User.FindFirst("email_verified")?.Value</p>
                      <p><strong>Auth0 User ID:</strong> @context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value</p>
                  </div>

                  <h4>All Claims:</h4>
                  <table class="table">
                      <thead>
                          <tr>
                              <th>Claim Type</th>
                              <th>Claim Value</th>
                          </tr>
                      </thead>
                      <tbody>
                          @foreach (var claim in context.User.Claims)
                          {
                              <tr>
                                  <td>@claim.Type</td>
                                  <td>@claim.Value</td>
                              </tr>
                          }
                      </tbody>
                  </table>
              </div>
          </Authorized>
          <NotAuthorized>
              <p>You must be logged in to view this page.</p>
              <a href="/Login?redirectUri=/profile">Log in</a>
          </NotAuthorized>
      </AuthorizeView>
      ```

      ```razor Components/Layout/MainLayout.razor lines theme={null}
      <div class="top-row px-4">
          <AuthorizeView>
              <NotAuthorized>
                  <a href="/Login">Log in</a>
              </NotAuthorized>
              <Authorized>
                  <span>Hello, @context.User.Identity?.Name!</span>
                  <a href="/Profile">Profile</a>
                  <a href="/Logout">Log out</a>
              </Authorized>
          </AuthorizeView>
      </div>
      ```

      ```razor Components/Routes.razor lines theme={null}
      <CascadingAuthenticationState>
          <Router AppAssembly="typeof(Program).Assembly" NotFoundPage="typeof(Pages.NotFound)">
              <Found Context="routeData">
                  <AuthorizeRouteView RouteData="routeData" DefaultLayout="typeof(Layout.MainLayout)" />
                  <FocusOnNavigate RouteData="routeData" Selector="h1" />
              </Found>
          </Router>
      </CascadingAuthenticationState>
      ```
    </AuthCodeGroup>
  </Step>

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

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

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

    Abra el navegador y vaya a `http://localhost:5000`. Haga clic en el enlace **Login** de la navegación. Se le redirigirá a la página de inicio de sesión de Auth0.
    Después de iniciar sesión, se le redirigirá de nuevo a la aplicación y debería ver su nombre en la navegación.
  </Step>
</Steps>

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

  Ahora debería tener una aplicación de Blazor Server totalmente funcional protegida con Auth0 ejecutándose 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="Personalizar parámetros de inicio de sesión">
  Puedes pasar parámetros personalizados a la página de inicio de sesión de Auth0:

  ```csharp Pages/Login.cshtml.cs theme={null}
  public async Task OnGet(string redirectUri = "/")
  {
      var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
          .WithRedirectUri(redirectUri)
          .WithParameter("screen_hint", "signup")  // Mostrar la página de registro
          .WithParameter("ui_locales", "es")       // Configurar 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 APIs externas en nombre del usuario, puedes obtener 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";
      options.UseRefreshTokens = true;
  });
  ```

  Luego, recupera el token de acceso:

  ```csharp theme={null}
  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();
  ```
</Accordion>

<Accordion title="Configurar organizaciones">
  Configura la compatibilidad con organizaciones para escenarios B2B:

  ```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"];
      options.Organization = builder.Configuration["Auth0:Organization"];
  });
  ```

  O especifica la organización al iniciar sesión:

  ```csharp Pages/Login.cshtml.cs theme={null}
  var authenticationProperties = new LoginAuthenticationPropertiesBuilder()
      .WithOrganization("org_abc123")
      .WithRedirectUri("/")
      .Build();
  ```
</Accordion>

***

<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 que:

    * No haya una barra diagonal al final del valor del dominio
    * Su aplicación tenga acceso a Internet para conectarse a Auth0
    * 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 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 Auth0 con los valores 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="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="sample-application">
  ## Aplicación de ejemplo
</div>

A continuación, se muestra una aplicación de ejemplo que ilustra la integración de Auth0 con ASP.NET Core MVC:

<Card title="Aplicación Blazor de ASP.NET Core" icon="github" href="https://github.com/auth0-samples/auth0-aspnetcore-blazor-server-samples/tree/main/Quickstart/Sample">
  Incluye ejemplos de inicio de sesión, cierre de sesión, perfil de usuario y más.
</Card>

Clona y ejecuta:

```bash theme={null}
git clone https://github.com/auth0-samples/auth0-aspnetcore-blazor-server-samples/tree/main/Quickstart/Sample

# Actualiza appsettings.json con tu configuración de Auth0
dotnet run
```

***