Google Ads API AI Automation: Complete October 2025 Guide

Step 1: Enable View-Based Conversions

Configure view-based conversion tracking via the API:

# Python: Enable view-based conversions
from google.ads.googleads.client import GoogleAdsClient

def enable_view_conversions(client, customer_id, conversion_action_id):
    """Enable view-based conversions for a conversion action"""
    conversion_action_service = client.get_service("ConversionActionService")
    conversion_action_operation = client.get_type("ConversionActionOperation")

    conversion_action = conversion_action_operation.update
    conversion_action.resource_name = (
        f"customers/{customer_id}/conversionActions/{conversion_action_id}"
    )

    # Enable view-through conversion tracking
    conversion_action.view_through_lookback_window_days = 30
    conversion_action.include_in_conversions_metric = True

    # Set counting type (ONE_PER_CLICK or MANY_PER_CLICK)
    conversion_action.counting_type = client.enums.ConversionActionCountingTypeEnum.ONE_PER_CLICK

    # Update field mask
    field_mask = client.field_mask.build(
        conversion_action_operation.update,
        conversion_action
    )
    conversion_action_operation.update_mask.CopyFrom(field_mask)

    # Execute the update
    response = conversion_action_service.mutate_conversion_actions(
        customer_id=customer_id,
        operations=[conversion_action_operation]
    )

    print(f"Updated conversion action: {response.results[0].resource_name}")
    return response

# Usage
client = GoogleAdsClient.load_from_storage("google-ads.yaml")
enable_view_conversions(client, "YOUR_CUSTOMER_ID", "YOUR_CONVERSION_ACTION_ID")

Step 2: Report on View-Based Conversions

# Python: Query view-based conversion metrics
def get_view_conversion_report(client, customer_id, date_range="LAST_30_DAYS"):
    """Generate report with view-based conversion data"""
    ga_service = client.get_service("GoogleAdsService")

    query = f"""
        SELECT
            campaign.name,
            campaign.id,
            metrics.conversions,
            metrics.view_through_conversions,
            metrics.all_conversions,
            metrics.cost_micros,
            metrics.impressions,
            metrics.video_views,
            segments.conversion_action_name,
            segments.date
        FROM campaign
        WHERE segments.date DURING {date_range}
        AND campaign.advertising_channel_type IN ('DISPLAY', 'VIDEO')
        AND campaign.status = 'ENABLED'
        ORDER BY metrics.view_through_conversions DESC
    """

    response = ga_service.search_stream(customer_id=customer_id, query=query)

    # Process results
    results = []
    for batch in response:
        for row in batch.results:
            results.append({
                'campaign': row.campaign.name,
                'campaign_id': row.campaign.id,
                'click_conversions': row.metrics.conversions,
                'view_conversions': row.metrics.view_through_conversions,
                'all_conversions': row.metrics.all_conversions,
                'cost': row.metrics.cost_micros / 1_000_000,
                'impressions': row.metrics.impressions,
                'video_views': row.metrics.video_views,
                'conversion_action': row.segments.conversion_action_name,
                'date': row.segments.date,
                'view_conversion_rate': (
                    row.metrics.view_through_conversions / row.metrics.impressions
                    if row.metrics.impressions > 0 else 0
                )
            })

    return results

# Usage
results = get_view_conversion_report(client, "YOUR_CUSTOMER_ID")
for result in results[:5]:
    print(f"{result['campaign']}: {result['view_conversions']} view conversions")

Query AI Max Performance Data

# Python: Access AI Max reporting
def get_ai_max_performance(client, customer_id, campaign_id):
    """Query AI Max search term ad combination performance"""
    ga_service = client.get_service("GoogleAdsService")

    query = f"""
        SELECT
            ai_max_search_term_ad_combination_view.search_term,
            ai_max_search_term_ad_combination_view.headline,
            ai_max_search_term_ad_combination_view.landing_page,
            campaign.name,
            ad_group.name,
            metrics.impressions,
            metrics.clicks,
            metrics.conversions,
            metrics.cost_micros,
            metrics.cost_per_conversion,
            segments.date
        FROM ai_max_search_term_ad_combination_view
        WHERE campaign.id = {campaign_id}
        AND segments.date DURING LAST_30_DAYS
        AND metrics.impressions > 100
        ORDER BY metrics.conversions DESC
        LIMIT 100
    """

    response = ga_service.search_stream(customer_id=customer_id, query=query)

    # Analyze combinations
    combinations = []
    for batch in response:
        for row in batch.results:
            view = row.ai_max_search_term_ad_combination_view
            combinations.append({
                'search_term': view.search_term,
                'headline': view.headline,
                'landing_page': view.landing_page,
                'campaign': row.campaign.name,
                'ad_group': row.ad_group.name,
                'impressions': row.metrics.impressions,
                'clicks': row.metrics.clicks,
                'conversions': row.metrics.conversions,
                'cost': row.metrics.cost_micros / 1_000_000,
                'cpa': row.metrics.cost_per_conversion,
                'date': row.segments.date
            })

    return combinations

# Analyze top-performing combinations
combinations = get_ai_max_performance(client, "YOUR_CUSTOMER_ID", "CAMPAIGN_ID")

# Find best headlines by search intent
from collections import defaultdict
headline_performance = defaultdict(list)

for combo in combinations:
    conversion_rate = (
        combo['conversions'] / combo['clicks']
        if combo['clicks']
        else 0
    )
    headline_performance[combo['headline']].append({
        'search_term': combo['search_term'],
        'conversions': combo['conversions'],
        'conversion_rate': conversion_rate
    })

# Print top headlines
for headline, performance in sorted(
    headline_performance.items(),
    key=lambda x: sum(p['conversions'] for p in x[1]),
    reverse=True
)[:5]:
    total_conversions = sum(p['conversions'] for p in performance)
    avg_conv_rate = sum(p['conversion_rate'] for p in performance) / len(performance)
    print(f"Headline: {headline}")
    print(f"  Total Conversions: {total_conversions}")
    print(f"  Avg Conversion Rate: {avg_conv_rate:.2%}")
    print(f"  Used for {len(performance)} search terms")

Optimization Strategies

Best Practices for AI Asset Generation

Target ROAS Diversity Metrics

Query time-segmented diversity metrics for Search campaigns using Target ROAS:

# Python: Retrieve diversity metrics for Target ROAS
def get_diversity_metrics(client, customer_id, campaign_id):
    """Get time-segmented diversity metrics for Target ROAS campaigns"""
    ga_service = client.get_service("GoogleAdsService")

    query = f"""
        SELECT
            campaign.name,
            metrics.impressions,
            metrics.clicks,
            metrics.conversions,
            metrics.conversion_value,
            metrics.average_cpc,
            metrics.search_budget_lost_impression_share,
            metrics.search_rank_lost_impression_share,
            segments.hour,
            segments.day_of_week,
            segments.device
        FROM campaign
        WHERE campaign.id = {campaign_id}
        AND campaign.bidding_strategy_type = 'TARGET_ROAS'
        AND segments.date DURING LAST_7_DAYS
        ORDER BY segments.hour, segments.device
    """

    response = ga_service.search_stream(customer_id=customer_id, query=query)

    # Analyze diversity by time and device
    diversity_analysis = {
        'by_hour': {},
        'by_device': {},
        'by_day': {}
    }

    for batch in response:
        for row in batch.results:
            hour = row.segments.hour
            device = row.segments.device.name
            day = row.segments.day_of_week.name

            # Track performance by hour
            if hour not in diversity_analysis['by_hour']:
                diversity_analysis['by_hour'][hour] = {
                    'impressions': 0,
                    'conversions': 0,
                    'value': 0,
                    'cost': 0
                }

            diversity_analysis['by_hour'][hour]['impressions'] += row.metrics.impressions
            diversity_analysis['by_hour'][hour]['conversions'] += row.metrics.conversions
            diversity_analysis['by_hour'][hour]['value'] += row.metrics.conversion_value
            diversity_analysis['by_hour'][hour]['cost'] += row.metrics.cost_micros / 1_000_000

            # Similar tracking for device and day...

    # Calculate ROAS variance
    for hour, metrics in diversity_analysis['by_hour'].items():
        metrics['roas'] = metrics['value'] / metrics['cost'] if metrics['cost'] > 0 else 0

    return diversity_analysis

# Usage and analysis
diversity = get_diversity_metrics(client, "YOUR_CUSTOMER_ID", "CAMPAIGN_ID")

print("ROAS by Hour:")
for hour in sorted(diversity['by_hour'].keys()):
    metrics = diversity['by_hour'][hour]
    print(f"  Hour {hour:02d}: ROAS = {metrics['roas']:.2f}")

Example: Automated Campaign Creator with AI Assets

# Python: Automation sketch - create campaign with reviewed AI assets
from google.ads.googleads.client import GoogleAdsClient
import pandas as pd

class CampaignAutomator:
    def __init__(self, client, customer_id):
        self.client = client
        self.customer_id = customer_id

    def create_campaign_with_ai_assets(self, product_data):
        """
        Create complete campaign with AI-generated assets

        Args:
            product_data: dict with 'name', 'url', 'keywords', 'budget'
        """
        # Step 1: Generate text assets
        print("Generating AI text assets...")
        text_response = self.generate_assets(
            final_url=product_data['url'],
            keywords=product_data['keywords']
        )

        # Step 2: Generate image assets
        print("Generating AI image assets...")
        image_response = self.generate_images(
            final_url=product_data['url']
        )

        # Step 3: Human or policy review before campaign mutation
        reviewed_assets = self.review_generated_assets(
            text_response=text_response,
            image_response=image_response
        )

        # Step 4: Create campaign
        print("Creating campaign...")
        campaign = self.create_campaign(
            name=product_data['name'],
            budget=product_data['budget']
        )

        # Step 5: Create ad group
        print("Creating ad group...")
        ad_group = self.create_ad_group(
            campaign_id=campaign.id,
            name=f"{product_data['name']} - Ad Group"
        )

        # Step 6: Create responsive search ad with reviewed assets
        print("Creating responsive search ad...")
        ad = self.create_responsive_ad(
            ad_group_id=ad_group.id,
            headlines=reviewed_assets['headlines'],
            descriptions=reviewed_assets['descriptions'],
            final_url=product_data['url']
        )

        # Step 7: Add keywords
        print("Adding keywords...")
        self.add_keywords(
            ad_group_id=ad_group.id,
            keywords=product_data['keywords']
        )

        print(f"Campaign created successfully: {campaign.id}")
        return {
            'campaign_id': campaign.id,
            'ad_group_id': ad_group.id,
            'ad_id': ad.id
        }

    def generate_assets(self, final_url, keywords):
        """Generate text assets using AI"""
        asset_gen_service = self.client.get_service("AssetGenerationService")

        request = self.client.get_type("GenerateTextRequest")
        request.customer_id = self.customer_id
        request.final_url = final_url
        request.keywords.extend(keywords)

        return asset_gen_service.generate_text(request=request)

    def generate_images(self, final_url):
        """Generate image assets using AI"""
        asset_gen_service = self.client.get_service("AssetGenerationService")

        request = self.client.get_type("GenerateImagesRequest")
        request.customer_id = self.customer_id
        request.final_url = final_url

        return asset_gen_service.generate_images(request=request)

    def review_generated_assets(self, text_response, image_response):
        """Map beta responses into policy-approved ad text."""
        # Inspect response fields for your client-library version, then apply
        # brand, legal, and Google Ads policy checks before campaign mutation.
        return {
            'headlines': [
                'Reviewed headline 1',
                'Reviewed headline 2',
                'Reviewed headline 3',
            ],
            'descriptions': [
                'Reviewed description 1',
                'Reviewed description 2',
            ],
        }

    def create_campaign(self, name, budget):
        """Create campaign with standard settings"""
        campaign_service = self.client.get_service("CampaignService")

        # Create budget
        budget_resource = self.create_budget(budget)

        # Create campaign operation
        campaign_operation = self.client.get_type("CampaignOperation")
        campaign = campaign_operation.create

        campaign.name = name
        campaign.advertising_channel_type = (
            self.client.enums.AdvertisingChannelTypeEnum.SEARCH
        )
        campaign.status = self.client.enums.CampaignStatusEnum.PAUSED
        campaign.campaign_budget = budget_resource
        campaign.network_settings.target_google_search = True
        campaign.network_settings.target_search_network = True

        # Set bidding strategy
        campaign.manual_cpc.enhanced_cpc_enabled = True

        response = campaign_service.mutate_campaigns(
            customer_id=self.customer_id,
            operations=[campaign_operation]
        )

        return response.results[0]

    def create_budget(self, amount_micros):
        """Create campaign budget"""
        budget_service = self.client.get_service("CampaignBudgetService")
        budget_operation = self.client.get_type("CampaignBudgetOperation")

        budget = budget_operation.create
        budget.name = f"Budget {amount_micros}"
        budget.delivery_method = (
            self.client.enums.BudgetDeliveryMethodEnum.STANDARD
        )
        budget.amount_micros = amount_micros

        response = budget_service.mutate_campaign_budgets(
            customer_id=self.customer_id,
            operations=[budget_operation]
        )

        return response.results[0].resource_name

    def create_ad_group(self, campaign_id, name):
        """Create ad group"""
        ad_group_service = self.client.get_service("AdGroupService")
        ad_group_operation = self.client.get_type("AdGroupOperation")

        ad_group = ad_group_operation.create
        ad_group.name = name
        ad_group.status = self.client.enums.AdGroupStatusEnum.ENABLED
        ad_group.campaign = f"customers/{self.customer_id}/campaigns/{campaign_id}"
        ad_group.cpc_bid_micros = 1000000  # $1.00

        response = ad_group_service.mutate_ad_groups(
            customer_id=self.customer_id,
            operations=[ad_group_operation]
        )

        return response.results[0]

    def create_responsive_ad(self, ad_group_id, headlines, descriptions, final_url):
        """Create responsive search ad"""
        ad_group_ad_service = self.client.get_service("AdGroupAdService")
        ad_group_ad_operation = self.client.get_type("AdGroupAdOperation")

        ad_group_ad = ad_group_ad_operation.create
        ad_group_ad.ad_group = (
            f"customers/{self.customer_id}/adGroups/{ad_group_id}"
        )
        ad_group_ad.status = self.client.enums.AdGroupAdStatusEnum.ENABLED

        # Set ad details
        ad_group_ad.ad.final_urls.append(final_url)

        # Add headlines (up to 15)
        for headline in headlines[:15]:
            headline_asset = self.client.get_type("AdTextAsset")
            headline_asset.text = headline
            ad_group_ad.ad.responsive_search_ad.headlines.append(headline_asset)

        # Add descriptions (up to 4)
        for description in descriptions[:4]:
            desc_asset = self.client.get_type("AdTextAsset")
            desc_asset.text = description
            ad_group_ad.ad.responsive_search_ad.descriptions.append(desc_asset)

        response = ad_group_ad_service.mutate_ad_group_ads(
            customer_id=self.customer_id,
            operations=[ad_group_ad_operation]
        )

        return response.results[0]

    def add_keywords(self, ad_group_id, keywords):
        """Add keywords to ad group"""
        ad_group_criterion_service = self.client.get_service(
            "AdGroupCriterionService"
        )
        operations = []

        for keyword in keywords:
            operation = self.client.get_type("AdGroupCriterionOperation")
            criterion = operation.create

            criterion.ad_group = (
                f"customers/{self.customer_id}/adGroups/{ad_group_id}"
            )
            criterion.status = self.client.enums.AdGroupCriterionStatusEnum.ENABLED
            criterion.keyword.text = keyword
            criterion.keyword.match_type = (
                self.client.enums.KeywordMatchTypeEnum.BROAD
            )

            operations.append(operation)

        response = ad_group_criterion_service.mutate_ad_group_criteria(
            customer_id=self.customer_id,
            operations=operations
        )

        return response.results

# Usage
client = GoogleAdsClient.load_from_storage("google-ads.yaml")
automator = CampaignAutomator(client, "YOUR_CUSTOMER_ID")

# Create campaign with AI-generated assets
result = automator.create_campaign_with_ai_assets({
    'name': 'AI-Powered Campaign - Winter Sale',
    'url': 'https://example.com/winter-sale',
    'keywords': ['winter jackets', 'warm coats', 'outerwear sale'],
    'budget': 50_000_000  # $50/day
})

print(f"Campaign ID: {result['campaign_id']}")
print(f"Ad Group ID: {result['ad_group_id']}")
print(f"Ad ID: {result['ad_id']}")

Step 1: Update Client Libraries

pip install --upgrade google-ads

npm install google-ads-api

Step 2: Update API Version in Requests

# Python: Update to v22
from google.ads.googleads.client import GoogleAdsClient

# Configuration will automatically use the correct version
# based on your installed library version
client = GoogleAdsClient.load_from_storage("google-ads.yaml")

# Verify version
print(f"Using Google Ads API version: {client.get_service('GoogleAdsService')._version}")

Step 3: Test New Features Incrementally

• Week 1: Test AI asset generation on non-critical campaigns
• Week 2: Enable view-based conversions tracking and monitor
• Week 3: Implement AI Max reporting queries
• Week 4: Roll out to production campaigns