DEV Community

Richard Gibbons
Richard Gibbons

Posted on • Originally published at digitalapplied.com on

Google Ads API AI Automation: Complete October 2025 Guide

#googleads #api #automation #ppc

Master Google Ads API v22 with AI-powered automation. Learn view-based conversions, AI Max reporting, and generative asset creation. Complete implementation guide with production-ready code examples for October 2025.

What's New in Google Ads API v22

Released on October 15, 2025, Google Ads API v22 introduces significant AI-powered capabilities, enhanced reporting, and improved automation features. This update represents Google's push toward AI-driven advertising and greater transparency across campaign types.

Major Features in v22

  • AssetGenerationService (Beta): Generate text and image assets using generative AI based on URLs, prompts, keywords, and campaign context
  • View-Based Conversions: Track engaged-view conversions for Display and Video campaigns with improved attribution
  • AI Max Reporting: New ai_max_search_term_ad_combination_view provides detailed performance data for AI Max for Search campaigns
  • Performance Max Enhancements: Image enhancement, extraction automation, and enhanced reporting with feed_types field
  • Targetless Bidding for App Campaigns: New OPTIMIZE_IN_APP_CONVERSIONS_WITHOUT_TARGET_CPA and OPTIMIZE_TOTAL_VALUE_WITHOUT_TARGET_ROAS goals
  • Smart Bidding Diversity Metrics: Target ROAS strategies on Search can retrieve time-segmented diversity metrics

These updates make Google Ads API v22 the most AI-focused release to date, enabling advertisers to automate asset creation, gain deeper insights into AI-driven campaigns, and optimize performance with enhanced bidding strategies.

View-Based Conversions: Complete Setup Guide

View-based conversions (also called engaged-view conversions) allow you to track conversions from users who viewed your Display or Video ads but didn't click. This provides more complete attribution for upper-funnel campaigns.

What Are View-Based Conversions?

View-based conversions count when a user:

  • Views your video ad for at least 10 seconds
  • Views your Display ad (meets Engaged View requirements)
  • Converts within the attribution window without clicking
  • Has not clicked any of your ads more recently

Step 1: Enable View-Based Conversions

Configure view-based conversion tracking via the API:

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
Enter fullscreen mode Exit fullscreen mode

Step 2: Report on View-Based Conversions 

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)

    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
Enter fullscreen mode Exit fullscreen mode

Best Practices

  • Use 30-day attribution window for Display
  • Use 7-14 day window for Video
  • Exclude view conversions from automated bidding
  • Monitor view-to-click conversion ratio

Common Pitfalls

  • Including views in Smart Bidding too early
  • Setting attribution window too long
  • Not distinguishing view vs click conversions
  • Forgetting to exclude search remarketing

AI Max Reporting: Access Enhanced Insights

Google Ads API v22 introduces the ai_max_search_term_ad_combination_view report, providing unprecedented transparency into AI Max for Search campaign performance. This report shows how different combinations of search terms, headlines, and landing pages perform.

What AI Max Reporting Reveals

  • Performance metrics for search term + headline + landing page combinations
  • Which AI-generated headlines perform best for specific queries
  • Landing page effectiveness by search intent and user segment
  • Real conversion data to optimize AI Max campaign structure
  • Impression share and quality metrics at the combination level

Query AI Max Performance Data 

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_url,
            campaign.name,
            ad_group.name,
            metrics.impressions,
            metrics.clicks,
            metrics.conversions,
            metrics.cost_micros,
            metrics.average_cpc,
            metrics.conversion_rate,
            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)

    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_url,
                '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,
                'avg_cpc': row.metrics.average_cpc / 1_000_000,
                'conversion_rate': row.metrics.conversion_rate,
                'cpa': row.metrics.cost_per_conversion,
                'date': row.segments.date
            })

    return combinations
Enter fullscreen mode Exit fullscreen mode

AI-Powered Asset Generation Service

The new AssetGenerationService (beta) in API v22 allows you to generate text and image assets automatically using generative AI. This feature can create headlines, descriptions, and images based on your inputs like URLs, prompts, keywords, and existing campaign context.

Text Asset Generation

Generate headlines and descriptions from various inputs:

def generate_text_assets(client, customer_id, final_url, keywords=None, prompt=None):
    """Generate ad headlines and descriptions using AI"""
    asset_generation_service = client.get_service("AssetGenerationService")

    request = client.get_type("GenerateTextAssetsRequest")
    request.customer_id = customer_id
    request.final_url = final_url

    if keywords:
        request.keywords.extend(keywords)

    if prompt:
        request.prompt = prompt

    request.number_of_headlines = 10
    request.number_of_descriptions = 5
    request.headline_length_preference = "SHORT"

    response = asset_generation_service.generate_text_assets(request=request)

    generated_assets = {
        'headlines': [],
        'descriptions': []
    }

    for headline in response.headlines:
        generated_assets['headlines'].append({
            'text': headline.text,
            'length': len(headline.text),
            'confidence_score': headline.confidence_score
        })

    for description in response.descriptions:
        generated_assets['descriptions'].append({
            'text': description.text,
            'length': len(description.text),
            'confidence_score': description.confidence_score
        })

    return generated_assets
Enter fullscreen mode Exit fullscreen mode

Image Asset Generation

Generate images from existing assets or create new ones:

def generate_image_assets(client, customer_id, final_url=None, existing_images=None, prompt=None):
    """Generate image assets using generative AI"""
    asset_generation_service = client.get_service("AssetGenerationService")

    request = client.get_type("GenerateImageAssetsRequest")
    request.customer_id = customer_id

    if final_url:
        request.final_url = final_url

    if existing_images:
        for image_url in existing_images:
            request.existing_image_urls.append(image_url)

    if prompt:
        request.prompt = prompt

    request.aspect_ratio = "SQUARE"
    request.number_of_images = 5

    response = asset_generation_service.generate_image_assets(request=request)

    generated_images = []
    for image in response.images:
        generated_images.append({
            'url': image.url,
            'asset_id': image.asset_id,
            'width': image.width,
            'height': image.height,
            'size_bytes': image.size_bytes
        })

    return generated_images
Enter fullscreen mode Exit fullscreen mode

Best Practices for AI Asset Generation

Input Quality:

  • Use high-quality landing pages
  • Provide specific keywords
  • Write clear prompts
  • Include brand guidelines

Review & Test:

  • Always review generated assets
  • A/B test AI vs human-created
  • Monitor confidence scores
  • Iterate based on performance

Integration:

  • Automate for large catalogs
  • Combine with existing assets
  • Use for seasonal variations
  • Scale winning combinations

Performance Max Campaign Enhancements

Google Ads API v22 brings significant improvements to Performance Max campaigns, including image enhancement automation, image extraction features, and enhanced reporting capabilities with new segments and the feed_types field.

Image Enhancement

Automatically enhance product images for better performance:

  • Background removal and replacement
  • Automatic cropping and resizing
  • Quality improvements and filters
  • Format optimization for each placement

Enhanced Reporting

New segments and fields for better insights:

  • feed_types field for asset source tracking
  • New performance segments by asset group
  • Detailed conversion path reporting
  • Enhanced audience insights

Query Performance Max with New Fields 

def get_pmax_performance(client, customer_id):
    """Query Performance Max campaigns with enhanced reporting"""
    ga_service = client.get_service("GoogleAdsService")

    query = """
        SELECT
            campaign.name,
            campaign.id,
            asset_group.name,
            asset_group.id,
            asset_group_asset.feed_types,
            metrics.impressions,
            metrics.clicks,
            metrics.conversions,
            metrics.all_conversions,
            metrics.cost_micros,
            metrics.conversion_value,
            segments.asset_interaction_target.asset,
            segments.asset_interaction_target.interaction_on_this_asset,
            segments.date
        FROM asset_group_asset
        WHERE campaign.advertising_channel_type = 'PERFORMANCE_MAX'
        AND segments.date DURING LAST_30_DAYS
        AND campaign.status = 'ENABLED'
        ORDER BY metrics.conversions DESC
    """

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

    performance_by_feed = {}
    for batch in response:
        for row in batch.results:
            feed_types = row.asset_group_asset.feed_types

            for feed_type in feed_types:
                if feed_type not in performance_by_feed:
                    performance_by_feed[feed_type] = {
                        'impressions': 0,
                        'clicks': 0,
                        'conversions': 0,
                        'cost': 0,
                        'value': 0
                    }

                performance_by_feed[feed_type]['impressions'] += row.metrics.impressions
                performance_by_feed[feed_type]['clicks'] += row.metrics.clicks
                performance_by_feed[feed_type]['conversions'] += row.metrics.conversions
                performance_by_feed[feed_type]['cost'] += row.metrics.cost_micros / 1_000_000
                performance_by_feed[feed_type]['value'] += row.metrics.conversion_value

    for feed_type, data in performance_by_feed.items():
        data['roas'] = data['value'] / data['cost'] if data['cost'] > 0 else 0
        data['cpa'] = data['cost'] / data['conversions'] if data['conversions'] > 0 else 0

    return performance_by_feed
Enter fullscreen mode Exit fullscreen mode

Smart Bidding & Targetless Bidding

API v22 introduces targetless bidding for App campaigns, allowing rapid scaling without specific CPA or ROAS targets. Additionally, Target ROAS strategies on Search campaigns now support time-segmented diversity metrics for better performance analysis.

Targetless Bidding for App Campaigns

Perfect for rapid scaling when you don't have enough conversion data for target-based bidding:

def setup_targetless_bidding(client, customer_id, campaign_id, goal_type):
    """Configure targetless bidding for rapid scaling"""
    campaign_service = client.get_service("CampaignService")
    campaign_operation = client.get_type("CampaignOperation")

    campaign = campaign_operation.update
    campaign.resource_name = f"customers/{customer_id}/campaigns/{campaign_id}"

    if goal_type == "CONVERSIONS":
        campaign.bidding_strategy_type = (
            client.enums.BiddingStrategyTypeEnum.OPTIMIZE_IN_APP_CONVERSIONS_WITHOUT_TARGET_CPA
        )
    elif goal_type == "VALUE":
        campaign.bidding_strategy_type = (
            client.enums.BiddingStrategyTypeEnum.OPTIMIZE_TOTAL_VALUE_WITHOUT_TARGET_ROAS
        )

    field_mask = client.field_mask.build(
        campaign_operation.update,
        campaign
    )
    campaign_operation.update_mask.CopyFrom(field_mask)

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

    print(f"Updated campaign to targetless bidding: {response.results[0].resource_name}")
    return response
Enter fullscreen mode Exit fullscreen mode

Best Practices & API Limits

Rate Limits & Quotas

  • Daily operations: Unlimited (Standard), 15,000 (Basic)
  • Batch size: Maximum 10,000 operations per request
  • Requests per second: Throttle to 10-20 RPS
  • Asset generation: Beta limits may apply
  • Concurrent requests: Limit to 10 parallel

Optimization Tips

  • Use search_stream() for large datasets
  • Batch mutations to reduce API calls
  • Cache AI-generated assets for reuse
  • Implement exponential backoff for retries
  • Monitor API quota usage proactively

Common Pitfalls with v22 Features

  • AI Asset Generation: Always review generated assets before deployment; confidence scores don't guarantee brand alignment
  • View-Based Conversions: Don't include in Smart Bidding until you have sufficient data (30+ days)
  • Targetless Bidding: Monitor closely during first 2 weeks; costs can spike during learning phase
  • AI Max Reporting: Data may be sampled for high-traffic campaigns; use date ranges wisely

Migration Guide: Upgrading to API v22

Step 1: Update Client Libraries

Python:

pip install --upgrade google-ads==22.0.0
Enter fullscreen mode Exit fullscreen mode

Node.js:

npm install google-ads-api@22.0.0
Enter fullscreen mode Exit fullscreen mode

Step 2: Update API Version in Requests 

from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage("google-ads.yaml")

print(f"Using Google Ads API version: {client.get_service('GoogleAdsService')._version}")
Enter fullscreen mode Exit fullscreen mode

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

Breaking Changes & Deprecations

While v22 maintains backward compatibility with most features, be aware of these changes:

  • Some older campaign types may have limited support for new features
  • AssetGenerationService is beta; API surface may change
  • View-based conversions require updated conversion tracking tags
  • AI Max reporting requires AI Max for Search campaigns (not all accounts)

Real-World Use Cases

Case Study: E-commerce Retailer - AI Asset Automation

A fashion retailer with 5,000+ SKUs automated asset creation using the AssetGenerationService:

  • Challenge: Creating unique ad copy for thousands of products manually
  • Solution: AI-generated headlines and descriptions from product pages
  • Results: 85% time savings, 23% higher CTR vs manual ads

Case Study: Mobile App - Targetless Bidding Success

A gaming app used targetless bidding to rapidly scale user acquisition:

  • Challenge: Insufficient conversion data for target-based bidding
  • Solution: OPTIMIZE_IN_APP_CONVERSIONS_WITHOUT_TARGET_CPA
  • Results: 3x install volume in 14 days, 18% lower CPI

Case Study: B2B SaaS - View-Based Conversion Tracking

A SaaS company improved attribution for their video campaigns:

  • Challenge: Undervaluing YouTube campaigns due to click-only attribution
  • Solution: Enabled view-based conversions with 7-day window
  • Results: 42% increase in attributed conversions, 2.1x ROAS

Frequently Asked Questions

What is Google Ads API v22 and when was it released?

Google Ads API v22 was released on October 15, 2025. It introduces major AI-powered capabilities including AssetGenerationService (beta) for generating text and image assets, view-based conversions tracking for Display and Video campaigns, AI Max reporting with detailed performance insights, Performance Max enhancements, and targetless bidding for App campaigns. This is Google's most AI-focused API release to date.

How do I enable view-based conversions in Google Ads API v22?

Enable view-based conversions by setting the view_through_lookback_window_days field on your ConversionAction resource. Use a 30-day attribution window for Display campaigns and 7-14 days for Video campaigns. Set include_in_conversions_metric to true and choose a counting type (ONE_PER_CLICK or MANY_PER_CLICK). Wait at least 30 days after enabling before including view conversions in Smart Bidding to ensure sufficient data collection.

What is the AssetGenerationService and how does it work?

The AssetGenerationService (beta) in API v22 uses generative AI to automatically create text and image assets for your campaigns. You provide inputs like a final URL, keywords, or a freeform prompt, and the service generates optimized headlines, descriptions, and images. It can create up to 15 headlines and 4 descriptions per request, each with a confidence score. The service is free during beta with rate limits applied.

How does AI Max reporting differ from standard campaign reporting?

AI Max reporting uses the new ai_max_search_term_ad_combination_view resource to provide detailed performance metrics for specific combinations of search terms, headlines, and landing pages in AI Max for Search campaigns. This granular data shows which AI-generated headlines perform best for specific queries and which landing pages are most effective by search intent, enabling unprecedented optimization of AI-driven campaigns.

What is targetless bidding for App campaigns?

Targetless bidding allows App campaigns to optimize for conversions or total value without requiring specific CPA or ROAS targets. The two options are OPTIMIZE_IN_APP_CONVERSIONS_WITHOUT_TARGET_CPA and OPTIMIZE_TOTAL_VALUE_WITHOUT_TARGET_ROAS. This is ideal for new apps with limited conversion data that need to scale rapidly. Monitor closely during the first 2 weeks as costs can spike during the learning phase.

What are the API rate limits for Google Ads API v22 features?

Standard access accounts have unlimited daily operations; Basic access accounts have 15,000. Maximum batch size is 10,000 operations per request. Throttle to 10-20 requests per second and limit concurrent requests to 10. AssetGenerationService (beta) may have additional rate limits. Use search_stream() for large datasets, batch mutations to reduce API calls, and implement exponential backoff for retries to stay within quotas.

Top comments (0)