# SkillPatch skill: google-analytics-admin-api-basics

This skill provides step-by-step guidance for working with the Google Analytics Admin API, covering API enablement via the Cloud CLI, authentication using Application Default Credentials, and a comprehensive overview of use cases across v1beta and v1alpha API versions. It helps agents programmatically configure Google Analytics accounts, manage properties, data streams, custom dimensions, conversion events, and product integrations like Firebase and Google Ads. The skill includes actionable shell commands and best-practice notes for both read and edit scopes.

You (the agent) were given this URL and asked to use this skill. This is a **public** skill — no SkillPatch account, API key, or prior setup is required. Two ways to use it:

**1. Use it right now** — the skill's complete file tree (SKILL.md + all reference files) is inlined below; read `SKILL.md` first, then follow it, consulting the other files as it directs.

**2. Install the exact package onto disk** (recommended if you can run a shell — this reproduces the skill byte-for-byte, including any binary assets that can't be inlined):

```bash
mkdir -p .claude/skills/google-analytics-admin-api-basics
curl -sSL https://skillpatch.dev/install_skill/google-analytics-admin-api-basics | tar -xz -C .claude/skills/
```

(`.claude/skills/` is Claude Code's convention; use whatever directory your agent loads skills from.)


---

## Skill files (8)

- `SKILL.md`
- `references/dotnet.md`
- `references/go.md`
- `references/java.md`
- `references/nodejs.md`
- `references/php.md`
- `references/python.md`
- `references/ruby.md`


### `SKILL.md`

````markdown
---
name: google-analytics-admin-api-basics
metadata:
  category: GoogleAnalytics
description: >-
  Manages Google Analytics account and property settings, enables the Analytics Admin API via the Cloud CLI, lists accounts and properties, and manages data streams, custom dimensions, conversion events, and integrations. Use when you need to programmatically configure Google Analytics accounts, provision properties, manage data retention, configure Measurement Protocol secrets, or manage Firebase and Google Ads links.
---

# Getting Started with Google Analytics Admin API

The Google Analytics Admin API provides programmatic access to Google Analytics
account and property configuration. It lets you automate account management,
manage data streams, configure custom dimensions, and handle product
integrations.

## Enabling the API via Cloud CLI

Before making API calls, ensure the Google Analytics Admin API is enabled in
your Google Cloud project.

If `gcloud` is not found, prompt the user to install the Google Cloud CLI before
running these commands.

1.  **Enable the API:** Use the Cloud CLI (`gcloud`) to enable
    `analyticsadmin.googleapis.com`.

    ```bash
    gcloud services enable analyticsadmin.googleapis.com --quiet
    ```

    *Why: Enabling the API ensures your Cloud project has the necessary quota
    and permissions allocated for managing Google Analytics configurations.*

2.  **Verify API Enablement:**

    ```bash
    gcloud services list --enabled --filter="analyticsadmin.googleapis.com"
    ```

## Authentication

To authenticate your API requests, you must generate Application Default
Credentials (ADC) and give your account the necessary scopes. Run the following
command in your terminal:

```bash
gcloud auth application-default login --scopes="https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/analytics.readonly"
```

*Why: This configures ADC in your local environment with the required Cloud
Platform and Google Analytics read-only scopes, allowing the client library to
automatically authenticate your requests.*

> [!NOTE] **Configuration Changes**: Methods changing the Google Analytics
> account/property configuration will need the
> `https://www.googleapis.com/auth/analytics.edit` scope.

## Admin API Use Cases

You can use the Google Analytics Admin API to:

*   Run Data Access reports (see
    https://developers.google.com/analytics/devguides/config/admin/v1/access-api.md.txt
    for more info)
*   Create Account summaries
*   Manage accounts
*   Provision new accounts
*   Search account change history events
*   Manage and create properties
*   Manage property data retention settings
*   Manage conversion events
*   Manage custom dimensions and metrics
*   Manage data streams and configure measurement protocol secrets
*   Manage Firebase links
*   Manage Google Ads links
*   Manage key events

### v1alpha-Only Use Cases

The following capabilities are currently available only in the `v1alpha` version
of the Admin API:

*   Manage account and property access bindings
*   Create and manage rollup properties
*   Create and manage subproperties
*   Acknowledge user data collection
*   Change property attribution, data retention, Google signals, reporting
    identity, and User Provided Data settings
*   Manage AdSense links
*   Manage BigQuery links
*   Manage audiences
*   Manage channel groups
*   Manage calculated metrics
*   Manage DisplayVideo360Advertiser links
*   Manage expanded data sets
*   Manage reporting data annotations
*   Manage SearchAds360 links
*   Manage event create rules for a data stream
*   Manage SKAdNetwork conversion value schema of an iOS stream
*   Submit a request for user deletion for a Google Analytics property.

## Calling the Admin API

To interact with the Admin API, use the official Google Analytics Admin client
library. Note that `v1beta` is the most stable version of the Admin API. For the
latest features, consider using `v1alpha`.

> [!IMPORTANT] **Mandatory Agent Directive:** When the user selects or requires
> a specific programming language, read the corresponding client library setup
> reference guide in `references/` listed below.

### Supported Client Libraries

#### Python

If you need to install or set up the Google Analytics Admin API client library
for Python, read the setup guide:

*   [Python Installation Reference](references/python.md) *(Package:
    `google-analytics-admin`)*

#### Java

If you need to install or set up the Google Analytics Admin API client library
for Java, read the setup guide:

*   [Java Installation Reference](references/java.md) *(Artifact:
    `com.google.cloud:google-cloud-analytics-admin`)*

#### PHP

If you need to install or set up the Google Analytics Admin API client library
for PHP, read the setup guide:

*   [PHP Installation Reference](references/php.md) *(Package:
    `google/analytics-admin`)*

#### Node.js

If you need to install or set up the Google Analytics Admin API client library
for Node.js, read the setup guide:

*   [Node.js Installation Reference](references/nodejs.md) *(Package:
    `@google-analytics/admin`)*

#### Go

If you need to install or set up the Google Analytics Admin API client library
for Go, read the setup guide:

*   [Go Installation Reference](references/go.md) *(Package:
    `cloud.google.com/go/analytics/admin/apiv1beta`)*

#### .NET

If you need to install or set up the Google Analytics Admin API client library
for .NET / C#, read the setup guide:

*   [.NET Installation Reference](references/dotnet.md) *(Package:
    `Google.Analytics.Admin.V1Beta`)*

#### Ruby

If you need to install or set up the Google Analytics Admin API client library
for Ruby, read the setup guide:

*   [Ruby Installation Reference](references/ruby.md) *(Gem:
    `google-analytics-admin-v1alpha`)*

> [!NOTE] **Additional Resources**: For further examples of calling the Admin
> API with Java, PHP, Node.js, .NET, Python, and REST, as well as hints on
> authentication with a service account, refer to the official
> [Admin API Quickstart](https://developers.google.com/analytics/devguides/config/admin/v1/quickstart).
> For complete API reference documentation for both `v1alpha` and `v1beta`, see
> the
> [Admin API Reference](https://developers.google.com/analytics/devguides/config/admin/v1/rest).

### Python Quick Start

1.  **Install the Client Library:**

    ```bash
    pip install google-analytics-admin
    ```

    If `pip` is not available, prompt the user to install `pip` before
    installing the client library.

2.  **List Accounts and Properties:** Below is a complete example demonstrating
    how to call the Admin API to list all available accounts and their child
    properties for the current user using `list_account_summaries()`.

    ```python
    from google.analytics.admin import AnalyticsAdminServiceClient

    def sample_list_account_summaries():
        # Initialize the client.
        # Assumes Application Default Credentials (ADC) are configured in your environment.
        client = AnalyticsAdminServiceClient()

        # list_account_summaries returns a summary of all accounts accessible to the
        # user and their child properties.
        account_summaries = client.list_account_summaries()

        print("Available Google Analytics Accounts and Properties:")
        for summary in account_summaries:
            print(f"Account: {summary.display_name} ({summary.account})")
            for property_summary in summary.property_summaries:
                print(f"  Property: {property_summary.display_name} ({property_summary.property})")

    if __name__ == "__main__":
        sample_list_account_summaries()
    ```

````


### `references/dotnet.md`

````markdown
# Google Analytics Admin API .NET Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for .NET / C#.

## Prerequisites

*   **.NET SDK:** .NET Core 3.1, .NET Standard 2.0, or .NET 6.0+.
*   **Package Manager:** NuGet / `dotnet` CLI.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the official NuGet package.

> [!NOTE] For package options and versions, see the
> [NuGet Google.Analytics.Admin.V1Beta Page](https://www.nuget.org/packages/Google.Analytics.Admin.V1Beta#package-manager).

Using the .NET CLI:

```bash
dotnet add package Google.Analytics.Admin.V1Beta
```

If `dotnet` is not available, prompt the user to install the `.NET CLI` before
installing the package.

Or via Package Manager Console in Visual Studio:

```powershell
Install-Package Google.Analytics.Admin.V1Beta
```

*Why: The NuGet package contains strongly typed protobuf models and gRPC service
clients for .NET applications.*

## Quickstart / Usage

```csharp
using System;
using System.Threading.Tasks;
using Google.Analytics.Admin.V1Beta;

class Program
{
    static async Task Main()
    {
        // Initialize client. Uses Application Default Credentials.
        AnalyticsAdminServiceClient client = await AnalyticsAdminServiceClient.CreateAsync();

        // List account summaries
        var response = client.ListAccountSummariesAsync(new ListAccountSummariesRequest());
        await foreach (AccountSummary summary in response)
        {
            Console.WriteLine($"Account: {summary.DisplayName} ({summary.Name})");
        }
    }
}
```

````


### `references/go.md`

````markdown
# Google Analytics Admin API Go Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for Go.

## Prerequisites

*   **Go:** Version 1.19 or higher.
*   **Modules:** Go modules enabled.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the official Go client library using `go get`.

Run the following command in your module directory:

```bash
go get cloud.google.com/go/analytics/admin/apiv1beta
```

If `go` is not available, prompt the user to install `Go` before installing the
package.

*Why: This adds the Google Analytics Admin API client package and necessary gRPC
transport dependencies to your `go.mod` file.*

## Quickstart / Usage

```go
package main

import (
    "context"
    "fmt"
    "log"

    admin "cloud.google.com/go/analytics/admin/apiv1beta"
    "cloud.google.com/go/analytics/admin/apiv1beta/adminpb"
    "google.golang.org/api/iterator"
)

func main() {
    ctx := context.Background()

    // Initialize the client. Automatically authenticates via ADC.
    client, err := admin.NewAnalyticsAdminClient(ctx)
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }
    defer client.Close()

    req := &adminpb.ListAccountSummariesRequest{}
    it := client.ListAccountSummaries(ctx, req)
    for {
        resp, err := it.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            log.Fatalf("Error iterating account summaries: %v", err)
        }
        fmt.Printf("Account: %s (%s)\n", resp.DisplayName, resp.Name)
    }
}
```

````


### `references/java.md`

````markdown
# Google Analytics Admin API Java Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for Java.

## Prerequisites

*   **Java Development Kit (JDK):** Java 8 or higher (Java 11+ recommended).
*   **Build Tool:** Maven or Gradle.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Add the official Google Analytics Admin client library dependency to your
project.

> [!NOTE] For more information and full documentation, refer to the
> [Google Cloud Java Analytics Admin Repository](https://github.com/googleapis/google-cloud-java/blob/main/java-analytics-admin/README.md).

> [!TIP]
> Always replace `LATEST_LIBRARY_VERSION` with the latest stable version of the
> dependency available on Maven Central.

### Option A: Maven (`pom.xml`)

Add the following dependency to your `pom.xml` inside `<dependencies>`:

```xml
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-analytics-admin</artifactId>
  <version>LATEST_LIBRARY_VERSION</version>
</dependency>
```

*Why: Using Maven ensures transitive dependencies (like Netty, gRPC, and Google
Auth Library) are automatically resolved.*

### Option B: Gradle (`build.gradle`)

Add the following to your `dependencies` block:

```groovy
implementation 'com.google.cloud:google-cloud-analytics-admin:LATEST_LIBRARY_VERSION'
```

## Quickstart / Usage

Initialize the client using try-with-resources to automatically close the gRPC
channel:

```java
import com.google.analytics.admin.v1beta.AnalyticsAdminServiceClient;
import com.google.analytics.admin.v1beta.AccountSummary;

public class AdminApiDemo {
  public static void main(String[] args) throws Exception {
    // Initialize the client. Automatically authenticates using ADC.
    try (AnalyticsAdminServiceClient client = AnalyticsAdminServiceClient.create()) {
      for (AccountSummary summary : client.listAccountSummaries().iterateAll()) {
        System.out.printf("Account: %s (%s)%n", summary.getDisplayName(), summary.getName());
      }
    }
  }
}
```

````


### `references/nodejs.md`

````markdown
# Google Analytics Admin API Node.js Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for Node.js.

## Prerequisites

*   **Node.js:** v14.x or higher (v16+ recommended).
*   **Package Manager:** `npm` or `yarn`.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the official Google Analytics Admin npm package.

> [!NOTE] For complete reference documentation, see the
> [Node.js Analytics Admin Reference](https://googleapis.dev/nodejs/analytics-admin/latest/index.html).

Run the following command in your project directory:

```bash
npm install @google-analytics/admin
```

If `npm` is not available, prompt the user to install `Node.js` (and `npm`)
before installing the package.

*Why: Installing `@google-analytics/admin` pulls in the official gRPC and REST
client bindings for Node.js.*

## Quickstart / Usage

```javascript
const {AnalyticsAdminServiceClient} = require('@google-analytics/admin');

async function listAccounts() {
  // Initialize the client. Uses ADC from the execution environment.
  const analyticsAdminClient = new AnalyticsAdminServiceClient();

  const [accountSummaries] = await analyticsAdminClient.listAccountSummaries();

  console.log('Available Accounts:');
  for (const account of accountSummaries) {
    console.log(`Account: ${account.displayName} (${account.name})`);
  }
}

listAccounts().catch(console.error);
```

````


### `references/php.md`

````markdown
# Google Analytics Admin API PHP Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for PHP.

## Prerequisites

*   **PHP:** Version 8.0 or higher.
*   **Package Manager:** Composer.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the library using Composer.

> [!NOTE] For full installation details, refer to the
> [PHP Analytics Admin Repository](https://github.com/googleapis/php-analytics-admin#installation).

Run the following command in your project directory:

```bash
composer require google/analytics-admin
```

If `composer` is not available, prompt the user to install `Composer` before
installing the package.

*Why: Composer installs the Google Analytics Admin client library and autoloader
along with its authentication dependencies.*

## Quickstart / Usage

Make sure to include Composer's autoloader before initializing the client:

```php
require_once __DIR__ . '/vendor/autoload.php';

use Google\Analytics\Admin\V1beta\Client\AnalyticsAdminServiceClient;
use Google\Analytics\Admin\V1beta\ListAccountSummariesRequest;

// Initialize the client. Uses ADC from environment.
$client = new AnalyticsAdminServiceClient();

$request = new ListAccountSummariesRequest();
$accountSummaries = $client->listAccountSummaries($request);

foreach ($accountSummaries as $summary) {
    printf("Account: %s (%s)\n", $summary->getDisplayName(), $summary->getName());
}
```

````


### `references/python.md`

````markdown
# Google Analytics Admin API Python Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for Python.

## Prerequisites

*   **Python:** Version 3.8 or higher.
*   **Package Manager:** `pip`
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the official Python client library within a virtual environment.

> [!NOTE] For complete details, see the
> [Python Analytics Admin README](https://github.com/googleapis/google-cloud-python/blob/main/packages/google-analytics-admin/README.rst#installation).

### 1. Create and Activate a Virtual Environment

```bash
python3 -m venv .venv
source .venv/bin/activate
```

### 2. Install the Client Library

```bash
pip install google-analytics-admin
```

If `pip` is not available, prompt the user to install Python and `pip` before
installing the client library.

*Why: Installing individual packages in a virtual environment prevents version
collisions with standard system libraries.*

## Quickstart / Usage

```python
from google.analytics.admin import AnalyticsAdminServiceClient

def list_accounts():
    # Initialize client. Automatically authenticates via ADC.
    client = AnalyticsAdminServiceClient()

    account_summaries = client.list_account_summaries()

    print("Available Accounts and Properties:")
    for summary in account_summaries:
        print(f"Account: {summary.display_name} ({summary.account})")
        for prop in summary.property_summaries:
            print(f"  Property: {prop.display_name} ({prop.property})")

if __name__ == "__main__":
    list_accounts()
```

````


### `references/ruby.md`

````markdown
# Google Analytics Admin API Ruby Client Library Installation

This guide provides specific instructions for installing and setting up the
Google Analytics Admin API client library for Ruby.

## Prerequisites

*   **Ruby:** Version 3.0 or higher.
*   **Package Manager:** RubyGems / Bundler.
*   **Authentication:** Application Default Credentials (ADC) configured via
    `gcloud auth application-default login`.

## Installation

Install the official Google Cloud Ruby client gem.

> [!NOTE] For complete installation details, refer to the
> [Ruby Analytics Admin Repository](https://github.com/googleapis/google-cloud-ruby/tree/main/google-analytics-admin-v1alpha#installation).

Using RubyGems:

```bash
gem install google-analytics-admin-v1alpha
```

If `gem` is not available, prompt the user to install `Ruby` (and `RubyGems`)
before installing the gem.

Or add to your `Gemfile`:

```ruby
gem "google-analytics-admin-v1alpha"
```

And run `bundle install`.

## Quickstart / Usage

```ruby
require "google/analytics/admin/v1alpha"

# Initialize client. Automatically authenticates using ADC.
client = Google::Analytics::Admin::V1alpha::AnalyticsAdminService::Client.new

account_summaries = client.list_account_summaries

account_summaries.each do |summary|
  puts "Account: #{summary.display_name} (#{summary.name})"
end
```

````