0
# Audience Management
1

2
Comprehensive audience and user list management including custom audience creation, user list management, audience insights, and advanced audience targeting capabilities. The Google Ads API provides extensive audience management features for remarketing, lookalike audiences, and behavioral targeting.
3

4
## Capabilities
5

6
### User List Operations
7

8
User list management operations for creating and managing remarketing lists, customer match lists, and other audience segments for targeted advertising.
9

10
```python { .api }
11
def mutate_user_lists(
12
    self,
13
    request: Optional[MutateUserListsRequest] = None,
14
    customer_id: Optional[str] = None,
15
    operations: Optional[Sequence[UserListOperation]] = None,
16
    partial_failure: bool = False,
17
    validate_only: bool = False,
18
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
19
) -> MutateUserListsResponse:
20
    """
21
    Create, update, or remove user lists.
22

23
    Args:
24
        request: The request object containing all parameters
25
        customer_id: Required customer ID for the account
26
        operations: List of user list operations to perform
27
        partial_failure: Continue processing on individual failures
28
        validate_only: Validate operations without executing
29
        response_content_type: Type of response content to return
30

31
    Returns:
32
        MutateUserListsResponse with operation results
33
    """
34

35
def get_user_list(
36
    self,
37
    request: Optional[GetUserListRequest] = None,
38
    resource_name: Optional[str] = None
39
) -> UserList:
40
    """
41
    Retrieve a user list by resource name.
42

43
    Args:
44
        request: The request object
45
        resource_name: User list resource name (customers/{customer_id}/userLists/{user_list_id})
46

47
    Returns:
48
        UserList resource object
49
    """
50
```
51

52
### Custom Audience Operations
53

54
Custom audience management for creating and managing interest-based and intent-based custom audiences for broader targeting beyond existing customer data.
55

56
```python { .api }
57
def mutate_custom_audiences(
58
    self,
59
    request: Optional[MutateCustomAudiencesRequest] = None,
60
    customer_id: Optional[str] = None,
61
    operations: Optional[Sequence[CustomAudienceOperation]] = None,
62
    validate_only: bool = False
63
) -> MutateCustomAudiencesResponse:
64
    """
65
    Create, update, or remove custom audiences.
66

67
    Args:
68
        request: The request object
69
        customer_id: Required customer ID
70
        operations: List of custom audience operations
71
        validate_only: Validate without executing
72

73
    Returns:
74
        MutateCustomAudiencesResponse with results
75
    """
76

77
def get_custom_audience(
78
    self,
79
    request: Optional[GetCustomAudienceRequest] = None,
80
    resource_name: Optional[str] = None
81
) -> CustomAudience:
82
    """
83
    Retrieve a custom audience by resource name.
84

85
    Args:
86
        request: The request object
87
        resource_name: Custom audience resource name
88

89
    Returns:
90
        CustomAudience resource object
91
    """
92
```
93

94
### Audience Insights Operations
95

96
Audience insights and analytics operations for understanding audience characteristics, interests, and behaviors to inform targeting strategies.
97

98
```python { .api }
99
def generate_insights_finder_report(
100
    self,
101
    request: Optional[GenerateInsightsFinderReportRequest] = None,
102
    customer_id: Optional[str] = None,
103
    baseline_audience: Optional[BasicInsightsAudience] = None,
104
    specific_audience: Optional[BasicInsightsAudience] = None
105
) -> GenerateInsightsFinderReportResponse:
106
    """
107
    Generate audience insights report comparing audiences.
108

109
    Args:
110
        request: The request object
111
        customer_id: Required customer ID
112
        baseline_audience: Baseline audience for comparison
113
        specific_audience: Specific audience to analyze
114

115
    Returns:
116
        Audience insights data and recommendations
117
    """
118

119
def generate_audience_composition_insights(
120
    self,
121
    request: Optional[GenerateAudienceCompositionInsightsRequest] = None,
122
    customer_id: Optional[str] = None,
123
    audience: Optional[InsightsAudience] = None,
124
    dimensions: Optional[Sequence[AudienceInsightsDimensionEnum.AudienceInsightsDimension]] = None
125
) -> GenerateAudienceCompositionInsightsResponse:
126
    """
127
    Generate audience composition insights for demographic analysis.
128

129
    Args:
130
        request: The request object
131
        customer_id: Required customer ID
132
        audience: Audience to analyze
133
        dimensions: Dimensions for analysis (age, gender, etc.)
134

135
    Returns:
136
        Demographic composition insights
137
    """
138

139
def list_insights_eligible_dates(
140
    self,
141
    request: Optional[ListInsightsEligibleDatesRequest] = None
142
) -> ListInsightsEligibleDatesResponse:
143
    """
144
    List available dates for audience insights analysis.
145

146
    Args:
147
        request: The request object
148

149
    Returns:
150
        Available date ranges for insights
151
    """
152
```
153

154
### Remarketing Action Operations
155

156
Remarketing action management for defining conversion events and user interactions that trigger remarketing list membership.
157

158
```python { .api }
159
def mutate_remarketing_actions(
160
    self,
161
    request: Optional[MutateRemarketingActionsRequest] = None,
162
    customer_id: Optional[str] = None,
163
    operations: Optional[Sequence[RemarketingActionOperation]] = None,
164
    partial_failure: bool = False,
165
    validate_only: bool = False
166
) -> MutateRemarketingActionsResponse:
167
    """
168
    Create, update, or remove remarketing actions.
169

170
    Args:
171
        request: The request object
172
        customer_id: Required customer ID
173
        operations: List of remarketing action operations
174
        partial_failure: Continue on individual failures
175
        validate_only: Validate without executing
176

177
    Returns:
178
        MutateRemarketingActionsResponse with results
179
    """
180

181
def get_remarketing_action(
182
    self,
183
    request: Optional[GetRemarketingActionRequest] = None,
184
    resource_name: Optional[str] = None
185
) -> RemarketingAction:
186
    """
187
    Retrieve a remarketing action by resource name.
188

189
    Args:
190
        request: The request object
191
        resource_name: Remarketing action resource name
192

193
    Returns:
194
        RemarketingAction resource object
195
    """
196
```
197

198
## User List Creation Examples
199

200
### Website Remarketing List
201

202
```python
203
from google.ads.googleads.client import GoogleAdsClient
204
from google.ads.googleads.errors import GoogleAdsException
205

206
def create_remarketing_list(client, customer_id, list_name, rule_items):
207
    """Create a remarketing list based on website visits."""
208
    
209
    user_list_service = client.get_service("UserListService")
210
    
211
    # Create user list operation
212
    operation = client.get_type("UserListOperation")
213
    user_list = operation.create
214
    user_list.name = list_name
215
    user_list.description = f"Website visitors for {list_name}"
216
    user_list.membership_status = client.enums.UserListMembershipStatusEnum.OPEN
217
    user_list.membership_life_span = 30  # 30 days
218
    
219
    # Configure rule-based user list
220
    rule_based_user_list = user_list.rule_based_user_list
221
    rule_based_user_list.prepopulation_status = client.enums.UserListPrepopulationStatusEnum.REQUESTED
222
    
223
    # Create flexible rule user list
224
    flexible_rule_user_list = rule_based_user_list.flexible_rule_user_list
225
    flexible_rule_user_list.inclusive_rule_operator = client.enums.UserListFlexibleRuleOperatorEnum.AND
226
    
227
    # Add rule groups
228
    rule_group = client.get_type("FlexibleRuleOperandInfo")
229
    rule_group.rule.rule_type = client.enums.UserListRuleTypeEnum.URL
230
    
231
    # Add rule items (URL conditions)
232
    for rule_item_data in rule_items:
233
        rule_item = client.get_type("UserListRuleItemInfo")
234
        rule_item.name = rule_item_data['name']
235
        rule_item.string_rule_item.operator = rule_item_data['operator']
236
        rule_item.string_rule_item.value = rule_item_data['value']
237
        
238
        rule_group.rule.rule_item_groups.append(
239
            client.get_type("UserListRuleItemGroupInfo", rule_items=[rule_item])
240
        )
241
    
242
    flexible_rule_user_list.inclusive_operands.append(rule_group)
243
    
244
    try:
245
        response = user_list_service.mutate_user_lists(
246
            customer_id=customer_id,
247
            operations=[operation]
248
        )
249
        
250
        user_list_resource_name = response.results[0].resource_name
251
        print(f"Created remarketing list: {user_list_resource_name}")
252
        return user_list_resource_name
253
        
254
    except GoogleAdsException as ex:
255
        print(f"Request failed with status {ex.error.code().name}")
256
        for error in ex.failure.errors:
257
            print(f"Error: {error.message}")
258
        return None
259

260
# Example usage - visitors to specific product pages
261
rule_items = [
262
    {
263
        'name': 'url',
264
        'operator': client.enums.UserListStringRuleItemOperatorEnum.CONTAINS,
265
        'value': '/products/'
266
    }
267
]
268

269
remarketing_list = create_remarketing_list(
270
    client,
271
    customer_id,
272
    "Product Page Visitors",
273
    rule_items
274
)
275
```
276

277
### Customer Match List (Email)
278

279
```python
280
def create_customer_match_email_list(client, customer_id, list_name, emails):
281
    """Create a customer match list using email addresses."""
282
    
283
    user_list_service = client.get_service("UserListService")
284
    offline_user_data_job_service = client.get_service("OfflineUserDataJobService")
285
    
286
    # Create customer match user list
287
    operation = client.get_type("UserListOperation")
288
    user_list = operation.create
289
    user_list.name = list_name
290
    user_list.description = f"Customer match list: {list_name}"
291
    user_list.membership_status = client.enums.UserListMembershipStatusEnum.OPEN
292
    user_list.membership_life_span = 10000  # Maximum lifespan
293
    
294
    # Configure customer match user list
295
    crm_based_user_list = user_list.crm_based_user_list
296
    crm_based_user_list.upload_key_type = client.enums.CustomerMatchUploadKeyTypeEnum.CONTACT_INFO
297
    crm_based_user_list.data_source_type = client.enums.UserListCrmDataSourceTypeEnum.FIRST_PARTY
298
    
299
    # Create the user list first
300
    response = user_list_service.mutate_user_lists(
301
        customer_id=customer_id,
302
        operations=[operation]
303
    )
304
    
305
    user_list_resource_name = response.results[0].resource_name
306
    
307
    # Create offline user data job to upload emails
308
    job_operation = client.get_type("OfflineUserDataJobOperation")
309
    job = job_operation.create
310
    job.type_ = client.enums.OfflineUserDataJobTypeEnum.CUSTOMER_MATCH_USER_LIST
311
    job.customer_match_user_list_metadata.user_list = user_list_resource_name
312
    
313
    job_response = offline_user_data_job_service.create_offline_user_data_job(
314
        customer_id=customer_id,
315
        job=job
316
    )
317
    
318
    job_resource_name = job_response.resource_name
319
    
320
    # Add email operations
321
    operations = []
322
    for email in emails:
323
        user_data_operation = client.get_type("OfflineUserDataJobOperation")
324
        user_data = user_data_operation.create
325
        user_data.user_identifiers.append(
326
            client.get_type("UserIdentifier", 
327
                          hashed_email=hashlib.sha256(email.lower().encode()).hexdigest())
328
        )
329
        operations.append(user_data_operation)
330
    
331
    # Add operations to job
332
    offline_user_data_job_service.add_offline_user_data_job_operations(
333
        resource_name=job_resource_name,
334
        operations=operations
335
    )
336
    
337
    # Run the job
338
    offline_user_data_job_service.run_offline_user_data_job(
339
        resource_name=job_resource_name
340
    )
341
    
342
    return user_list_resource_name
343

344
# Example usage
345
import hashlib
346

347
customer_emails = [
348
    "customer1@example.com",
349
    "customer2@example.com", 
350
    "customer3@example.com"
351
]
352

353
customer_match_list = create_customer_match_email_list(
354
    client,
355
    customer_id,
356
    "VIP Customers",
357
    customer_emails
358
)
359
```
360

361
### Similar Audiences (Lookalike)
362

363
```python
364
def create_similar_user_list(client, customer_id, list_name, seed_user_list_resource_name):
365
    """Create a similar audiences (lookalike) list based on a seed list."""
366
    
367
    user_list_service = client.get_service("UserListService")
368
    
369
    operation = client.get_type("UserListOperation")
370
    user_list = operation.create
371
    user_list.name = list_name
372
    user_list.description = f"Similar audience based on {seed_user_list_resource_name}"
373
    user_list.membership_status = client.enums.UserListMembershipStatusEnum.OPEN
374
    user_list.membership_life_span = 30
375
    
376
    # Configure similar user list
377
    similar_user_list = user_list.similar_user_list
378
    similar_user_list.seed_user_list = seed_user_list_resource_name
379
    
380
    response = user_list_service.mutate_user_lists(
381
        customer_id=customer_id,
382
        operations=[operation]
383
    )
384
    
385
    return response.results[0].resource_name
386
```
387

388
## Custom Audience Examples
389

390
### Interest-Based Custom Audience
391

392
```python
393
def create_interest_custom_audience(client, customer_id, audience_name, interests, urls=None):
394
    """Create a custom audience based on interests and URLs."""
395
    
396
    custom_audience_service = client.get_service("CustomAudienceService")
397
    
398
    operation = client.get_type("CustomAudienceOperation")
399
    custom_audience = operation.create
400
    custom_audience.name = audience_name
401
    custom_audience.type_ = client.enums.CustomAudienceTypeEnum.INTEREST
402
    custom_audience.description = f"Interest-based audience: {audience_name}"
403
    custom_audience.status = client.enums.CustomAudienceStatusEnum.ENABLED
404
    
405
    # Add interest members
406
    for interest in interests:
407
        member = client.get_type("CustomAudienceMember")
408
        member.member_type = client.enums.CustomAudienceMemberTypeEnum.KEYWORD
409
        member.keyword = interest
410
        custom_audience.members.append(member)
411
    
412
    # Add URL members if provided
413
    if urls:
414
        for url in urls:
415
            member = client.get_type("CustomAudienceMember")
416
            member.member_type = client.enums.CustomAudienceMemberTypeEnum.URL
417
            member.url = url
418
            custom_audience.members.append(member)
419
    
420
    try:
421
        response = custom_audience_service.mutate_custom_audiences(
422
            customer_id=customer_id,
423
            operations=[operation]
424
        )
425
        
426
        return response.results[0].resource_name
427
        
428
    except GoogleAdsException as ex:
429
        print(f"Request failed: {ex.error.code().name}")
430
        for error in ex.failure.errors:
431
            print(f"Error: {error.message}")
432
        return None
433

434
# Example usage
435
interests = [
436
    "outdoor sports",
437
    "hiking equipment", 
438
    "camping gear",
439
    "adventure travel"
440
]
441

442
urls = [
443
    "https://www.outdoor-gear.com",
444
    "https://www.hiking-equipment.com"
445
]
446

447
custom_audience = create_interest_custom_audience(
448
    client,
449
    customer_id,
450
    "Outdoor Enthusiasts",
451
    interests,
452
    urls
453
)
454
```
455

456
### Purchase Intent Custom Audience
457

458
```python
459
def create_purchase_intent_audience(client, customer_id, audience_name, intent_keywords, apps=None):
460
    """Create a purchase intent custom audience."""
461
    
462
    custom_audience_service = client.get_service("CustomAudienceService")
463
    
464
    operation = client.get_type("CustomAudienceOperation")
465
    custom_audience = operation.create
466
    custom_audience.name = audience_name
467
    custom_audience.type_ = client.enums.CustomAudienceTypeEnum.PURCHASE_INTENT
468
    custom_audience.description = f"Purchase intent audience: {audience_name}"
469
    custom_audience.status = client.enums.CustomAudienceStatusEnum.ENABLED
470
    
471
    # Add intent keywords
472
    for keyword in intent_keywords:
473
        member = client.get_type("CustomAudienceMember")
474
        member.member_type = client.enums.CustomAudienceMemberTypeEnum.KEYWORD
475
        member.keyword = keyword
476
        custom_audience.members.append(member)
477
    
478
    # Add app members if provided
479
    if apps:
480
        for app in apps:
481
            member = client.get_type("CustomAudienceMember")
482
            member.member_type = client.enums.CustomAudienceMemberTypeEnum.APP
483
            member.app = app
484
            custom_audience.members.append(member)
485
    
486
    response = custom_audience_service.mutate_custom_audiences(
487
        customer_id=customer_id,
488
        operations=[operation]
489
    )
490
    
491
    return response.results[0].resource_name
492
```
493

494
## Audience Targeting Examples
495

496
### Apply Audience to Campaign
497

498
```python
499
def add_audience_to_campaign(client, customer_id, campaign_resource_name, audience_resource_name, bid_modifier=None):
500
    """Add audience targeting to a campaign."""
501
    
502
    campaign_criterion_service = client.get_service("CampaignCriterionService")
503
    
504
    operation = client.get_type("CampaignCriterionOperation")
505
    criterion = operation.create
506
    criterion.campaign = campaign_resource_name
507
    criterion.status = client.enums.CampaignCriterionStatusEnum.ENABLED
508
    
509
    # Determine audience type and set accordingly
510
    if "userLists" in audience_resource_name:
511
        criterion.type_ = client.enums.CriterionTypeEnum.USER_LIST
512
        criterion.user_list.user_list = audience_resource_name
513
    elif "customAudiences" in audience_resource_name:
514
        criterion.type_ = client.enums.CriterionTypeEnum.CUSTOM_AUDIENCE
515
        criterion.custom_audience.custom_audience = audience_resource_name
516
    
517
    # Set bid modifier if provided
518
    if bid_modifier:
519
        criterion.bid_modifier = bid_modifier
520
    
521
    response = campaign_criterion_service.mutate_campaign_criteria(
522
        customer_id=customer_id,
523
        operations=[operation]
524
    )
525
    
526
    return response.results[0].resource_name
527
```
528

529
### Audience Exclusions
530

531
```python
532
def exclude_audience_from_campaign(client, customer_id, campaign_resource_name, audience_resource_name):
533
    """Add audience exclusion to a campaign."""
534
    
535
    campaign_criterion_service = client.get_service("CampaignCriterionService")
536
    
537
    operation = client.get_type("CampaignCriterionOperation")
538
    criterion = operation.create
539
    criterion.campaign = campaign_resource_name
540
    criterion.negative = True  # Mark as exclusion
541
    
542
    if "userLists" in audience_resource_name:
543
        criterion.type_ = client.enums.CriterionTypeEnum.USER_LIST
544
        criterion.user_list.user_list = audience_resource_name
545
    elif "customAudiences" in audience_resource_name:
546
        criterion.type_ = client.enums.CriterionTypeEnum.CUSTOM_AUDIENCE
547
        criterion.custom_audience.custom_audience = audience_resource_name
548
    
549
    response = campaign_criterion_service.mutate_campaign_criteria(
550
        customer_id=customer_id,
551
        operations=[operation]
552
    )
553
    
554
    return response.results[0].resource_name
555
```
556

557
## Audience Insights Examples
558

559
### Generate Audience Composition Report
560

561
```python
562
def get_audience_demographics(client, customer_id, user_list_resource_name):
563
    """Generate demographic insights for an audience."""
564
    
565
    audience_insights_service = client.get_service("AudienceInsightsService")
566
    
567
    # Create insights audience from user list
568
    insights_audience = client.get_type("InsightsAudience")
569
    insights_audience.country_location.append(
570
        client.get_type("LocationInfo", geo_target_constant="geoTargetConstants/2840")  # US
571
    )
572
    insights_audience.user_lists.append(user_list_resource_name)
573
    
574
    # Request demographic dimensions
575
    dimensions = [
576
        client.enums.AudienceInsightsDimensionEnum.AGE_RANGE,
577
        client.enums.AudienceInsightsDimensionEnum.GENDER,
578
        client.enums.AudienceInsightsDimensionEnum.INCOME_RANGE,
579
        client.enums.AudienceInsightsDimensionEnum.PARENTAL_STATUS
580
    ]
581
    
582
    request = client.get_type("GenerateAudienceCompositionInsightsRequest")
583
    request.customer_id = customer_id
584
    request.audience = insights_audience
585
    request.dimensions = dimensions
586
    
587
    try:
588
        response = audience_insights_service.generate_audience_composition_insights(
589
            request=request
590
        )
591
        
592
        insights_data = []
593
        for section in response.sections:
594
            section_data = {
595
                'dimension': section.dimension.name,
596
                'breakdown': []
597
            }
598
            
599
            for attribute in section.breakdown:
600
                attribute_data = {
601
                    'attribute': attribute.attribute_metadata.dimension_value.display_name,
602
                    'coverage_percentage': attribute.coverage_percentage,
603
                    'index': attribute.index,
604
                    'score': attribute.score
605
                }
606
                section_data['breakdown'].append(attribute_data)
607
                
608
            insights_data.append(section_data)
609
        
610
        return insights_data
611
        
612
    except GoogleAdsException as ex:
613
        print(f"Insights request failed: {ex.error.code().name}")
614
        for error in ex.failure.errors:
615
            print(f"Error: {error.message}")
616
        return []
617
```
618

619
### Audience Finder Report
620

621
```python
622
def find_similar_audiences(client, customer_id, baseline_audience_resource_name):
623
    """Find audiences similar to a baseline audience."""
624
    
625
    audience_insights_service = client.get_service("AudienceInsightsService")
626
    
627
    # Create baseline audience
628
    baseline_audience = client.get_type("BasicInsightsAudience")
629
    baseline_audience.country_location.append(
630
        client.get_type("LocationInfo", geo_target_constant="geoTargetConstants/2840")
631
    )
632
    baseline_audience.user_list = baseline_audience_resource_name
633
    
634
    request = client.get_type("GenerateInsightsFinderReportRequest")
635
    request.customer_id = customer_id
636
    request.baseline_audience = baseline_audience
637
    
638
    response = audience_insights_service.generate_insights_finder_report(
639
        request=request
640
    )
641
    
642
    similar_audiences = []
643
    for audience_insights in response.audience_insights:
644
        audience_data = {
645
            'audience_definition': audience_insights.audience_definition,
646
            'targetable_audience_size': audience_insights.targetable_audience_size,
647
            'coverage_percentage': audience_insights.coverage_percentage,
648
            'index': audience_insights.index,
649
            'score': audience_insights.score
650
        }
651
        similar_audiences.append(audience_data)
652
    
653
    return similar_audiences
654
```
655

656
## Types
657

658
```python { .api }
659
# User list types
660
class UserList:
661
    resource_name: str
662
    id: Optional[int]
663
    read_only: Optional[bool]
664
    name: Optional[str]
665
    description: Optional[str]
666
    membership_status: UserListMembershipStatusEnum.UserListMembershipStatus
667
    integration_code: Optional[str]
668
    membership_life_span: Optional[int]
669
    size_for_display: Optional[int]
670
    size_range_for_display: UserListSizeRangeEnum.UserListSizeRange
671
    size_for_search: Optional[int]
672
    size_range_for_search: UserListSizeRangeEnum.UserListSizeRange
673
    type_: UserListTypeEnum.UserListType
674
    closing_reason: UserListClosingReasonEnum.UserListClosingReason
675
    access_reason: AccessReasonEnum.AccessReason
676
    account_user_list_status: UserListAccessStatusEnum.UserListAccessStatus
677
    eligible_for_search: Optional[bool]
678
    eligible_for_display: Optional[bool]
679
    match_rate_percentage: Optional[int]
680
    
681
    # User list types (one of the following)
682
    crm_based_user_list: CrmBasedUserListInfo
683
    similar_user_list: SimilarUserListInfo
684
    rule_based_user_list: RuleBasedUserListInfo
685
    logical_user_list: LogicalUserListInfo
686
    basic_user_list: BasicUserListInfo
687
    lookalike_user_list: LookalikeUserListInfo
688

689
class CrmBasedUserListInfo:
690
    app_id: Optional[str]
691
    upload_key_type: CustomerMatchUploadKeyTypeEnum.CustomerMatchUploadKeyType
692
    data_source_type: UserListCrmDataSourceTypeEnum.UserListCrmDataSourceType
693

694
class RuleBasedUserListInfo:
695
    prepopulation_status: UserListPrepopulationStatusEnum.UserListPrepopulationStatus
696
    flexible_rule_user_list: FlexibleRuleUserListInfo
697

698
class FlexibleRuleUserListInfo:
699
    inclusive_rule_operator: UserListFlexibleRuleOperatorEnum.UserListFlexibleRuleOperator
700
    inclusive_operands: List[FlexibleRuleOperandInfo]
701
    exclusive_operands: List[FlexibleRuleOperandInfo]
702

703
class FlexibleRuleOperandInfo:
704
    rule: UserListRuleInfo
705
    lookaback_window_days: Optional[int]
706

707
class UserListRuleInfo:
708
    rule_type: UserListRuleTypeEnum.UserListRuleType
709
    rule_item_groups: List[UserListRuleItemGroupInfo]
710

711
class UserListRuleItemGroupInfo:
712
    rule_items: List[UserListRuleItemInfo]
713

714
class UserListRuleItemInfo:
715
    name: Optional[str]
716
    number_rule_item: UserListNumberRuleItemInfo
717
    string_rule_item: UserListStringRuleItemInfo
718
    date_rule_item: UserListDateRuleItemInfo
719

720
class SimilarUserListInfo:
721
    seed_user_list: Optional[str]
722

723
# Custom audience types
724
class CustomAudience:
725
    resource_name: str
726
    id: Optional[int]
727
    status: CustomAudienceStatusEnum.CustomAudienceStatus
728
    name: Optional[str]
729
    type_: CustomAudienceTypeEnum.CustomAudienceType
730
    description: Optional[str]
731
    members: List[CustomAudienceMember]
732

733
class CustomAudienceMember:
734
    member_type: CustomAudienceMemberTypeEnum.CustomAudienceMemberType
735
    keyword: Optional[str]
736
    url: Optional[str]
737
    place_category: Optional[int]
738
    app: Optional[str]
739

740
# Remarketing action types
741
class RemarketingAction:
742
    resource_name: str
743
    id: Optional[int]
744
    name: Optional[str]
745
    tag_snippets: List[TagSnippet]
746

747
class TagSnippet:
748
    type_: TrackingCodeTypeEnum.TrackingCodeType
749
    page_format: TrackingCodePageFormatEnum.TrackingCodePageFormat
750
    global_site_tag: Optional[str]
751
    event_snippet: Optional[str]
752

753
# Audience insights types
754
class InsightsAudience:
755
    country_location: List[LocationInfo]
756
    sub_country_location: List[LocationInfo]
757
    gender: List[GenderInfo]
758
    age_ranges: List[AgeRangeInfo]
759
    user_interests: List[UserInterestInfo]
760
    user_lists: List[str]
761
    custom_audiences: List[str]
762

763
class BasicInsightsAudience:
764
    country_location: List[LocationInfo]
765
    sub_country_location: List[LocationInfo]
766
    gender: List[GenderInfo]
767
    age_ranges: List[AgeRangeInfo]
768
    user_interests: List[UserInterestInfo]
769
    user_list: Optional[str]
770
    custom_audience: Optional[str]
771

772
class AudienceCompositionSection:
773
    dimension: AudienceInsightsDimensionEnum.AudienceInsightsDimension
774
    breakdown: List[AudienceCompositionBreakdown]
775

776
class AudienceCompositionBreakdown:
777
    attribute_metadata: AudienceCompositionAttribute
778
    coverage_percentage: float
779
    index: float
780
    score: float
781

782
class AudienceCompositionAttribute:
783
    attribute_value: AttributeValue
784
    display_name: str
785
    display_info: str
786

787
# Operation types
788
class UserListOperation:
789
    update_mask: FieldMask
790
    create: UserList
791
    update: UserList
792
    remove: str
793

794
class CustomAudienceOperation:
795
    update_mask: FieldMask
796
    create: CustomAudience
797
    update: CustomAudience
798
    remove: str
799

800
class RemarketingActionOperation:
801
    update_mask: FieldMask
802
    create: RemarketingAction
803
    update: RemarketingAction
804
    remove: str
805

806
# Response types
807
class MutateUserListsResponse:
808
    partial_failure_error: Status
809
    results: List[MutateUserListResult]
810

811
class MutateUserListResult:
812
    resource_name: str
813
    user_list: UserList
814

815
class MutateCustomAudiencesResponse:
816
    results: List[MutateCustomAudienceResult]
817

818
class MutateCustomAudienceResult:
819
    resource_name: str
820
    custom_audience: CustomAudience
821

822
class GenerateAudienceCompositionInsightsResponse:
823
    sections: List[AudienceCompositionSection]
824

825
class GenerateInsightsFinderReportResponse:
826
    audience_insights: List[AudienceInsights]
827

828
class AudienceInsights:
829
    audience_definition: InsightsAudience
830
    targetable_audience_size: int
831
    coverage_percentage: float
832
    index: float
833
    score: float
834
```