Google Mobile Ads Unity Plugin for Android and iOS

Google Mobile Ads Unity Plugin's C# Integration Boundary

Google Mobile Ads Unity Plugin addresses a specific gap between Unity application code and Google's mobile advertising interfaces. A Unity project may contain its gameplay and application logic in C# while still requiring platform-specific code for an advertising SDK. This plugin supplies a C# interface for requesting ads from scripts in the Unity project, allowing developers to serve Google Mobile Ads on Android and iOS without writing the integration directly in Java or Objective-C.

The intended users are Unity developers building native mobile applications that use Google Mobile Ads. It is not presented as a general campaign management console, attribution service, advertising dashboard, or mediation platform that operates independently of Google. The repository description identifies `googleads/googleads-mobile-unity` as the official Unity Plugin for the Google Mobile Ads SDK, and its C# surface is the part with which application scripts interact.

This boundary makes the plugin useful when a team wants its ad-request logic to remain in C#. It also means that project selection depends on target platforms. Android and iOS are explicitly documented. A Unity project shipping only to desktop or web is outside the documented scope, and the README does not claim equivalent support for those destinations.

The plugin does not remove the work associated with a mobile advertising integration. It changes where much of that work occurs. Developers still need platform configuration and must select compatible Google Mobile Ads APIs for their application. The official quick-start guide is therefore part of the integration itself, not merely an optional tutorial linked after setup.

Plugin Source, Packages, Samples, and Mediation Layout

Based on the repository layout, this is a full plugin source tree rather than a collection of isolated snippets. The `source/` directory contains the main project code, while `packages/` is the natural location to inspect for Unity package distribution. The top-level `build.gradle`, `gradle/`, `gradlew`, and `gradlew.bat` files show that Gradle tooling is part of the repository. An `Info.plist` is also present at the top level, which is relevant when inspecting the repository's native iOS-related files.

The repository separates mediation under `mediation/`. This confirms that mediation-related code has its own place in the project. The README does not enumerate mediation partners, supported networks, setup procedures, or platform differences, so the directory alone cannot establish what is available in a particular release. Developers who expect one provider-neutral mediation system should consult the official AdMob Unity documentation for the current supported configuration.

Two sample areas are visible. The README links `samples/HelloWorld/` as a Unity project demonstrating how to use Google Mobile Ads. The repository also contains `samples/Roll-A-Ball-NativeDemo/`. The HelloWorld project is the more useful starting point for a first integration because the README explicitly identifies it as the usage example. It should be checked for current package structure, initialization sequence, and script setup before being copied into another project.

The README does not include a C# request snippet, so this article cannot safely reconstruct an API call from unspecified method names. Using a snippet from another version could create a mismatch with `v11.6.0` or a later package. The sample included with the selected release remains the better source for exact code.

Importing the Plugin Through Unity Package Manager

The README provides two documented acquisition routes. Developers can import the plugin through Unity Package Manager or download a package from the GitHub releases page. It does not print a Unity Package Manager command, a package name, a registry URL, or a manual extraction procedure. Those details must be taken from the official quick-start section named `import_the_mobile_ads_for_unity_plugin`.

For a Package Manager installation, open the linked developer guide and follow its Unity Package Manager sequence exactly. The expected result is that the plugin becomes available to the Unity project through the package route documented by Google. Because the README does not describe the Unity version, menu labels, package identifier, or confirmation screen, none of those should be guessed. Check the package contents after import before adding application code.

The releases route serves as the documented alternative. Recent release tags include `v11.6.0`, `v11.5.0`, and `v11.4.0`, with corresponding release names identifying the Google Mobile Ads Unity Plugin. The exact downloadable asset is not listed in the README. Open the GitHub releases page, select the intended package, and follow the instructions associated with that asset rather than assuming that every release has the same file format.

A Unity developer should then open the HelloWorld sample associated with the same release and compare its package version with the imported one. That comparison is important because the README does not state that the `main` branch sample is guaranteed to match an older imported package. Keep the plugin, sample, and official documentation aligned when evaluating behavior.

First Ad Request Through the Unity C# Interface

The README states that the plugin provides a C# interface for requesting ads and that Unity scripts use that interface. It does not document an exact initialization method, request constructor, ad unit property, callback signature, or load call. A complete first-use example would require inventing those names, so the verifiable procedure begins with the linked HelloWorld project.

Open `samples/HelloWorld/` after importing the plugin. Locate the C# scripts that request an ad and follow their initialization and request flow. Then compare those scripts with the Unity project that will contain the integration. This exposes whether the sample uses direct script references, Unity inspector fields, or another project-specific setup mechanism without requiring this article to claim details that the README omits.

Before running the sample, the official quick-start guide should be used to verify the Android or iOS build prerequisites. The repository includes `Info.plist`, Gradle files, and package sources, but their presence does not establish every application-level requirement. In particular, the README does not document consent handling, application identifiers, privacy configuration, test ad units, or platform build commands. Each of those must be checked in Google's current guide before using the integration in a production project.

The first successful review is therefore not merely whether an ad appears. Confirm that the sample imports without package conflicts, its scripts match the installed plugin version, and its configuration corresponds to the mobile platform being built. The README does not describe expected editor console output or visual results, so it would be misleading to promise a particular interface state.

Android, iOS, and Mediation Constraints

The plugin concentrates Android and iOS ad access behind a Unity-facing C# interface. This is its main architectural distinction from implementing the Google Mobile Ads SDK separately in each native platform layer. It can reduce the amount of Java and Objective-C integration code handled directly by a Unity team, but the README does not claim that every Google Mobile Ads API behaves identically across both operating systems.

Native platform constraints still apply. The repository contains Gradle build files and an `Info.plist`, but the README does not document Unity editor requirements, minimum operating-system versions, native dependency versions, architecture settings, or build-process steps. Those are release-sensitive details. They should be taken from the official AdMob Unity guide associated with the imported package version.

The `mediation/` directory also requires careful handling. Its existence confirms a mediation component, but not which networks or setup methods a release supports. Mediation usually involves additional platform-specific configuration, and selecting a provider outside the documented support list could lead to an incomplete integration. The README does not provide a supported-partner list, so repository contributors or users should not infer one merely from directory names or sample files.

This is where the plugin differs from a standalone mediation service. It presents an SDK plugin within the Google Mobile Ads ecosystem. A team seeking mediation features that remain outside that ecosystem would need a different architectural approach or a separately documented product.

Apache 2.0 Licensing and Upgrade Work

The repository identifies Apache 2.0 as its license and links the Apache 2.0 License text. That statement establishes the licensing declared for this repository. It does not mean that every SDK component, service, trademark, advertisement, or external package in a Unity application is covered by the same terms. No legal conclusion about a particular distribution should be drawn from the repository label alone.

The repository is not archived. Its last push was on 2026-10-15. Recent releases were published as `v11.6.0` on 2026-10-13, `v11.5.0` on 2026-09-03, and `v11.4.0` on 2026-08-19. These dates show recent repository and release activity. They do not establish a fixed release schedule, a support window, or automatic compatibility between versions.

Upgrade planning has two concrete sources within the project. `ChangeLog.txt` records changes shipped from the repository, and the GitHub releases page provides published packages. The README does not document a semantic-version policy, migration procedure, deprecation period, or list of supported Unity versions, so an adopter cannot determine upgrade effort from the version number alone.

Before replacing an installed plugin, compare its release notes with the project's current C# calls and inspect the matching HelloWorld sample. Advertising integrations commonly cross platform build boundaries, so testing only Unity editor behavior is insufficient. The README does not define an upgrade test matrix, leaving that verification to the official documentation and the adopting project's platform builds.

When Separate Native SDK Integration Is More Appropriate

This plugin is the wrong tool for a Unity application that does not target Android or iOS. Those are the only mobile platforms named by the README. It also does not fit a team looking for advertising campaign planning, reporting, publisher administration, or an independent mediation backend. Those concerns are outside the stated role of a Unity interface for requesting Google Mobile Ads.

A direct native integration is the real alternative when platform-level control is more important than a shared C# path. In that approach, the Android side uses Java and the iOS side uses Objective-C, as identified by the README. This removes the repository's C# plugin layer from the architecture, but it also gives up the stated convenience of making ad requests from Unity C# scripts. Native implementations may require separate maintenance and platform-specific implementation work.

A provider-neutral abstraction is another alternative when a project needs to change ad networks or operate outside Google Mobile Ads. The README does not document such an abstraction here, and the `mediation/` directory cannot by itself prove that any external provider is supported. A team with those requirements should define its interface around the actual destinations and mediation choices, rather than assuming this plugin supplies them.

The practical choice is narrow. Use the plugin when the application targets Android or iOS and its team wants Google Mobile Ads access from C#. Prefer direct native work when per-platform ownership is mandatory, or a separate advertising design when the requirement extends beyond Google's SDK.

Editorial conclusion

Unity developers building Android or iOS applications that need Google Mobile Ads should adopt this plugin when keeping ad requests in C# is important. It does not fit projects targeting unsupported platforms, developers who need a mediation service independent of Google, or teams that require direct native control over both SDK integrations. Before adoption, verify compatibility with the project's Unity version, Android or iOS build settings, required Google Mobile Ads configuration, intended ad formats, and mediation requirements against the official quick-start guide.

Frequently asked questions

Official sources

1. googleads/googleads-mobile-unity on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases