It’s an incredible time to be a developer in the advertising space. Innovation is moving at a breakneck pace, and we’re shifting from incremental API integrations to fundamental improvements in how technical users interact with our platforms. In the latest episode of Ads DevCast, I sat down with my colleague Matt Landers to discuss how AI is moving from "hype" to "utility," decreasing friction in development and delivering tangible business results.

The Power of Multi-Product Insights

One of the most exciting developments we’re seeing is the value of Advertising MCPs (Model Context Protocol) servers showing up. These open-standard tools allow your AI agents to interact directly with the Google Ads and Google Analytics APIs.

Historically, solving a problem like "why is my high-CTR ad not converting?" meant a lot of manual data joining between Ads and Analytics. By combining the Google Ads and Analytics MCPs, you can now perform this analysis in seconds using natural language. You can verify engagement rates, identify content mismatches on landing pages, and even suggest ROI improvements in the time it takes to brew a cup of coffee.

Efficiency and Speed with Natural Language

We’re also seeing AI make technical tasks more accessible. A great example is the recent update to our Sheets Report Builder add-on for Google Analytics 4. Previously, creating complex reports required manually adding dimensions, metrics, and filters in the UI. Now, with Gemini integrated directly into Sheets, you can simply ask, "What's my highest converting landing page?" and the tool automatically sets all the parameters in the UI, sends the API request, and imports the data for you.

The Senior Pair Programmer in Your CLI

For developers deep in the code, the Google Ads API Developer Assistant is a game-changer. Think of it as a senior pair programmer that has memorized the entire API schema and every possible error code. Whether you’re troubleshooting conversion uploads or finding hidden problems in your account, the assistant doesn’t just explain what’s wrong—it can generate, debug, and even run the fix directly in your environment.

Health, Diagnostics, and Seamless Migrations

Beyond AI-driven insights, we’re focused on improving the underlying health of your technical systems. The Data Manager API will soon feature integrated diagnostics in the UI, allowing you to track what went wrong with your integrations. Last but not least, for publishers, we’ve released a new migration skill for the AdMob SDK to help you transition between versions with the help of your coding agent.

Experiment, Fail Fast, and Build Great Things

The barrier to entry for building sophisticated, data-driven advertising solutions is dropping. By automating the busy work, you’re freed up to focus on high-impact projects that drive real business growth.

Ready to dive deeper?

Watch the full episode: goo.gle/watchadsdevcast

Listen on the go: goo.gle/listenadsdevcast

Take our Episode 3 Survey: goo.gle/adc-survey-e3

Join our Discord Community: goo.gle/ads-and-measurement-discord

Cory Liseno Google’s Advertising and Measurement Developer Relations team

We're excited to announce the launch of the new Google Advertising and Measurement Developers Hub!

Whether you're looking to automate campaigns, analyze performance, manage tags, or monetize your apps, the new hub is designed to make it easier to find the right tools and information.

We've launched a new technical-user focused site to make it easier than ever for you to find the tools, resources, and support you need to build and innovate with Google's advertising and measurement products.

What's New?

We have created a one-stop shop where you can easily find the resources you need, connect with our team and the community, and get support. Here are some key features:

• At-a-glance homepage: A clear starting point highlighting how we can help, with quick links to our blog, Discord, and information about our team.
• Meet the team: Learn more about the Developer Relations team dedicated to supporting your success.
• Products: A comprehensive directory of the developer products we cover, from the Google Ads API and Google Analytics APIs to Publisher Tools like AdMob and Ad Manager, linking directly to their official documentation. You can browse by categories like Advertising Platforms, Tagging, Measurement & Analytics, and Publisher Tools.
• Connect with us: A streamlined page to help you find the best way to engage:
  • Join our vibrant Discord community.
  • Find links to product or technical support.
  • Download open source projects on GitHub.
• Media and podcast: A new home for our multimedia content, including the Ads DevCast playlist embedded directly on the page.

We're excited to make this the place for you to learn, build, and connect.

Please explore the new site and use the Send Feedback button located at the bottom of each page to share your thoughts!

If you have any questions about this announcement or want to discuss it with our team and the community, please reach out to us on our "Google Advertising and Measurement Community" Discord server.

Happy Building!

- Aalap Shastri, Google Ads API Team

Version 25.0.0 of the Android Google Mobile Ads SDK is now available. We recommend upgrading as soon as possible to take advantage of the latest features, performance improvements, and API updates. This is a major version update that includes several breaking changes, new functionality for optimizing banner ad sizes, and important dependency updates.

New Large Anchored Adaptive Banner Size APIs

Unlock better performance with new banner ad sizes:

To better align with modern mobile devices, we are introducing the Large Adaptive Anchor API (e.g. AdSize.getLargeAnchoredAdaptiveBannerAdSize()). This update focuses solely on the sizing logic within adaptive anchor banners. While individual results may vary, larger ads are designed to increase engagement and revenue potential for publishers. The previous anchored adaptive APIs (e.g. AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize()) are now deprecated in favor of the new large anchored adaptive banner approach.

Old usage (Kotlin):

adView.setAdSize(AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, 360))

New usage (Kotlin):

adView.setAdSize(AdSize.getLargeAnchoredAdaptiveBannerAdSize(this, 360))

Breaking Changes and Removals

Version 25.0.0 is a major version with breaking changes that primarily impact mediation adapters and custom events.

API Removals:

• The VersionInfo class in the com.google.android.gms.ads.mediation package has been removed. Use com.google.android.gms.ads.VersionInfo instead.
• The deprecated getConfiguration() method in the RtbSignalData class has been removed. Developers should migrate to using getConfigurations() instead.
• The deprecated onFailure(String) and onAdFailedToShow(String) methods have been removed from the following callback classes:
  • SignalCallbacks
  • MediationAdLoadCallback
  • MediationInterstitialAdCallback
  • MediationRewardedAdCallback
The replacement methods are onFailure(AdError) and onAdFailedToShow(AdError).
  • The NativeAdViewHolder class has been removed from the com.google.android.gms.ads.nativead package.

For the full list of changes, please refer to the release notes. We strongly encourage you to review our migration guide to ensure your mobile apps are ready to upgrade.

SDK Deprecation Reminder

Per the deprecation schedule, the release of version 25.0.0 means that:

• Android Google Mobile Ads SDK versions 23.0.0 - 23.6.0 are officially deprecated.
• Android versions 22.0.0 - 22.6.0 will sunset on June 30, 2026.

We strongly recommend updating to a supported SDK version to avoid any disruption in ad serving and to benefit from the latest SDK features and fixes.

To comment on this blog post or engage with fellow developers, join the Google Mobile Ads SDK Discord channel and share your thoughts.

 - Jason Chiu, Mobile Ads Developer Relations

Version 13.0.0 of the Google Mobile Ads SDK for iOS is now available. We recommend upgrading as soon as possible to take advantage of the latest features, performance improvements, and API updates.

Updates in Version 13.0.0

• Increased minimum deployment target: The minimum supported iOS deployment target has been raised to iOS 13.
• Unlock better performance with new banner ad sizes: To better align with modern mobile devices, we are introducing the Large Adaptive Anchor API (e.g. largeAnchoredAdaptiveBanner). This update focuses solely on the sizing logic within adaptive anchor banners. While individual results may vary, larger ads are designed to increase engagement and revenue potential for publishers. The previous anchored adaptive APIs (e.g. currentOrientationAnchoredAdaptiveBanner) are now deprecated in favor of the new large anchored adaptive banner approach. For more API details, see the migration guide.

  Old usage (Swift):

  bannerView.adSize =
      currentOrientationAnchoredAdaptiveBanner(width: 375)

  New usage (Swift):

  bannerView.adSize = largeAnchoredAdaptiveBanner(width: 375)

• Swift 6 concurrency support: This release continues to enhance support for Swift 6 strict concurrency, such as updating our delegate methods to only be accessed on the main thread.
• Stricter type enforcement: The SDK will now raise an exception if any object that is not a String type is detected in the neighboringContentURLStrings array, ensuring better type safety.

For the full list of changes, please refer to the release notes. We strongly encourage you to review our migration guide to ensure your mobile apps are ready to upgrade.

SDK Deprecation Reminder

Per the deprecation schedule, the release of version 13.0.0 means that:

• iOS Google Mobile Ads SDK versions 11.x.x are now officially deprecated.
• Version 10.x.x will sunset on June 30, 2026.

We strongly recommend updating to a supported SDK version to avoid any disruption in ad serving and to benefit from the latest SDK features and fixes.

To comment on this blog post or engage with fellow developers, join the Google Mobile Ads SDK Discord channel and share your thoughts.

 - Justin Malandruccolo, Mobile Ads Developer Relations

We are announcing the Google Mobile Ads (GMA) Next-Gen SDK for Android, a significant rewrite of the Google Mobile Ads SDK that prioritizes speed, stability, and an improved developer experience. See the developer guides to get started today (AdMob | Ad Manager).

Currently available in Open Beta, the GMA Next-Gen SDK is scheduled for General Availability (GA) in July 2026. We encourage you to explore the new SDK and its potential benefits for your applications.

Advantages of the GMA Next-Gen SDK

• Improved Performance: Benefit from notable reductions in ad request latency. The new Google Mobile Ads SDK offers up to 27% faster ad request latency for banner ads than our previous version¹. The new SDK also features background initialization to minimize impact on application startup times.
• Reduced Application Size: The new Google Mobile Ads SDK file size is up to 17% smaller than our previous version².
• Modern Language Support: Developed in Kotlin, the SDK provides idiomatic APIs for developers working in both Kotlin and Java.
• Faster Release Cycles: The GMA Next-Gen SDK benefits from a more frequent and regular release schedule, providing quicker access to new features and bug fixes.
• Comprehensive Feature Support: Continues to use all existing Google Mobile Ads formats and features within your applications.

Early adoption successes

Publishers participating in the beta program have reported positive outcomes compared to the previous SDK:

• 50% increase in Average Revenue Per User (ARPU).
• 91.5% uplift in Average Revenue Per Daily Active User (ARPDAU).
• 1/3 reduction in ANR rate and a 50% reduction in slow cold starts.
• 16% increase in fill rate.

Further details on these outcomes can be found in the GMA Next-Gen SDK success stories.

Live events

The following upcoming live events are encouraged for those interested in the GMA Next-Gen SDK:

• Introductory webinar: An overview focused on the advantages of the GMA Next-Gen SDK and best practices for implementation.
  • EMEA/APAC session: Live webinar broadcasted on February 19th. (Register)
  • AMER session: Live viewing of recording on February 24th. (Register)
  • February 26th - Discord technical overview session: A technical introduction of the GMA Next-Gen SDK specifically for developers. Register (Accept Invite)
  • March 4th - Discord banner migration live coding session: A practical demonstration of migrating banner ads from the previous SDK to the GMA Next-Gen SDK. Register (Accept Invite)
  • March 11th - Migration hackathon: AI-Based migration to the GMA Next-Gen SDK with a dedicated MCP server and vibe coding. If interested, please reach out to your Google account manager.

Implementation resources

Get started with these Next-Gen SDK resources:

1. Integration guide: The latest version and setup instructions are available in our GMA Next-Gen SDK Get Started guide (AdMob | Ad Manager).
2. Migration guide: Instructions to migrate to the GMA-Next Gen SDK (AdMob | Ad Manager).
3. Developer samples: Example applications demonstrating SDK usage are available in our GitHub repository.
4. Introduction video: For an overview of the SDK's benefits, please watch our introductory video.

We invite you to integrate the Google Mobile Ads Next-Gen SDK and discover the performance and stability enhancements it can bring to your Android applications.

If you have any questions or need additional help, please join the GMA Next-Gen SDK channel to share your thoughts and get in contact with the team.

 - Justin Malandruccolo, Mobile Ads Developer Relations

¹ Google Internal Data, Latency Measurement for Banner Ads, Google Mobile Ads SDK vs. New Google Mobile Ads SDK, August 21, 2025 to September 3, 2025.

² Google Internal Data, Increase to app file size when adding the SDK, Google Mobile Ads SDK vs. new Google Mobile Ads SDK, September 29, 2025.

Today, we’re announcing you can start adding Google Mobile Ads mediation adapters to your iOS projects using Swift Package Manager (SPM).

Swift Package Manager is Apple's first-party tool for managing project dependencies. By supporting SPM, we're making it easier for you to integrate and manage our mediation adapters, helping you streamline your development workflow and reduce setup complexity.

Which adapters are supported?

We're planning to roll out SPM support for all open source and versioned adapters. Each adapter will be in its own dedicated GitHub repository.

Adapters currently available:

Add a Swift Package to your project

To add a package dependency to your Xcode project, navigate to File > Add Package Dependencies… and search for the package using each adapter's corresponding GitHub URL:

Adapters coming soon

We're continuing to roll out Swift Package Manager support for more mediation adapters. Check the list of currently supported adapters by visiting our GitHub page.

If you have any questions or want to discuss this post, please reach out to us on our “Google Advertising and Measurement Community” Discord server.

 - Justin Malandruccolo, Mobile Ads Developer Relations

We’re launching our new “Google Advertising and Measurement Community” Discord server! To join, just click this invite link and follow the onboarding guide.

The current products available on this server are Analytics, Google Ads, Google AdMob, and Google Ad Manager.

The Ads Developer Relations team will be on this server regularly to discuss your feedback or questions using Google’s Advertising and Analytics APIs/SDKs, as well as to let you know what’s new with our products.

We’ll be hosting a “Meet the Team” in August, where we’ll go over who we are, and how you can expect to engage with us in Discord. Stay tuned as we add other events, and more channels.

Looking forward to chatting with you on Discord!

- Cory Liseno, on behalf of the Ads Developer Relations Team

Version 24.0.0 of the Android Google Mobile Ads SDK is now available. To take advantage of the latest features and performance improvements, we highly recommend you configure your app to upgrade as soon as possible. Major changes to the SDK are as follows:

Minimum Android API level

Starting with version 24.0.0, the Google Mobile Ads SDK requires all apps to be on a minimum Android API level of 23. To adjust the API level, change the value of minSdk in your app-level build.gradle file to 23 or higher.

Optimized initialization and ad loading

By default, The OPTIMIZE_INITIALIZATION and OPTIMIZE_AD_LOADING flags are now generally available and set to true. These flags help reduce ANRs. You can further prevent ANRs by initializing the Google Mobile Ads SDK on a background thread. For more information, see Optimize initialization and ad loading.

Removed ad services config in AndroidManifest.xml

To prevent merge conflicts for apps that configure API-specific Ad Services, we've removed the android.adservices.AD_SERVICES_CONFIG property tag from the SDK’s manifest file. This change provides greater flexibility for developers who need to customize their Ad Services configurations.

SDK deprecation and sunset timelines activated

With this Android major version 24 launch and the iOS major version 12 launch last month, new deprecation and sunset dates for older releases are as follows:

• Android Google Mobile Ads SDK versions 22.0.0 - 22.6.0 are officially deprecated, and will sunset in June 2026.
• Android versions 21.x.x and iOS versions 9.x.x will sunset on June 30, 2025.
  • While there are currently no plans to disable ad serving on Android versions 21.x.x and iOS versions 9.x.x, we strongly recommend updating to the latest SDK version to avoid future impactions.

For a complete list of changes in v24.0.0 and detailed migration steps, check the release notes and SDK migration guide. If you have any questions or need additional help, contact us through Mobile Ads SDK Support.

 - Eric Leichtenschlag, Mobile Ads Developer Relations

Version 12.0.0 of the Google Mobile Ads SDK is now available. We recommend upgrading as soon as possible to get our latest features and performance improvements.

Updated Swift APIs

We’ve updated the Google Mobile Ads SDK to define an NS_SWIFT_NAME for every API to follow the naming conventions from Apple’s Swift API Design Guidelines. For example, we have:

• Removed the GAD prefix across names for all types.
• Renamed the GAM prefix to AdManager.
• Renamed the GADM prefix to Mediation.

For the full list of Swift API name changes, see Swift naming support.

Swift 6 Concurrency

Swift 6 concurrency support is being rolled out incrementally, starting this release with added support for our ad format delegate methods. Future SDK versions will include further improvements.

Changes to Xcode requirements

The minimum supported Xcode version has been bumped to 16.0.

For the full list of changes, check the release notes. Check our migration guide to ensure your mobile apps are ready to upgrade.

SDK Deprecation Reminder

Per the deprecation schedule, the release of version 12.0.0 means that:

• iOS Google Mobile Ads SDK versions 10.x.x are officially deprecated, and will sunset in Q2 2026.
• Versions 9.x.x and below will sunset on June 30, 2025.
  • While there are currently no plans to disable ad serving on version 9.x.x, we strongly recommend updating to a supported SDK version to avoid being impacted in the future.

As always, if you have any questions or need additional help, contact us via the developer forum.

 - Justin Malandruccolo, Mobile Ads Developer Relations

Ad inspector is an in-app overlay that enables authorized devices to perform real-time analysis of Google Mobile Ads SDK test ad requests directly within your mobile app. It is included with the Google Mobile Ads SDK and you can enable it with no coding required.

Ad inspector empowers you to thoroughly test all your ad sources before releasing those changes to your users so you can verify everything is working properly. To help you understand and utilize ad inspector effectively, we published a 7-part ad inspector video series on our Google AdMob YouTube channel.

Each video focuses on a specific challenge in testing your ad integration, offering in-depth tutorials and demonstrations on how to:

• Launch ad inspector
• Debug ad requests
• Inspect your third-party adapters
• View mediation details
• View bidding details
• Inspect privacy signals
• Export ad data to support teams

Check out our ad inspector documentation (Android, iOS, Unity, Flutter) to learn more. If you have questions, comments, or general feedback about ad inspector, contact us in the developer forum. And remember to subscribe to our Google AdMob YouTube channel for more technical content.

 - Justin Malandruccolo, Mobile Ads Developer Relations

We heard your feedback via Play Console crash reports regarding Application Not Responding (ANRs) errors related to the Google Mobile Ads SDK. After analyzing these reports, we updated our SDK implementation best practices to reduce ANR rates. The recommended best practices are as follows:

1. Initialize the Mobile Ads SDK on a background thread
2. Enable optimization flag for ad loading

1. Initialize the Mobile Ads SDK on a background thread

Our previous best practice was to specify the OPTIMIZE_INITIALIZATION manifest flag. However, some work on the calling thread is still required to prepare MobileAds to handle other method calls synchronously.

We now recommend calling MobileAds.initialize() on a background thread, enabling the work required on the calling thread to happen in the background.

import com.google.android.gms.ads.MobileAds
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    CoroutineScope(Dispatchers.IO).launch {
      // Initialize the Google Mobile Ads SDK on a background thread.
      MobileAds.initialize(this@MainActivity) {}
      runOnUiThread {
        // Load an ad on the main thread.
        loadAd()
      }
    }
  }
}

Note: When calling MobileAds.initialize() on a background thread, the OPTIMIZE_INITIALIZATION manifest flag is no longer required.

2. Enable optimization flag for ad loading

By enabling the OPTIMIZE_AD_LOADING manifest flag, you can offload most ad loading tasks to a background thread. We recommend enabling this flag in your app's AndroidManifest.xml file to reduce the occurrence of ad loading causing ANRs.

<manifest>
  ...
  <application>
      ...
      <meta-data
          android:name="com.google.android.gms.ads.flag.OPTIMIZE_AD_LOADING"
          android:value="true"/>
  </application>
</manifest>

We’ve updated all of our Android example apps to implement these best practices. For more details on initialization and optimization flags, see Get started and Optimize initialization and ad loading. Contact us if you have any questions or need additional help.

 - Joshua Hui, Mobile Ads Developer Relations

Version 23.0.0 of the Android Google Mobile Ads SDK is now available. We recommend upgrading as soon as possible to get our latest features and performance improvements.

The minimum Android API level is 21

Starting in version 23.0.0, the Google Mobile Ads SDK requires all apps to be on a minimum Android API level 21 to run. To adjust the API level, change the value of minSdk in your app-level build.gradle file to 21 or higher.

Ad Manager builder methods can now be chained

In version 23.0.0, AdManagerAdRequest.Builder methods inherited from its parent can be chained together to build an AdManagerAdRequest using a single call:

var newRequest = AdManagerAdRequest.Builder()
  .addCustomTargeting("age", "25") // AdManagerAdRequest.Builder method.
  .setContentUrl("https://www.example.com") // Method inherited from parent.
  .build() // Builds an AdManagerAdRequest.

A side effect of this change is AdManagerAdRequest.Builder no longer inherits from AdRequest.Builder.

SDK deprecation and sunset timelines activated

With this Android major version 23 launch and the iOS major version 11 launch last month, we are announcing new deprecation and sunset dates for older major releases. Specifically:

• Android Google Mobile Ads SDK versions 21.x.x are officially deprecated, and will sunset in Q2 2025.
• Android versions 20.x.x and iOS versions 8.x.x will sunset on June 30, 2024.
  • While there are currently no plans to disable ad serving on Android versions 20.x.x and iOS versions 8.x.x, we strongly recommend updating to a supported SDK version to avoid being impacted in the future.

For the full list of changes in v23.0.0, check the release notes. Check our migration guide to ensure your mobile apps are ready to upgrade. As always, if you have any questions or need additional help, contact us via the developer forum.

 - Jill Song, Mobile Ads Developer Relations

Today, we are announcing that version 11.0.0 of the Google Mobile Ads SDK is now available. We recommend upgrading as soon as possible to get our latest features and performance improvements.

Simplified SwiftUI development

Version 11.0.0 no longer requires publishers to declare a view controller to present full-screen ads. As a result, SwiftUI Publishers can now present full-screen ads without the need for UIKit or UIViewControllerRepresentable workarounds. See our SwiftUI guide for more information.

struct ContentView: View {
  private let adCoordinator = AdCoordinator()

  var body: some View {
    ...

    Button("Watch an ad") {
      adCoordinator.showAd()
    }
  }
}

private class InterstitialAdCoordinator: NSObject, GADFullScreenContentDelegate {
  private var interstitial: GADInterstitialAd?

  ...

  func showAd() {
    guard let interstitial = interstitial else {
      return print("Ad wasn't ready")
    }

    // The SDK uses the app's main window to look up view controllers
    // automatically when one is not provided.
    interstitial.present(fromRootViewController: nil)
  }
}

Continue collecting user metrics in AdMob

The Google Mobile Ads SDK dependency on GoogleAppMeasurement has been removed. This dependency that powered the user metrics toggle in AdMob will be discontinued in early 2024. To continue collecting user metrics in AdMob, link your AdMob app to Firebase and integrate the Google Analytics for Firebase SDK into your app.

Changes to minimum OS and Xcode requirements

• The minimum OS version to load ads has been bumped from 12 to 13. Applications can still be built for iOS 12, but the SDK will only load ads on iOS 13 and higher.
• The minimum supported Xcode version has been bumped to 15.1.

For the full list of changes, check the release notes. Check our migration guide to ensure your mobile apps are ready to upgrade.

SDK Deprecation Reminder

Per the deprecation schedule, the release of version 11.0.0 means that:

• iOS Google Mobile Ads SDK versions 9.x.x are officially deprecated, and will sunset in Q2 2025.
• Versions 8.x.x and below will sunset in Q2 2024, approximately 60 days following the release of Android Google Mobile Ads SDK major version 23.0.0.
  • While there are currently no plans to disable ad serving on version 8.x.x, we strongly recommend updating to a supported SDK version to avoid being impacted in the future.

As always, if you have any questions or need additional help, contact us via the developer forum.

 - Justin Malandruccolo, Mobile Ads Developer Relations

In case you missed it, we announced new consent management platform requirements for serving ads in the EEA and UK. Beginning January 16, 2024, Google will require all publishers to use a Google-certified consent management platform (CMP) when serving ads to users in the European Economic Area or the UK.

In addition to growing our list of certified CMPs, we explored how to improve the User Messaging Platform (UMP) SDK developer experience for those who choose to use Google’s consent management solution. We are excited to share several updates in the latest iOS and Android versions that we think will streamline your integration.

Loading and presenting a consent form

The latest UMP SDK release introduces a new API, loadAndPresentIfRequired(), that consolidates the existing individual load and present consent form methods into a single method. The new API loads a consent form and if consent is required, automatically presents the consent form. This method is intended to be used at the beginning of a new app session.

Here is a code example of how to use the new API on iOS:

class ViewController: UIViewController {

  private var isMobileAdsStartCalled = false

  override func viewDidLoad() {
    super.viewDidLoad()

    UMPConsentInformation.sharedInstance.requestConsentInfoUpdate(with: parameters) {
      [weak self] requestConsentError in
      guard let self else { return }

      // Call the helper method once consent information has been updated.
      UMPConsentForm.loadAndPresentIfRequired(from: self) {
        [weak self] loadAndPresentError in
        guard let self else { return }

        if UMPConsentInformation.sharedInstance.canRequestAds {
          self.startGoogleMobileAdsSDK()
        }
      }
    }

    // canRequestAds will be true if consent was gathered in the previous session.
    if UMPConsentInformation.sharedInstance.canRequestAds {
      startGoogleMobileAdsSDK()
    }
  }

  private func startGoogleMobileAdsSDK() {
    DispatchQueue.main.async {
      guard !self.isMobileAdsStartCalled else { return }

      self.isMobileAdsStartCalled = true

      // Initialize the Google Mobile Ads SDK.
      GADMobileAds.sharedInstance().start()
      // Request an ad.
      GADInterstitialAd.load(...)
    }
  }
}

Checking when to request ads

We added a new boolean property canRequestAds to use as a check before initializing the Google Mobile Ads SDK and requesting ads. canRequestAds returns true when the consent status is either OBTAINED or NOT_REQUIRED; as a result you don’t need to implement any enum checking yourself.

You should use the canRequestAds API in two places (as seen in the code snippet above):

1. Once consent has been gathered in the current session.
2. Immediately after you have called requestConsentInfoUpdate. It is possible consent has been gathered in the previous session in which case it is not necessary to wait for the callback to finish.

Checking privacy options requirement status

GDPR requires that publishers allow users to withdraw their consent choices at any time. It should be as easy to withdraw consent as it is to gather consent. To simplify this process, we have added two new APIs:

1. privacyOptionsRequirementStatus to determine whether you should include a UI element that can re-present the consent form, such as a button in your application’s settings page.
2. presentPrivacyOptionsForm() to show the form so the user can update their consent status at any time.

Here is a code example of how to use the new APIs on iOS:

// Show a privacy options button if required.
private var isPrivacySettingsButtonEnabled: Bool {
  return UMPConsentInformation.shared.privacyOptionsRequirementStatus == .required
}

// Present the privacy options form when a user interacts with your app.
@IBAction func privacySettingsTapped(_ sender: UIBarButtonItem) {
  UMPConsentForm.presentPrivacyOptionsForm(from: self) {
    [weak self] formError in
    guard let self, let formError else { return }

    // Handle the error.
  }
}

Developer resources

We updated our AdMob banner samples applications for iOS and Android to showcase integrating the UMP SDK. Keep an eye out as we add UMP SDK support to the rest of our samples soon.

Also take a look at our iOS and Android developer documentation for instructions on how to implement the UMP SDK.

If you have any questions or need additional help integrating the UMP SDK, please contact us via the developer forum.

 - Justin Malandruccolo, Mobile Ads Developer Relations

We’re excited to announce the launch of new testing features on ad inspector across all platforms for our AdMob and Ad Manager publishers.

Previously, ad inspector tested all ads in context - in other words, you had to fire up your app, navigate to the appropriate screen in the UI, and have your ad load as it would for any other user. While this provides for the most accurate testing scenario, it also puts more work on you as the publisher and tester of your app. You don’t want ads buried in more obscure screens in your app to lose out on the testing attention and care they need!

With our latest update, you can now use test ads to load requests for any ad unit - no matter where it's located in your app. Rather than needing to navigate through your app to test each ad unit, you can execute your tests directly from ad inspector.

How do I use ad inspector’s new testing features?

Beginning with version v10.0.0 on iOS and v21.4.0 on Android of the Google Mobile Ads SDK, ad inspector supports running tests directly from the ad unit detail screen via a “Request test ad” button:

All of your requests made from your app’s UI or within ad inspector will appear in the SDK request log; your requests made from within ad inspector will be differentiated by being labeled with “Requested from ad inspector”. For these special requests you’ll be able to tap the “View” button one time to view the actual ad, see which network filled the slot, and more.

Alongside single ad source testing, these new testing features will allow you to rigorously test each individual ad network integration in your app.

To learn more about how to test your ads with ad inspector, check out our developer guides here:

• Android (AdMob | Ad Manager)
• iOS (AdMob | Ad Manager)
• Flutter (AdMob | Ad Manager)
• Unity (AdMob)
• C++ (AdMob)

If you have any questions or need additional help, please contact us via the developer forum.

 - Chris Giglio, Mobile Ads Developer Relations

We are excited to announce the release of Version 8 of the Google Mobile Ads for Unity plugin! This new version contains a number of new features and upgraded APIs.

Minimum Unity version is now 2019.4

The Google Mobile Ads Unity plugin now has a minimum Unity Engine version requirement of 2019.4. This was done to align with Unity’s long term support.

Compatibility with Android v22.0.0

This release supports the Android Google Mobile Ads SDK version 22.0.0 major version release.

User Messaging Platform (UMP) support

The Google Mobile Ads Unity plugin now includes support for the Google User Messaging Platform (UMP) to help you gather consent from app users. To enable UMP support, see the user privacy get started guide.

Plugin now has C# reference documentation

With the release of version 8, we now have launched C# reference documentation. Moreover, this version added xml-doc summaries to all public fields, properties, methods, and classes. This makes the plugin easier to use and provides full IntelliSense support when developing in Visual Studio.

Migrate ad format events to the new interface

Full-screen ad formats APIs now have a uniform interface and we are removing the old ad event APIs. These changes make the APIs for each ad format more consistent and easier to use. The new interface includes a static Load() method, use of generic delegates instead of EventArgs, and consistent ad events names across formats.

For a full list of changes and steps for upgrading your code, please see the version 8 migration guide.

Use RaiseAdEventsOnUnityMainThread() to guarantee thread safety

The Google Mobile Ads Unity plugin now includes an optional support feature for Unity thread safety. This feature means you no longer need to manage threading concerns when handling platform events or callbacks.

If you use this feature, the SDK may pause events during full screen ad presentations. This means that you might not get some events, like OnAdFullScreenContentOpened or OnAdImpressionRecorded, until after the user comes back to the game. If you need to collect this data in real time, this might not be a good option. We recommend you test this feature to see if it works for you.

Here's an example of how to use Google Mobile Ads new thread safety support:

Deprecation of Ad Placements

The Google Mobile Ads Unity plugin's Ad Placements feature is deprecated. There are no plans to move it into public release.

If you have any questions or concerns about migrating your project, please reach out on our developer forum.

 - Nicholas Ventimiglia, Mobile Ads Developer Relations

We are excited to announce the release of our newest version of the Google Mobile Ads SDK. We recommend upgrading as soon as possible to stay up-to-date with our latest features.

Version 22.0.0 Changes

Google Mobile Ads SDK version 22.0.0 introduces a few major changes:

• MobileAds.getVersionString() is removed in version 22.0.0 in favor of MobileAds.getVersion(). The new method returns the expected external version number (for example, 22.0.0), helping you more clearly identify your SDK version. For more information about this change, see the Use the new Google Mobile Ads SDK getVersion() method blog post.
• In version 21, the Google Mobile Ads SDK provided you the NativeCustomFormatAd.getVideoMediaView() method to get the media asset for an Ad Manager native custom ad format. In version 22, NativeCustomFormatAd provides direct access to getMediaContent() enabling you to define your MediaView in layout files along with the rest of your other views, and simply populate that view with its content once the ad loads.

See release notes for the full changelog. See our migration guide to help you migrate your apps.

SDK deprecation/sunset activated

Per the deprecated schedule announced last year, the release of iOS version 10.0.0 in February and this Android version 22.0.0 release activate the sunset period of earlier Android/iOS releases. Specifically:

• Android Google Mobile Ads SDK version 20.x.x is officially deprecated, meaning that you will be asked to update to at least version 21.0.0 to receive full support from the Google Mobile Ads SDK developer forum.
• Android versions 19.x.x and below, as well as iOS versions 7.x.x will sunset on June 30th, 2023, meaning that ad serving could be disrupted. See details below.

Updated definition of sunset

We remain committed to regularly disabling old SDK versions balanced with minimizing disruption to ad serving. Aligned with this goal, we are making some changes to the previously announced sunset definition for 2023:

1. We previously communicated that the sunset notice period would be 2 months. For this 2023 sunset, the sunset date is June 30th, approximately 3 months notice.
2. We will leverage the “Outdated” feature on the Google Play SDK Index, requiring you to move off a sunset SDK version for future releases of your Android apps. See Understanding issues with your app’s third-party SDK for more information.
3. Starting June 30th, you may notice some disruptions in your ad serving. While we do not plan to stop ad serving for iOS version 7.x.x and Android versions 19.x.x and earlier at this time, we will regularly review usage of all sunset versions going forward to consider disabling ad serving. The oldest versions with lower usage and higher maintenance costs will be targeted first. Therefore, ad traffic from sunset SDKs versions will be at risk of receiving automatic no fill due to stopped ad serving going forward.

To avoid disruptions in ad serving, we highly recommend upgrading to a supported version as soon as possible so your users have a chance to update before June 30th, 2023.

Check if your apps are affected

To help you prepare for these changes, there are several ways you can check if your apps are affected:

• Use the Ads Activity report and enable the “GMA SDK” dimension to see iOS app traffic running on iOS 7.x.x or earlier. Currently, only the Google Mobile Ads SDK for iOS is supported.
• In Android Studio, check your build.gradle file for build warnings, which are thrown when compiling with Android SDK version 19.x.x or earlier.
• Check your console logs for warning logs when making ad requests.

As always, if you have any questions or need additional help, contact us through the developer forum.

 - Jill Song, Mobile Ads Developer Relations

Today, we’re excited to announce the launch of our 2023 Google Mobile Ads SDK Developer Survey. As part of our efforts to continue updating the AdMob and Ad Manager products, we’d like to hear from you about where we should focus our efforts. This includes product feedback as well as feedback on our guides, code samples and other resources. Your feedback will help shape our future product and resource roadmap.

This anonymous survey should only take about 15 minutes to complete and will provide our team with your valuable feedback as we plan for the months ahead. Whether you’re an engineer, Ad Ops personnel, or a PM, your feedback on AdMob, Ad Manager, and the Google Mobile Ads SDK is valuable to us. We appreciate you taking the time to help improve our developer experience!

 - Chris Giglio, Mobile Ads Developer Relations

The volume control APIs provided by the Google Mobile Ads SDK are intended to mirror your app’s own custom volume controls. Utilizing these APIs ensures that the user receives video ads with the expected audio volume.

We’ll talk about some best practices implementing the volume control APIs in your iOS, Android or Unity project.

Why are we mentioning this?

Publishers can lose revenue when using these APIs to lower or mute the volume of the Google Mobile Ads SDK. Two issues we have commonly seen:

1. Apps are using their own custom volume controls not sending the app’s accurate volume to the Google Mobile Ads SDK, but always sending zero
2. App are just muting the SDK

Some apps have close to a 100% mute rate which doesn’t sound correct (pun intended). Setting application volume to zero or muting the application reduces video ad eligibility, which as a result may reduce your app’s ad revenue.

Volume control APIs

The Google Mobile Ads SDK offers two volume control APIs: setting the volume and toggling mute. These APIs are applicable to App Open, Banner, Interstitial, Rewarded and Rewarded Interstitial ad formats. For Native ads, use GADVideoOptions.

Setting application volume on each platform

Use applicationVolume to set your custom volume relative to the device volume. The range can be from 0.0 (silent) to 1.0 (current device volume). For example, if the device volume level was at half level and the user set your app’s custom volume to max level, set the applicationVolume to 1.0 and the user will receive an ad with the volume at half level.

Setting application mute on each platform

Use applicationMuted if your custom volume controls include a mute button. Only toggle applicationMuted if the user selects your custom mute button. For example, if the user adjusts your custom volume to 0 you do not need to call applicationMuted; just call applicationVolume = 0.0.

Setting mute for native ads on each platform

let videoOptions = GADVideoOptions()
videoOptions.startMuted = true
adLoader = GADAdLoader(
    adUnitID: "AD_UNIT_ID",
    rootViewController: self,
    adTypes: [ ... ad type constants ... ],
    options: [videoOptions])

val videoOptions = VideoOptions.Builder()
        .setStartMuted(false)
        .build()
val adOptions = NativeAdOptions.Builder()
        .setVideoOptions(videoOptions)
        .build()
val adLoader = AdLoader.Builder(this, "AD_UNIT_ID")
        .forNativeAd( ... )
        .withNativeAdOptions(adOptions)
        .build()

Use startMuted if your custom volume controls include a mute button. Only toggle startMuted if the user selects your custom mute button.

Best Practices

To use our APIs as intended:

1. applicationVolume should be called only when your custom volume control settings are set to reflect the new volume
2. applicationMuted or startMuted should only be toggled to true if the user has muted your custom volume

As a rule of thumb, if your app does not have custom volume controls then you should not use these APIs.

What should you do?

To verify that your mobile applications are using these APIs correctly, we recommend that you enable test ads and force load a video test ad in your application. If your app has custom volume controls, the ad’s volume should be at the same level as the custom volume. Otherwise, the ad’s volume should match the device volume.

If you have any questions or need additional help, please contact us via the forum.

 - Justin Malandruccolo, Mobile Ads Developer Relations

We are excited to announce the release of our newest version of the Google Mobile Ads SDK. We recommend upgrading as soon as possible to stay up-to-date with our latest features.

Version 10.0.0 Changes

Google Mobile Ads SDK version 10.0.0 introduces a few major changes:

• The minimum OS version has been bumped from 11 to 12. Given the high adoption rate of iOS 16, we are continuing the trend of incrementing the minimum support level. Applications can still be built for iOS 11, however, the SDK will not load any ads on iOS 11.
• Since bitcode is deprecated in Xcode 14, we have disabled bitcode in the SDK. As a result, this has decreased the download size of our SDK by ~35MB. What this means for you is to integrate with SDK version 10.0.0, you also have to disable bitcode (if you haven’t already) in the build settings of your Xcode project.
• Ad Manager applications require an app ID upon initialization of the SDK. This also means the key GADIsAppManagerApp will no longer bypass this check. App IDs are added to the Info.plist with a key of GADApplicationIdentifier. See Update your Info.plist for more details.
• Ad Manager applications require GoogleAppMeasurement.xcframework as a dependency. If you install the Google Mobile Ads SDK through CocoaPods or Swift Package Manager, no additional action is required. If you install frameworks manually, see Manual Download for more details.
• We also have removed deprecated APIs of various properties and classes.

For the full list of changes, check the release notes. Check our migration guide to ensure your mobile apps are ready to upgrade.

SDK Deprecation Reminder

Per the deprecation schedule announced last year, the release of version 10.0.0 means that:

• iOS Google Mobile Ads SDK versions 8.x.x is officially deprecated, and will sunset in Q2 2024.
• Versions 7.x.x and below will sunset sometime in Q2 2023, approximately 60 days following the release of Android Google Mobile Ads SDK major version 22.0.0.

As always, if you have any questions or need additional help, contact us via the forum.

 - Justin Malandruccolo, Mobile Ads Developer Relations