Añade el inicio de sesión a tu aplicación Android con el SDK de Auth0.Android

Usa IA para integrar Auth0

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 minutos usando agent skills.

Instala:

npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-android

Después, pídele a tu asistente de IA:

Add Auth0 authentication to my Android app

Tu asistente de IA creará automáticamente tu aplicación de Auth0, obtendrá las credenciales, añadirá la dependencia del SDK de Auth0 para Android, configurará los marcadores de posición del manifiesto e implementará los flujos de inicio y cierre de sesión. Documentación completa de agent skills →

​

Primeros pasos

1. Crear un proyecto nuevo de Android

   Crea un nuevo proyecto de Android para esta guía de inicio rápido.

   En Android Studio:

   1. File → New → New Project
   2. Selecciona la plantilla Phone and Tablet → Empty Activity
   3. Configura el proyecto:
      • Name: Auth0-Android-Sample
      • Package name: com.auth0.samples.android
      • Language: Kotlin
      • Minimum SDK: API 24 (Android 7.0)
      • Build configuration language: Kotlin DSL
   4. Haz clic en Finish

   Esto crea una aplicación moderna de Android con Kotlin y Gradle Kotlin DSL, siguiendo las prácticas recomendadas actuales del desarrollo para Android.

2. Añade el SDK de Auth0 con Gradle

   Añade el SDK de Auth0 para Android a tu proyecto con Gradle.

   Actualiza el archivo build.gradle.kts de tu aplicación:

   app/build.gradle.kts

   dependencies {   
       // SDK de Auth0
       implementation("com.auth0.android:auth0:3.14.0")
   }
   

   Agrega los marcadores de posición del manifiesto en el build.gradle.kts de tu aplicación:

   app/build.gradle.kts

   android {
       defaultConfig {
           // Agrega estos marcadores de posición del manifiesto
           manifestPlaceholders += mapOf(
               "auth0Domain" to "@string/com_auth0_domain", // esto se configurará en el siguiente paso
               "auth0Scheme" to "https"
           )
       }
   }
   
   

   Añade el permiso de acceso a Internet a AndroidManifest.xml:

   app/src/main/AndroidManifest.xml

   <?xml version="1.0" encoding="utf-8"?>
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools">
       <uses-permission android:name="android.permission.INTERNET" />
   </manifest>
   

   El SDK de Auth0 gestiona automáticamente la resolución de dependencias e incluye almacenamiento seguro de tokens.

3. Configura tu aplicación de Auth0

   A continuación, debes crear una nueva aplicación en tu tenant de Auth0 y añadir la configuración a tu proyecto Android.

   Primero, prepara el archivo app/src/main/res/values/strings.xml con valores de marcador de posición:

   app/src/main/res/values/strings.xml

   <?xml version="1.0" encoding="utf-8"?>
   <resources>
       <string name="com_auth0_domain">{yourDomain}</string>
       <string name="com_auth0_client_id">YOUR_AUTH0_CLIENT_ID</string>
       <string name="com_auth0_scheme">https</string>
   </resources>
   

   1. Ve al Auth0 Dashboard
   2. Haz clic en Applications > Applications > Create Application
   3. En la ventana emergente, introduce un nombre para tu aplicación, selecciona Native como tipo de aplicación y haz clic en Create
   4. Ve a la pestaña Settings en la página de detalles de la aplicación
   5. Sustituye {yourDomain} y YOUR_AUTH0_CLIENT_ID en el archivo strings.xml por los valores de Domain y Client ID del panel

   Por último, en la pestaña Settings de la página de detalles de tu aplicación, configura las siguientes URL:

   Allowed Callback URLs:

   https://{yourDomain}/android/PACKAGE_NAME/callback
   

   URL de cierre de sesión permitidas:

   https://{yourDomain}/android/PACKAGE_NAME/callback
   

   Sustituye {yourDomain} por tu dominio real de Auth0 (por ejemplo, dev-abc123.us.auth0.com).

   Las Allowed Callback URLs son una medida de seguridad fundamental para garantizar que, tras la autenticación, los usuarios vuelvan de forma segura a tu aplicación. Si no hay una URL que coincida, el proceso de inicio de sesión fallará y los usuarios verán una página de error de Auth0 en lugar de acceder a tu aplicación.

   Las Allowed Logout URLs son esenciales para ofrecer una experiencia fluida al cerrar sesión. Si no hay una URL que coincida, los usuarios no serán redirigidos de vuelta a tu aplicación al cerrar sesión y, en su lugar, permanecerán en una página genérica de Auth0.

   El esquema de la URL incluye el nombre de tu paquete (com.auth0.samples.android) para garantizar que el callback se dirija a tu aplicación concreta.

   Importante: Asegúrate de que el nombre del paquete en tus URL de callback coincida con tu applicationId en build.gradle.kts. Si la autenticación falla, comprueba que estos valores sean idénticos.

   Al usar el esquema https (como se configuró antes), debes configurar Android App Links para que Android dirija la URL de callback directamente a tu aplicación en lugar de abrirla en el navegador. Consulta la sección Configurar Android App Links en Resolución de problemas y opciones avanzadas más abajo.

4. Inicializar el SDK de Auth0

   Crea una instancia de Auth0 en tu Activity para poder comunicarte con Auth0.

   En tu MainActivity.kt:

   MainActivity.kt

   import com.auth0.android.Auth0
   import com.auth0.android.authentication.AuthenticationException
   import com.auth0.android.callback.Callback
   import com.auth0.android.provider.WebAuthProvider
   import com.auth0.android.result.Credentials
   
   class MainActivity : ComponentActivity() {
       private lateinit var auth0: Auth0
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           
           // Inicializar Auth0
           auth0 = Auth0.getInstance(
               getString(R.string.com_auth0_client_id),
               getString(R.string.com_auth0_domain)
           )
       }
   }
   

   La instancia de Auth0 se inicializa con tu ID de cliente y el dominio del archivo strings.xml que configuraste anteriormente. Esta instancia se utilizará para todas las operaciones de autenticación.

5. Implementar el inicio y el cierre de sesión

   Implementa el inicio de sesión: Usa WebAuthProvider para abrir la página universal de inicio de sesión.

   Agrega estos métodos a tu MainActivity:

   Callback de Kotlin

   MainActivity.kt

   private fun login() {
       WebAuthProvider.login(auth0)
           .withScheme("https")
           .withScope("openid profile email offline_access")
           .start(this, object : Callback<Credentials, AuthenticationException> {
               override fun onSuccess(credentials: Credentials) {
                   // Guarda las credenciales
                   // El usuario está autenticado
               }
   
               override fun onFailure(exception: AuthenticationException) {
                   // Gestiona los casos de error
               }
           })
   }
   

   Corrutina

   MainActivity.kt

   private fun login() {
       lifecycleScope.launch {
           try {
               val credentials = WebAuthProvider.login(auth0)
                   .withScheme("https")
                   .withScope("openid profile email offline_access")
                   .await(this@MainActivity)
               // Guarda las credenciales
               // El usuario está autenticado
           } catch (exception: AuthenticationException) {
               // Gestiona el error
           }
       }
   }
   

   Implementa el cierre de sesión: Usa WebAuthProvider para cerrar la sesión del usuario.

   Callback de Kotlin

   MainActivity.kt

   private fun logout() {
       WebAuthProvider.logout(auth0)
           .withScheme("https")
           .start(this, object : Callback<Void?, AuthenticationException> {
               override fun onSuccess(result: Void?) {
                   // Borra las credenciales guardadas
                   // El usuario ha cerrado sesión
               }
   
               override fun onFailure(exception: AuthenticationException) {
                   // Gestiona el error
               }
           })
   }
   

   Corrutina

   MainActivity.kt

   private fun logout() {
       lifecycleScope.launch {
           try {
               WebAuthProvider.logout(auth0)
                   .withScheme("https")
                   .await(this@MainActivity)
               // Borra las credenciales guardadas
               // El usuario ha cerrado sesión
           } catch (exception: AuthenticationException) {
               // Gestiona el error
           }
       }
   }
   

   Los métodos login() y logout() deben llamarse cuando el usuario pulse los botones correspondientes en tu interfaz. El código usa this (en referencia a la Activity) como parámetro de contexto, lo cual es necesario para que WebAuthProvider abra Chrome Custom Tabs y gestione el flujo de autenticación.

6. Ejecuta tu aplicación

   Compila y ejecuta tu aplicación para Android.

   En Android Studio:

   # Sincronizar el proyecto con los archivos de Gradle (o usar "Sync Now" en Android Studio)
   ./gradlew clean build
   
   # Compilar e instalar en el dispositivo conectado o en el emulador
   ./gradlew installDebug
   
   # O ejecutar directamente desde Android Studio
   # Hacer clic en el botón "Run" o pulsar Shift+F10
   

   Flujo esperado:

   1. La app se abre con el botón “Iniciar sesión” y el ícono de escudo
   2. Toca “Iniciar sesión” → se abre una pestaña personalizada de Chrome → completa el inicio de sesión
   3. Vuelve a la app automáticamente
   4. ¡Éxito!

   Android mostrará un cuadro de selección de navegador si hay varios navegadores instalados. Las pestañas personalizadas de Chrome ofrecen la mejor experiencia de usuario para la autenticación con Auth0.

Punto de control

Ahora deberías tener una experiencia de inicio de sesión con Auth0 totalmente funcional ejecutándose en tu dispositivo Android o emulador. La aplicación usa Chrome Custom Tabs para ofrecer una autenticación segura y almacena automáticamente las credenciales.

---

​

Solución de problemas y opciones avanzadas

Problemas comunes y soluciones

​

Chrome Custom Tab no redirige de vuelta a la app

Soluciones:

1. Comprueba que las Allowed Callback URLs del Auth0 Dashboard coincidan exactamente con tu applicationId
2. Verifica que los marcadores de posición del manifiesto en build.gradle.kts sean correctos
3. Asegúrate de tener configuradas tanto las URL https como las URL con esquema personalizado
4. Limpia y recompila: Build → Clean Project → Rebuild Project

​

La app se cierra: ‘Auth0 domain not found’

Solución:

1. Comprueba que los valores de com_auth0_domain y com_auth0_client_id sean correctos
2. Asegúrate de que no haya errores tipográficos en el formato del dominio (no debe incluir https://)

​

Errores de compilación con dependencias

Solución:

1. Actualiza a la versión más reciente del Android Gradle Plugin en build.gradle (nivel de proyecto)
2. Sincroniza el proyecto: File → Sync Project with Gradle Files
3. Limpia la compilación: ./gradlew clean build

​

Autenticación cancelada por el usuario

Manéjalo correctamente en tu callback de error:

override fun onFailure(exception: AuthenticationException) {
    when {
        exception.isAuthenticationCanceled -> 
            showMessage("Login was cancelled")
        exception.isBrowserAppNotAvailable -> 
            showMessage("No browser available")
        else -> 
            showMessage("Login failed: ${exception.getDescription()}")
    }
}

​

Error de navegador no compatible

• Instala Chrome u otro navegador moderno en tu dispositivo o emulador
• Habilita Chrome Custom Tabs para mejorar la experiencia de usuario
• Haz pruebas en un dispositivo real con Chrome instalado

Configurar Android App Links

Android App Links permiten que tu app se establezca como el controlador predeterminado para las URL de callback de Auth0, lo que proporciona una experiencia de autenticación más segura y fluida. Sin App Links, Android puede mostrar un cuadro de diálogo de desambiguación para que el usuario elija entre tu app y un navegador.

App Links usa callbacks verificados con el esquema https. Esto es más seguro que los esquemas de URL personalizados, que pueden estar sujetos a ataques de suplantación de cliente.

​

Obtén la huella digital de tu certificado de firma

Necesitas la huella digital SHA256 del certificado de firma de tu app. Ejecuta el siguiente comando en tu terminal:

# Para compilaciones de depuración
keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

# Para compilaciones de lanzamiento
keytool -list -v -keystore my-release-key.keystore

Copia el valor de la huella digital SHA256 de la salida.

​

Configurar en el Auth0 Dashboard

1. Ve a Auth0 Dashboard > Applications > Applications y selecciona tu aplicación
2. Desplázate hasta la parte inferior de la página Settings y selecciona Show Advanced Settings
3. Selecciona la pestaña Device Settings
4. En Android, proporciona:
   • App Package Name: Tu applicationId (por ejemplo, com.auth0.samples.android)
   • SHA256 Cert Fingerprints: La huella digital que copiaste antes
5. Haz clic en Save Changes

​

Verifica la configuración

Auth0 genera automáticamente el archivo assetlinks.json que Android usa para verificar tu app. Pruébalo navegando a:

https://{yourDomain}/.well-known/assetlinks.json

Deberías ver una respuesta JSON que contiene el nombre de tu paquete y la huella digital del certificado:

[{
  "relation": ["delegate_permission/common.handle_all_urls"],
  "target": {
    "namespace": "android_app",
    "package_name": "[YOUR_PACKAGE_NAME]",
    "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"]
  }
}]

La guía de inicio rápido ya usa https como esquema en los marcadores de posición del manifiesto y en las llamadas a WebAuthProvider, lo cual es necesario para App Links. No hace falta cambiar el código si seguiste los pasos anteriores.

Para obtener más información, consulta la documentación de Enable Android App Links Support y la guía de Android Verify App Links.

Usa un esquema de URL personalizado

Si no puedes usar Android App Links (por ejemplo, si trabajas con versiones de la API de Android anteriores a la 23), puedes configurar un esquema de URL personalizado en su lugar.

Los esquemas de URL personalizados son menos seguros que App Links porque pueden ser vulnerables a ataques de suplantación del cliente. Usa App Links siempre que sea posible.

1. Actualiza el marcador de posición del manifiesto auth0Scheme en tu app/build.gradle.kts:

app/build.gradle.kts

android {
    defaultConfig {
        manifestPlaceholders += mapOf(
            "auth0Domain" to "@string/com_auth0_domain",
            "auth0Scheme" to "myapp" // Usa un esquema personalizado único
        )
    }
}

2. Actualiza las Allowed Callback URLs y Allowed Logout URLs en la configuración de tu aplicación en el Auth0 Dashboard para usar el esquema personalizado:

myapp://{yourDomain}/android/PACKAGE_NAME/callback

3. Pasa el esquema personalizado al llamar a WebAuthProvider:

MainActivity.kt

WebAuthProvider.login(auth0)
    .withScheme("myapp")
    .withScope("openid profile email offline_access")
    .start(this, callback)

Los esquemas personalizados solo pueden contener letras minúsculas.

Despliegue en producción

​

Preparación para la tienda de aplicaciones

• Configura Android App Links para una autenticación sin fricciones
• Haz pruebas en varias versiones de Android y tamaños de pantalla
• Implementa un manejo adecuado de errores para fallos de red
• Añade reglas de ProGuard para el SDK de Auth0 si usas ofuscación de código
• Sigue las políticas de Google Play Store para los flujos de autenticación

​

Consideraciones de seguridad

• Usa SecureCredentialsManager para almacenar credenciales en producción
• Implementa certificate pinning para reforzar la seguridad de la API
• Considera usar Android Keystore para una mayor protección de las credenciales
• Habilita la autenticación biométrica para operaciones sensibles

Integración avanzada de Android

​

Seguridad reforzada de las credenciales

Implementa autenticación biométrica para acceder a las credenciales:

AuthenticationManager.kt

class AuthenticationManager(private val context: Context) {
    
    private val credentialsManager: SecureCredentialsManager
    
    init {
        val authentication = AuthenticationAPIClient(auth0)
        val storage = SharedPreferencesStorage(context)
        credentialsManager = SecureCredentialsManager(context, authentication, storage)
        
        // Habilitar autenticación biométrica
        credentialsManager.requireAuthentication(
            context as FragmentActivity,
            REQUEST_CODE_BIOMETRIC,
            "Autenticación biométrica",
            "Autentícate para acceder a tu cuenta"
        )
    }
    
    companion object {
        private const val REQUEST_CODE_BIOMETRIC = 321
    }
}

​

Scopes y audience personalizados

Solicita scopes y audience específicos para tu API:

AuthenticationManager.kt

fun login() {
    WebAuthProvider.login(auth0)
        .withScheme("https")
        .withScope("openid profile email offline_access read:posts")
        .withAudience("https://myapi.example.com")
        .withParameter("prompt", "login")
        .start(context as MainActivity, loginCallback)
}

​

Configuración de red

Gestiona la seguridad de red y el certificate pinning:

app/src/main/res/xml/network_security_config.xml

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <domain-config>
        <domain includeSubdomains="true">your-auth0-domain.auth0.com</domain>
        <pin-set>
            <pin digest="SHA-256">AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</pin>
        </pin-set>
    </domain-config>
</network-security-config>

Añádelo a AndroidManifest.xml:

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ... />