DocumentazioneJourney OptimizerGuida di Journey Optimizer

Utilizzare e configurare i collegamenti profondi nelle e-mail e negli SMS deeplinks

Ultimo aggiornamento: 8 settembre 2026

Creato per:

  • Intermediate
  • User
  • Developer

In questa pagina: scopri come creare collegamenti profondi in contenuti e-mail e SMS, configurarli in Adobe Journey Optimizer e gestire i collegamenti tracciati nelle app iOS e Android in modo che i destinatari arrivino alla schermata in-app corretta.

style
shade-box

I collegamenti profondi consentono di portare i destinatari da un messaggio e-mail o SMS a una schermata o a un contenuto specifico nell’app mobile. Aiuta a portare le persone direttamente all’esperienza in-app prevista, senza indirizzarle tramite un browser web o un app store, in modo che il percorso rimanga rilevante e sul marchio.

Quando i destinatari fanno clic sul collegamento profondo, vengono indirizzati direttamente al contenuto in-app desiderato - a condizione che tu abbia completato:

NOTE
Adobe Journey Optimizer supporta il deep linking per iOS e Android utilizzando URL tracciati (/ee/v1/mclick/*) per garantire la compatibilità e il tracciamento dei clic.

Creazione di collegamenti profondi authoring

CAUTION
I collegamenti profondi non funzioneranno se non avrai completato i passaggi configurazione e implementazione app mobile in questa pagina.

E-mail authoring-email

Per i messaggi e-mail, puoi inserire un collegamento profondo in due modi:

  • Invia un’e-mail a Designer: assicurati che il tracciamento dei collegamenti sia abilitato. Seleziona l’elemento da collegare (testo, pulsante o immagine), fai clic su Inserisci collegamento nella barra degli strumenti contestuale e scegli Collegamento diretto per immettere l’URL del collegamento diretto. Ulteriori informazioni sull’inserimento di collegamenti

  • Editor Personalization (codice): inserisci il collegamento profondo direttamente in HTML utilizzando lo snippet seguente:

    code language-html 
    <a class="arc-link" data-nl-type="DEEPLINK" href="<<deeplink_url>>" id="acr-link-7821368" style="text-decoration:underline;" target="_blank" data-tracking-type="DEEPLINK">Click Here</a>
    note tip
    TIP
    Sostituisci <<deeplink_url>> con l'URL del collegamento profondo effettivo e utilizza un id univoco per ogni blocco per evitare conflitti.

SMS authoring-sms

Per gli SMS, i collegamenti profondi vengono creati utilizzando la funzione helper Url nell’editor di personalizzazione. Scopri come aggiungere collegamenti al contenuto SMS in questa sezione.

Per inserire collegamenti profondi nel contenuto degli SMS, utilizza la sintassi seguente:

{{url originalUrl='<<url>>' type='DEEPLINK' action='CLICK'}}
TIP
Sostituisci <<url>> con il tuo URL di collegamento profondo effettivo.

Configurazione in Journey Optimizer configuration

Per poter utilizzare i collegamenti profondi nelle e-mail e negli SMS per le app mobili, completa i passaggi di configurazione riportati di seguito.

NOTE
Questa sezione si applica quando si utilizzano collegamenti universali (iOS) e collegamenti alle app (Android) (collegamenti profondi basati su HTTPS).

  1. In Journey Optimizer, delega il sottodominio in cui è abilitato il collegamento profondo. Ulteriori informazioni

  2. Ospita il file AASA per iOS e il file assetLinks.json per Android sul tuo sottodominio. Contatta l’Assistenza clienti Adobe o il tuo rappresentante Adobe con i dettagli seguenti:

    • Per iOS (AASA):

      • Sottodominio delegato
      • ID bundle dell’app

    • Per Android (assetLinks.json):

      • Sottodominio delegato
      • ID bundle dell’app
      • Impronta digitale del certificato SHA-256
IMPORTANT
I collegamenti profondi tramite l'infrastruttura Adobe si applicano quando il tracciamento dei collegamenti è abilitato per il messaggio, nelleimpostazioni di tracciamento e-mail o nella sezione Tracciamento azioni per le campagne SMS. I clic di collegamento profondo tracciati utilizzano gli URL in /ee/v1/mclick/*, che Adobe ospita e risolve.
Per collegamenti non tracciati, l'URL non viene riscritto tramite i sistemi Adobe. Devi configurare i collegamenti universali o i collegamenti alle app sui tuoi domini e hosting in modo che tali collegamenti aprano l’app come previsto.

Implementazione di un’app mobile mobile-implementation

Questa sezione spiega come implementare i collegamenti profondi per dispositivi mobili con Adobe Journey Optimizer in modo che, in una configurazione tipica di HTTPS (collegamenti universali e collegamenti alle app), un singolo URL possa:

  • Apri una schermata specifica all’interno dell’app mobile quando questa è installata, oppure
  • Apri il sito web come fallback quando l’app non è installata.

Quando il tracciamento dei collegamenti è abilitato per il messaggio, Journey Optimizer continua a tenere traccia di questi clic, li include nel reporting e può utilizzarli in esperimenti di contenuto se vengono eseguiti sul messaggio.

Questa sezione fornisce modelli di implementazione comuni per i collegamenti profondi. La configurazione esatta dipende dall’architettura dell’app e dal framework di routing.

iOS (collegamenti universali) ios-implementation

  1. In Xcode, seleziona la destinazione tramite Firma e funzionalità > + funzionalità > Domini associati.

  2. Aggiungi voci per i sottodomini delegati, ad esempio:

    code language-text 
    applinks:www.mybusiness.com
applinks:data.email.mybusiness.com

  3. Gestisci i collegamenti universali nell’app e ottieni il collegamento originale dall’intestazione di risposta.

    accordion
    Esempio: iOS 13+ con scene
    code language-swift 
    class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    func scene(_ scene: UIScene,
              continue userActivity: NSUserActivity) {
        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
              let incomingURL = userActivity.webpageURL else {
            return
        }

        handleUniversalLink(url: incomingURL)
    }

    private func handleUniversalLink(url: URL) {
        // Only handle AJO tracked mobile clicks
        guard url.host == "data.email.mybusiness.com",
              url.path.hasPrefix("/ee/v1/mclick") else {
            // Could also handle direct www.mybusiness.com links here
            return
        }

        resolveTrackedUrlAndRoute(url)
    }

    private func resolveTrackedUrlAndRoute(_ trackedUrl: URL) {
        var request = URLRequest(url: trackedUrl)
        request.httpMethod = "GET"

        URLSession.shared.dataTask(with: request) { _, response, error in
            guard error == nil,
                  let httpResponse = response as? HTTPURLResponse,
                  let locationValue = httpResponse.allHeaderFields["Location"] as? String,
                  let finalUrl = URL(string: locationValue) else {
                return
            }

            DispatchQueue.main.async {
                self.routeToDestination(finalUrl)
            }
        }.resume()
    }

    private func routeToDestination(_ url: URL) {
        // Example: map URL paths to screens
        // https://www.mybusiness.com/dashboard/offers/coupons
        // → OffersViewController for Coupons
    }
}
IMPORTANT
L'app deve eseguire un GET sull'URL mclick e leggere l'intestazione Location, quindi instradare in base all'URL final.
Non aprire semplicemente l'URL mclick in Safari; in questo modo si vanifica lo scopo dei collegamenti profondi.

Android (collegamenti alle app) android-implementation

  1. Aggiungi il filtro delle finalità del collegamento all’app nell’app Android.

    code language-xml 
    <activity
    android:name=".DeepLinkActivity"
    android:exported="true">

    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <data
            android:scheme="https"
            android:host="data.email.mybusiness.com"
            android:pathPrefix="/ee/v1/mclick" />
    </intent-filter>

</activity>

  2. Implementa il gestore di collegamenti profondi.

    accordion
    A Cotlino:
    code language-kotlin 
    class DeepLinkActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val trackedUri = intent?.data
        if (trackedUri == null ||
            trackedUri.host != "data.email.mybusiness.com" ||
            !trackedUri.path.orEmpty().startsWith("/ee/v1/mclick")) {
            finish()
            return
        }

        resolveTrackedUrlAndRoute(trackedUri)
    }

    private fun resolveTrackedUrlAndRoute(trackedUri: Uri) {
        lifecycleScope.launch(Dispatchers.IO) {
            try {
                val finalUrl = followRedirect(trackedUri.toString())
                withContext(Dispatchers.Main) {
                    routeToDestination(finalUrl)
                    finish()
                }
            } catch (e: Exception) {
                // Optionally log error, fallback to browser
                finish()
            }
        }
    }

    private fun followRedirect(trackedUrl: String): Uri {
        val client = OkHttpClient.Builder()
            .followRedirects(false) // We want to read Location ourselves
            .build()

        val request = Request.Builder()
            .url(trackedUrl)
            .get()
            .build()

        client.newCall(request).execute().use { response ->
            val location = response.header("Location")
                ?: throw IllegalStateException("Missing Location header")
            return Uri.parse(location)
        }
    }

    private fun routeToDestination(finalUri: Uri) {
        // Example: interpret https://www.mybusiness.com/dashboard/offers/coupons
        // and open the correct Activity / Fragment
    }
}
IMPORTANT
Come iOS, l'app deve chiamare l'URL mclick e utilizzare l'intestazione Location per determinare la destinazione finale.
Utilizza followRedirects(false) per controllare la gestione dei reindirizzamenti e registrare accuratamente le analisi se necessario.
La logica di indirizzamento è specifica per l’app; definisci una chiara mappatura dagli URL alle schermate.
  • Usa percorsi stabili: preferisci route resilienti alle modifiche dell’interfaccia utente dell’app (ad esempio /account/orders anziché /tab/3/view/2).
  • Account per percorsi tracciati: quando è abilitato il tracciamento dei collegamenti, il collegamento su cui è stato fatto clic può utilizzare modelli di percorsi tracciati (ad esempio /ee/v1/mclick/). Assicurati che il router possa analizzare l’URL finale dopo aver risolto il collegamento tracciato.
  • Mantieni i parametri prevedibili: definisci uno schema di parametri coerente (ad esempio ?orderId=12345).
  • Evita dati sensibili negli URL: non inserire segreti o dati personali direttamente nell’URL del collegamento profondo.
  • Verifica il collegamento profondo: invia una bozza e fai clic sul collegamento profondo in un dispositivo in cui è installata l’app.
  • Convalida su dispositivi reali: i collegamenti universali e i comportamenti di risoluzione dei collegamenti tracciati sono più affidabili per la convalida su dispositivi fisici anziché su simulatori.
  • Convalida il routing lato app: se il collegamento profondo non apre la schermata prevista, convalida il routing lato app e il formato URL (host/percorso/query e codifica URL).
  • Tieni presente l’inizializzazione dell’app: il comportamento Collegamenti app/Collegamenti universali è più affidabile dopo che l’app è stata installata e aperta almeno una volta.

Risoluzione dei problemi e domande frequenti troubleshooting-faq

L'app non si apre quando tocco il collegamento profondo.
  • Verificare che l’URL corrisponda ai pattern di host e percorso che l’app è registrata per gestire, inclusi i percorsi di clic tracciati quando è abilitato il tracciamento dei collegamenti (ad esempio, percorsi in /ee/v1/mclick/).
  • Per i collegamenti universali iOS e i collegamenti alle app Android, l’associazione del dominio (AASA / assetlinks.json) è configurata correttamente ed è raggiungibile.
  • Eseguire il test su un dispositivo reale (i simulatori/emulatori possono comportarsi in modo diverso per l’associazione dei collegamenti).
L’app si apre ma non passa alla schermata prevista.
  • Conferma che il router lato app analizzi correttamente il percorso/query dell’URL.
  • Verifica codifica URL: i caratteri riservati devono essere codificati in URL.
  • Verificare che i nomi e i valori dei parametri corrispondano a quanto previsto dal router.
Cosa succede se l’app non è installata?
  • Se lo stesso URL HTTPS può essere servito dal sito web, il collegamento può aprire una pagina web come fallback quando l’app non è installata (configura di conseguenza la destinazione web e il routing).
Come posso includere in modo sicuro i caratteri speciali nei parametri?
Valori dei parametri di query con codifica URL. Questo riduce i problemi di consegna e rendering e aiuta a prevenire gli errori di analisi nell’app.
Come dovremmo eseguire il test end-to-end?

  • Crea una bozza con un collegamento profondo; fai clic su di essa sui dispositivi iOS e Android (scenari installati e non installati).

  • Convalida:

    • Il valore finale del collegamento e-mail o SMS (host/percorso/query)
    • Associazione a livello di sistema operativo (se si utilizzano collegamenti universali/collegamenti alle app)
    • Risultato del routing in-app
Ho un’app ma diversi sottodomini per l’organizzazione. Devo richiedere la creazione di AASA e assetLinks.json per ogni sottodominio?
Sì. Se desideri collegamenti profondi su ogni sottodominio delegato, richiedi la configurazione di AASA e assetlinks.json per ogni sottodominio che deve supportare la funzione.
L'URL configurato deve utilizzare un formato di collegamento profondo (ad esempio appname://path)?
È possibile utilizzare uno schema URL personalizzato (ad esempio appname://path), ma l’approccio consigliato è un collegamento universale o un collegamento all’app (https://), che corrisponde alla configurazione basata su HTTPS nelle sezioni di configurazione e implementazione di questa pagina.
I parametri UTM sull’URL saranno disponibili nell’app mobile per l’analisi?
Sì. I parametri UTM configurati in Journey Optimizer sono inclusi nell’URL finale restituito nell’intestazione Location quando l’app esegue un GET sull’URL mclick, quindi puoi utilizzarli per l’analisi in-app.
Qual è l'esperienza utente per /ee/v1/click/ URL?
Il collegamento viene aperto nel browser Web predefinito del dispositivo (comportamento standard di tracciamento dei clic), anziché essere gestito come collegamento profondo nell’app tramite il flusso mclick descritto in questa pagina.
AI Knowledge Reference

This section contains structured knowledge intended to support interpretation, retrieval, and question answering related to this topic.

For complete understanding, this information should be combined with the documentation on this page. Neither source is intended to stand alone; the page describes the feature, while this section provides additional context that helps disambiguate terminology, intent, applicability, and constraints.

  • TL;DR: This page explains how to author deep links in email and SMS content, configure them in Journey Optimizer, and handle the tracked links in iOS and Android apps so recipients land on the right in-app screen.

Intents:

  • Author a deep link in email (Email Designer or Personalization editor code) and in SMS (Url helper function)
  • Complete the Journey Optimizer configuration for universal links (iOS) and app links (Android)
  • Implement mobile app handling of tracked mclick links in iOS and Android
  • Follow recommended practices and troubleshoot deep links that do not open the app or the expected screen
  • Test deep links end-to-end by sending a proof and clicking on real devices

Glossary:

  • Deep link: A link that takes recipients from an email or SMS message directly to a specific screen or content in a mobile app (product-specific)
  • Universal links (iOS) / App links (Android): HTTPS-based deep links the configuration on this page applies to (product-specific)
  • AASA / assetLinks.json: The association files hosted on your delegated subdomain for iOS (AASA) and Android (assetLinks.json) (product-specific)
  • /ee/v1/mclick/*: Tracked URLs that Adobe hosts and resolves for deep link clicks when link tracking is enabled (product-specific)

Guardrails:

  • Deep links will not work unless you complete both the configuration and the mobile app implementation steps on this page.
  • Deep linking is supported for both iOS and Android using tracked URLs (/ee/v1/mclick/*) for compatibility and click tracking.
  • The configuration section applies when you use universal links (iOS) and app links (Android), which are HTTPS-based deep links.
  • Tracked deep link clicks use URLs under /ee/v1/mclick/*, which Adobe hosts and resolves, and apply when link tracking is enabled for the message.
  • For non-tracked links, the URL is not rewritten through Adobe systems; you must configure universal links or app links on your own domains and hosting.
  • The app must perform a GET on the mclick URL and read the Location header, then route based on the final URL; do not simply open the mclick URL in a browser.
  • Hosting the AASA (iOS) and assetLinks.json (Android) files requires contacting Adobe Customer Care with the delegated subdomain and app bundle ID; Android also requires the SHA-256 certificate fingerprint.

Terminology:

  • Canonical name: Deep link — Acronym: n/a — variants: deeplink, Deeplink (Insert link option)
  • Synonyms: “universal links” (iOS) and “app links” (Android) = the HTTPS-based deep link setup
  • Do not confuse: “/ee/v1/mclick/*” (tracked deep link flow handled as an app deep link) ≠ “/ee/v1/click/” (opens in the device’s default web browser, standard click tracking)
  • Do not confuse: “tracked links” (rewritten through Adobe, use mclick) ≠ “non-tracked links” (not rewritten; configured on your own domains)

FAQ:

  • Q: What must be done before deep links work? — Complete both the configuration steps in Journey Optimizer and the mobile app implementation steps for iOS and Android.
  • Q: How should the app handle the tracked link? — Perform a GET on the mclick URL, read the Location header, and route based on the final URL; do not open the mclick URL directly in a browser.
  • Q: What happens if the app is not installed? — If the same HTTPS URL can be served by your website, the link can open a web page as a fallback.
  • Q: Are UTM parameters available in the app? — Yes; UTM parameters configured in Journey Optimizer are included in the final URL returned in the Location header.
  • Q: How do I test end-to-end? — Send a proof (create a proof with a deep link) and click it on iOS and Android devices, for both installed and not-installed scenarios, validating on real devices.
  • Q: Should I use a custom URL scheme like appname://path? — You can, but the recommended approach is a universal link or app link (https://) matching the HTTPS-based setup on this page.
recommendation-more-help
journey-optimizer-help