Agrega Login a tu aplicación iOS o macOS con el SDK de Auth0.swift

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 cuestión de minutos con agent skills.

Instala:

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

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

Add Auth0 authentication to my iOS app

Tu asistente de IA creará automáticamente tu aplicación de Auth0, obtendrá las credenciales, añadirá la dependencia del SDK Auth0.swift, configurará Auth0.plist, establecerá las URL de callback e implementará los flujos de login y Logout. Documentación completa de agent skills →

​

Primeros pasos

1. Crear un proyecto nuevo

   Cree un nuevo proyecto de iOS o macOS para este inicio rápido.

   En Xcode:

   1. File → New → Project (o ⌘+Mayús+N)
   2. Seleccione una de estas opciones:
      • Pestaña iOS → plantilla App
      • Pestaña macOS → plantilla App
   3. Configure el proyecto:
      • Product Name: Auth0-Sample
      • Interface: SwiftUI
      • Language: Swift
      • Use Core Data: Desactivado
      • Include Tests: Activado (recomendado)
   4. Elija una ubicación y haga clic en Create

   Esto crea una aplicación estándar con soporte para SwiftUI y Swift Package Manager, ideal para integrar Auth0.

2. Agrega el SDK de Auth0

   Agrega el SDK de Auth0 a tu proyecto con el gestor de paquetes que prefieras.

   Swift Package Manager

   En Xcode:

   1. File → Add Package Dependencies… (o ⌘+Shift+K)
   2. Ingresa la URL del SDK de Auth0:
      https://github.com/auth0/Auth0.swift
      
   3. Add Package → Selecciona el target de tu app → Add Package

   CocoaPods

   1. Crea un Podfile en el directorio de tu proyecto:
      Podfile

      platform :ios, '14.0' # O platform :osx, '11.0' para macOS
      use_frameworks!
      
      target 'YourApp' do
        pod 'Auth0', '~> 2.0'
      end
      
   2. Instala las dependencias:
      pod install
      
   3. Abre el archivo .xcworkspace generado (no el .xcodeproj)

   Carthage

   1. Crea un Cartfile en el directorio de tu proyecto:
      Cartfile

      github "auth0/Auth0.swift" ~> 2.0
      
   2. Ejecuta Carthage:
      carthage update --platform iOS --use-xcframeworks
      
      Para macOS, usa --platform macOS
   3. Arrastra el Auth0.xcframework generado desde Carthage/Build a tu proyecto de Xcode
   4. En la configuración General de tu target, agrega Auth0.xcframework a Frameworks, Libraries, and Embedded Content
3. Configurar Auth0

   Cree una nueva aplicación en Auth0 y configure las URL de callback.

   1. Vaya a Auth0 Dashboard
   2. Applications > Create Application > Asígnele un nombre, seleccione Native > Create
   3. En la pestaña Settings, anote su ID de cliente y dominio
   4. Agregue las siguientes URL a Allowed Callback URLs:

   iOS

   https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
   

   macOS

   https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
   

   5. Agregue las siguientes URL a Allowed Logout URLs:

   iOS

   https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
   

   macOS

   https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
   

   6. Haga clic en Save Changes
4. Configurar las credenciales de la aplicación

   Crea Auth0.plist en el directorio del proyecto:

   Auth0.plist

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
   <plist version="1.0">
   <dict>
       <key>ClientId</key>
       <string>YOUR_AUTH0_CLIENT_ID</string>
       <key>Domain</key>
       <string>{yourDomain}</string>
   </dict>
   </plist>
   

   Arrastra Auth0.plist a Xcode y asegúrate de que la opción “Add to target” esté seleccionada.

5. Crear el servicio de autenticación

   Cree AuthenticationService.swift:

   1. Haga clic derecho en su proyecto → New File… → Swift File
   2. Asígnele el nombre AuthenticationService
   3. Reemplace el contenido con:

   AuthenticationService.swift

   import Foundation
   import Auth0
   import Combine
   
   @MainActor
   class AuthenticationService: ObservableObject {
       @Published var isAuthenticated = false
       @Published var user: User?
       @Published var isLoading = false
       @Published var errorMessage: String?
       
       private let credentialsManager = CredentialsManager(authentication: Auth0.authentication())
       
       init() {
           Task {
               await checkAuthenticationStatus()
           }
       }
       
       private func checkAuthenticationStatus() async {
           isLoading = true
           defer { isLoading = false }
           
           guard let credentials = try? await credentialsManager.credentials() else {
               isAuthenticated = false
               return
           }
           
           isAuthenticated = true
           // Obtener información del usuario desde el token de ID
           user = credentials.user
       }
       
       func login() async {
           isLoading = true
           errorMessage = nil
           defer { isLoading = false }
           
           do {
               let credentials = try await Auth0
                   .webAuth()
                   .scope("openid profile email offline_access")
                   .start()
               
               _ = credentialsManager.store(credentials: credentials)
               isAuthenticated = true
               // Get user info from the ID token
               user = credentials.user
           } catch {
               errorMessage = "Login failed: \(error.localizedDescription)"
           }
       }
       
       func logout() async {
           isLoading = true
           defer { isLoading = false }
           
           do {
               try await Auth0
                 .webAuth()
                 .clearSession()
               _ = credentialsManager.clear()
               isAuthenticated = false
               user = nil
           } catch {
               errorMessage = "Logout failed: \(error.localizedDescription)"
           }
       }
   }
   
6. Configurar el flujo de autenticación (opcional)

   Para mejorar la experiencia del usuario, puede minimizar las alertas del sistema de las siguientes maneras:

   1. Use Universal Links: esto elimina el mensaje ‘¿Abrir en “AppName”?’ que aparece durante la redirección. Nota: la alerta de permiso de ASWebAuthenticationSession seguirá apareciendo.
   2. Use sesiones efímeras: esto elimina todas las alertas de permiso. Nota: esto desactiva el inicio de sesión único (SSO) y las cookies compartidas.

   Omita este paso para usar el comportamiento predeterminado con una alerta de permiso. Puede configurarlo más adelante.

   Universal Links

   1. Auth0 Dashboard → Applications → Su aplicación → Settings → Advanced Settings → Device Settings
   2. Agregue Apple Team ID y bundle identifier → Save
   3. Xcode: Target → Signing & Capabilities → + Capability → Associated Domains
   4. Agregue: webcredentials:{yourDomain}

   Requiere: una cuenta de pago de Apple Developer, iOS 17.4+/macOS 14.4+

   Ideal para aplicaciones en producción.

   Sesión efímera

   Agregue .useEphemeralSession() a la llamada de Login en AuthenticationService.swift:

   // En la función login()
   let credentials = try await Auth0
       .webAuth()
       .scope("openid profile email offline_access")
       .useEphemeralSession()
       .start()
   

   Al usar sesiones efímeras, no necesita llamar a clearSession() al cerrar sesión. Solo borre las credenciales de su aplicación; no hay ninguna cookie compartida que eliminar.

   Configuración rápida, sin alertas, pero los usuarios deben iniciar sesión cada vez (sin SSO).

7. Ejecuta la aplicación

   Presiona ⌘+R en Xcode.

   1. Toca “Iniciar sesión” → Alerta de permisos (si usas la configuración predeterminada) → Toca “Continuar”
   2. Completa el inicio de sesión en el navegador
   3. ¡Verás tu perfil!

Punto de control

¡Ya tienes un inicio de sesión con Auth0 totalmente funcional en tu aplicación para iOS o macOS!

---

​

Solución de problemas y opciones avanzadas

Problemas comunes y soluciones

​

Errores de compilación: no se encuentra el módulo ‘Auth0’

Soluciones:

1. Swift Package Manager: Revisa Package Dependencies → Verifica que Auth0.swift figure en la lista
2. CocoaPods: Asegúrate de abrir el archivo .xcworkspace, no .xcodeproj
3. Carthage: Verifica que Auth0.xcframework esté agregado en Frameworks, Libraries, and Embedded Content
4. Limpia y vuelve a compilar: ⌘+Shift+K y luego ⌘+R
5. Reinicia Xcode si es necesario

​

La app se cierra: ‘Auth0.plist not found’

Solución:

1. Verifica que Auth0.plist esté en el navegador del proyecto de Xcode
2. Selecciona el archivo → Inspector → Asegúrate de que el target de tu app esté marcado
3. Confirma que tenga las claves ClientId y Domain con tus valores
4. Alternativa: Usa configuración programática (consulta la sección de integración avanzada a continuación)

​

El navegador se abre, pero nunca regresa a la app

Solución:

1. Comprueba que las URL de callback en Auth0 Dashboard coincidan exactamente con tu identificador de paquete y la plataforma
2. Para iOS: las URL deben contener /ios/; para macOS: /macos/
3. Verifica que el identificador de paquete en Xcode coincida con la configuración de Auth0
4. Asegúrate de que no haya errores tipográficos en las URL (los más comunes: dos puntos faltantes o formato de dominio incorrecto)
5. Si usas un dominio personalizado: Verifica que estés usando tu dominio personalizado, no el dominio de Auth0

​

La alerta de permisos aparece cada vez

Este es el comportamiento de seguridad estándar de iOS/macOS al usar esquemas de URL personalizados. Consulta el Paso 6 para eliminar esta alerta usando Universal Links o Ephemeral Sessions.

Configuración de dominio personalizado

Si usas un dominio personalizado, usa ese valor en lugar de tu dominio de Auth0 en todas partes.

Ejemplo: Usa login.example.com en lugar de tenant.auth0.com

Esto es necesario para que ciertas funciones funcionen correctamente:

• Actualiza Auth0.plist con tu dominio personalizado
• Usa el dominio personalizado en las URL de callback/logout
• Para Universal Links, usa: webcredentials:login.example.com

Implementación en producción

​

Preparación para App Store

• Configura Universal Links para eliminar la alerta de permisos
• Haz pruebas en varias versiones de la plataforma y tamaños de dispositivo
• Implementa un manejo de errores adecuado para fallos de red
• Agrega descripciones de uso de privacidad si usas Keychain con biometría
• Sigue las directrices de revisión de App Store para los flujos de autenticación

​

Prácticas recomendadas de seguridad

• Nunca registres datos de autenticación sensibles en producción
• Implementa el cumplimiento de App Transport Security (ATS)
• Usa HTTPS para todas las solicitudes de red
• NO fijes certificados de la API de Auth0: Auth0 no recomienda esta práctica

​

Optimización del rendimiento

• Todas las operaciones asíncronas usan correctamente @MainActor para actualizar la UI
• Las propiedades @Published usan un manejo de memoria adecuado
• Las credenciales se almacenan en caché de forma segura en el Keychain para acceso sin conexión
• El perfil de usuario se obtiene del token de ID (sin ninguna solicitud de red adicional)

Integración avanzada

​

Configuración programática

En lugar de usar Auth0.plist, puedes pasar las credenciales directamente en el código. Esto es útil cuando las credenciales deben ser dinámicas o específicas del entorno (p. ej., distintos inquilinos de Auth0 para desarrollo/preproducción/producción).

Sustituye las llamadas a Auth0.webAuth() por Auth0.webAuth(clientId:domain:):

// En AuthenticationService.swift - función de login
func login() async {
    isLoading = true
    errorMessage = nil
    defer { isLoading = false }
    
    do {
        let credentials = try await Auth0
            .webAuth(clientId: "{yourClientId}", domain: "{yourDomain}")
            .scope("openid profile email offline_access")
            .start()
        
        _ = credentialsManager.store(credentials: credentials)
        isAuthenticated = true
        user = credentials.user
    } catch {
        errorMessage = "Login failed: \(error.localizedDescription)"
    }
}

// En AuthenticationService.swift - función de logout
func logout() async {
    isLoading = true
    defer { isLoading = false }
    
    do {
        try await Auth0.webAuth(clientId: "{yourClientId}", domain: "{yourDomain}").clearSession()
        _ = credentialsManager.clear()
        isAuthenticated = false
        user = nil
    } catch {
        errorMessage = "Logout failed: \(error.localizedDescription)"
    }
}

​

Seguridad reforzada de Keychain con biometría

Exige Face ID o Touch ID para acceder a las credenciales almacenadas:

private let credentialsManager: CredentialsManager = {
    let manager = CredentialsManager(authentication: Auth0.authentication())
    manager.enableBiometrics(
        withTitle: "Unlock with Face ID", 
        cancelTitle: "Cancel", 
        fallbackTitle: "Use Passcode"
    )
    return manager
}()

Cuando está habilitado, los usuarios deben autenticarse con biometría antes de que el SDK pueda recuperar las credenciales almacenadas.

​

Renovación automática de tokens

CredentialsManager renueva automáticamente los tokens de acceso caducados:

// Obtener credenciales: se renuevan automáticamente si han caducado
func getAccessToken() async throws -> String {
    let credentials = try await credentialsManager.credentials()
    return credentials.accessToken
}

Usa este patrón al hacer llamadas a la API que requieran un token de acceso.

​

Credenciales compartidas entre extensiones de la app

Para widgets, extensiones de la app o tareas en segundo plano que necesiten tokens de acceso:

// Crear un administrador de credenciales compartidas con un grupo de apps
let credentialsManager = CredentialsManager(
    authentication: Auth0.authentication(),
    storeKey: "credentials",
    storage: .shared(withIdentifier: "group.com.example.myapp")
)

Requisitos:

1. Habilita la capacidad App Groups en Xcode para todos los targets
2. Usa el mismo identificador de grupo de apps en todos los targets
3. Configura el CredentialsManager compartido en cada target

​

Comparación de opciones del flujo de autenticación

Característica	Universal Links	Sesión efímera	Por defecto (alerta)
Alerta de permisos	Reducida (sin aviso de redirección)	Ninguna	Muestra todas las alertas
Compatibilidad con SSO	Sí	No	Sí
Cuenta de desarrollador de Apple	Obligatoria	No obligatoria	No obligatoria
Experiencia de usuario	Mejor	Buena	Aceptable
Complejidad de configuración	Media	Fácil	Fácil
Compatibilidad con navegación privada	Sí	Sí	No

Recomendaciones:

• Apps de producción con SSO: Universal Links (mejor UX, compatibilidad con SSO, requiere una cuenta de desarrollador de Apple)
• Apps de producción sin SSO: Sesiones efímeras (sin alertas, configuración más sencilla)
• Pruebas/desarrollo: Sesiones efímeras (configuración rápida, UX más limpia)
• Inicio rápido/prototipado: Opción predeterminada con alertas (sin configuración, puedes migrar más adelante)