Audience targeting

Overview#

Audiences can be used to target your experimentation and personalization activities. Adobe Target supports myriad powerful audience targeting capabilities out of the box. The following attributes are available for audience targeting:

Target Library#

For more information, see Target Library.

Referred from Bing
Chrome Browser
Firefox Browser
Referred from Google
Internet Explorer
Linux Operating System
Mac OS Operating System
New Visitors
Returning Visitors
Safari Browser
Tablet Device
Windows Operating System
Referred from Yahoo

Geo#

For more information, see Geo.

Country/Region
State
City
Zip Code
Latitude
Longitude
DMA
Mobile Carrier

Network#

For more information, see Network.

ISP
Domain Name
Connection Speed

Mobile#

For more information, see Mobile.

Device Marketing Name
Device Model
Device Vendor
Is Mobile Device
Is Mobile Phone
Is Tablet
OS
Screen Height (px)
Screen Width (px)

Custom#

For more information, see Custom parameters.

any key / value pair

Operating system#

For more information, see Operating System.

Linux
Macintosh
Windows

Site pages#

For more information, see Site pages.

Current Page
Previous Page
Landing Page
HTTP Header

Browser#

For more information, see Browser.

Type
Language
Version

Visitor Profile#

For more information, see Visitor Profile.

any key / value pair, which is persisted

Traffic Sources#

For more information, see Traffic Sources.

From Baidu
From Bing
From Google
From Yahoo
Referring Landing Page: URL
Referring Landing Page: Domain
Referring Landing Page: Query

Time Frame#

For more information, see Time Frame.

Start Date / End Date

Client Hints#

Adobe Target requires Client Hints for correct segmentation of Browser, Operating System, and Mobile audience attributes, as well as certain instances of Profile Scripts. For more background information, see User Agent and Client Hints.

How to Pass Client Hints to Adobe Target#

Starting with Node.js SDK v2.4.0 and Java SDK v2.3.0, Client Hints can be sent to Target via getOffers() calls. Client Hints should be included on the request.context object, along with User Agent.

Node.js SDK

Java SDK

targetClient.getOffers({ 
    request: { 
        context: { 
            channel: "mobile" 
            userAgent: "Mozilla/5.0 (Linux; Android 12; Pixel 4a) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36", 
            clientHints: { 
                mobile: "true", 
                platform: "Linux", 
                platformVersion: "12.1", 
                model: "Pixel 4a", 
                browserUAWithMajorVersion: "\"Not A;Brand\";v=\"98\", \"Chromium\";v=\"98\", \"Google Chrome\";v=\"98\"", 
                browserUAWithFullVersion: "\" Not A;Brand\";v=\"98.0.0.0\", \"Chromium\";v=\"98.0.4844.83\", \"Google Chrome\";v=\"98.0.4758.101\"", 
                bitness: "64", 
                architecture: "x86" 
            } 
        }, 
        execute: { 
            mboxes: [{ 
                name: "home", 
                index: 1 
            }] 
        } 
    } 
});
Copied to your clipboard
1targetClient.getOffers({ 
2    request: { 
3        context: { 
4            channel: "mobile" 
5            userAgent: "Mozilla/5.0 (Linux; Android 12; Pixel 4a) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36", 
6            clientHints: { 
7                mobile: "true", 
8                platform: "Linux", 
9                platformVersion: "12.1", 
10                model: "Pixel 4a", 
11                browserUAWithMajorVersion: "\"Not A;Brand\";v=\"98\", \"Chromium\";v=\"98\", \"Google Chrome\";v=\"98\"", 
12                browserUAWithFullVersion: "\" Not A;Brand\";v=\"98.0.0.0\", \"Chromium\";v=\"98.0.4844.83\", \"Google Chrome\";v=\"98.0.4758.101\"", 
13                bitness: "64", 
14                architecture: "x86" 
15            } 
16        }, 
17        execute: { 
18            mboxes: [{ 
19                name: "home", 
20                index: 1 
21            }] 
22        } 
23    } 
24});

import com.adobe.target.delivery.v1.model.ClientHints; 
import com.adobe.target.delivery.v1.model.Context; 
import com.adobe.target.delivery.v1.model.ExecuteRequest; 
import com.adobe.target.edge.client.model.TargetDeliveryRequest; 

 
ClientHints clientHints = new ClientHints(); 
clientHints.setMobile(true); 
clientHints.setPlatform("macOS"); 
clientHints.setArchitecture("x86"); 
clientHints.setPlatformVersion("11.3.1"); 
clientHints.setBrowserUAWithMajorVersion( 
  "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"99\", \"Google Chrome\";v=\"99\""); 
String userAgent = 
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36"; 

 
TargetDeliveryRequest request = TargetDeliveryRequest.builder() 
        .execute(new ExecuteRequest().pageLoad(pageLoad)) 
        .context(new Context().clientHints(clientHints).userAgent(userAgent)) 
        .build(); 
Copied to your clipboard
1import com.adobe.target.delivery.v1.model.ClientHints; 
2import com.adobe.target.delivery.v1.model.Context; 
3import com.adobe.target.delivery.v1.model.ExecuteRequest; 
4import com.adobe.target.edge.client.model.TargetDeliveryRequest; 
5
6 
7ClientHints clientHints = new ClientHints(); 
8clientHints.setMobile(true); 
9clientHints.setPlatform("macOS"); 
10clientHints.setArchitecture("x86"); 
11clientHints.setPlatformVersion("11.3.1"); 
12clientHints.setBrowserUAWithMajorVersion( 
13  "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"99\", \"Google Chrome\";v=\"99\""); 
14String userAgent = 
15  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36"; 
16
17 
18TargetDeliveryRequest request = TargetDeliveryRequest.builder() 
19        .execute(new ExecuteRequest().pageLoad(pageLoad)) 
20        .context(new Context().clientHints(clientHints).userAgent(userAgent)) 
21        .build();

On-device decisioning#

The following table indicates which audience rules are supported or not supported for on-device decisioning.

Audience Rule	On-device Decisioning
Geo	Yes
Network	No
Mobile	No
Custom Parameters	Yes
Operating System	Yes
Site Pages	Yes
Browser	Yes
Visitor Profile	No
Traffic Sources	No
Time Frame	Yes
Experience Cloud Audiences (Audiences from Adobe Audience Manager, Adobe Analytics, and Adobe Experience Manager	No

Geo targeting for on-device decisioning#

In order to maintain near-zero latency for on-device decisioning activities with geo-based audiences, Adobe recommends you provide the geo values yourself in the call to getOffers. Do this by setting the Geo object in the Context of the request. This means your server will need a way to determine the location of each end user. For example, your server may perform an IP-to-Geo lookup, using a service you configure. Some hosting providers, such as Google Cloud, provide this functionality via custom headers in each HttpServletRequest.

Node.js

Java

const CONFIG = {
    client: "acmeclient",
    organizationId: "1234567890@AdobeOrg",
    decisioningMethod: "on-device"
};

const targetClient = TargetClient.create(CONFIG);

targetClient.getOffers({
    request: {
        context: {
            geo: {
                city: "SAN FRANCISCO",
                countryCode: "US",
                stateCode: "CA",
                latitude: 37.75,
                longitude: -122.4
            }
        },
        execute: {
            pageLoad: {}
        }
    }
})
Copied to your clipboard
1const CONFIG = {
2    client: "acmeclient",
3    organizationId: "1234567890@AdobeOrg",
4    decisioningMethod: "on-device"
5};
6
7const targetClient = TargetClient.create(CONFIG);
8
9targetClient.getOffers({
10    request: {
11        context: {
12            geo: {
13                city: "SAN FRANCISCO",
14                countryCode: "US",
15                stateCode: "CA",
16                latitude: 37.75,
17                longitude: -122.4
18            }
19        },
20        execute: {
21            pageLoad: {}
22        }
23    }
24})

public class TargetRequestUtils {

    public static Context getContext(HttpServletRequest request) {
        Context context = new Context()
            .geo(ipToGeoLookup(request.getRemoteAddr()))
            .channel(ChannelType.WEB)
            .timeOffsetInMinutes(330.0)
            .address(getAddress(request));
        return context;
    }

    public static Geo ipToGeoLookup(String ip) {
        GeoResult geoResult = geoLookupService.lookup(ip);
        return new Geo()
            .city(geoResult.getCity())
            .stateCode(geoResult.getStateCode())
            .countryCode(geoResult.getCountryCode());
    }
}
Copied to your clipboard
1public class TargetRequestUtils {
2
3    public static Context getContext(HttpServletRequest request) {
4        Context context = new Context()
5            .geo(ipToGeoLookup(request.getRemoteAddr()))
6            .channel(ChannelType.WEB)
7            .timeOffsetInMinutes(330.0)
8            .address(getAddress(request));
9        return context;
10    }
11
12    public static Geo ipToGeoLookup(String ip) {
13        GeoResult geoResult = geoLookupService.lookup(ip);
14        return new Geo()
15            .city(geoResult.getCity())
16            .stateCode(geoResult.getStateCode())
17            .countryCode(geoResult.getCountryCode());
18    }
19}

However, if you do not have the ability to perform IP-to-Geo lookups on your server, but you still want to perform on-device decisioning for getOffers requests that contain geo-based audiences, this is also supported. The downside of this approach is that it will use a remote IP-to-Geo lookup, which will add latency to each getOffers call. This latency should be lower than a remote getOffers call, since it hits a CDN that is located close to your server. You must only provide the ipAddress field in the Geo object in the Context of your request, in order for the SDK to retrieve the geo-location of your user's IP address. If any other field in addition to the ipAddress is provided, the Target SDK will not fetch the geo-location metadata for resolution.