Google Analytics Integration for AI Projects

How we built a comprehensive analytics reporting system with secure credential management, interactive setup, and enterprise-grade architecture

---

The Challenge: Analytics at Scale with Security

When building AI agent systems that need to access Google Analytics data, developers face a common dilemma: how do you create focused analytics reports while maintaining security best practices?

We recently tackled this challenge while building our AWS AI Agent Bus – a comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with AWS services and external APIs through standardized interfaces. The result? A complete Google Analytics reporting system with AWS Secrets Manager integration that makes credential management painless while delivering enterprise-grade security.

What is AWS AI Agent Bus?

The AWS AI Agent Bus is an infrastructure platform that allows AI agents (like Claude, GPT, or custom agents) to:

• Securely access AWS services (DynamoDB, S3, EventBridge, Step Functions)
• Integrate with external APIs (Google Analytics, Search Console, social media)
• Manage workflows and state across multiple agent interactions
• Handle credentials securely using AWS Secrets Manager
• Scale from development to production with enterprise-grade architecture

Think of it as the “nervous system” that connects AI agents to real-world data and services.

What We Built

Our solution includes three key components:

🔐 Secure Credential Management

• AWS Secrets Manager integration for encrypted credential storage
• Interactive OAuth2 setup with automated token refresh
• Zero hardcoded secrets in code or configuration files

📊 Production-Ready Reports

• Users by Country report with geographic insights
• Sample data versions for testing without credentials
• Comprehensive error handling and troubleshooting guides

🛠️ Developer Experience

• One-command setup: npm run setup:ga-credentials
• Interactive credential management and testing
• Complete documentation and troubleshooting guides

Let’s dive into how we built it.

How It Fits Into AWS AI Agent Bus

This Google Analytics integration is part of the larger AWS AI Agent Bus architecture:

┌─────────────────────────────────────────────────────────────────┐
│                    AWS AI Agent Bus                             │
├─────────────────┬─────────────────┬─────────────────────────────┤
│   AI Agents     │  MCP Server     │     AWS Services            │
│  (Claude, GPT)  │                 │                             │
├─────────────────┼─────────────────┼─────────────────────────────┤
│ • Chat/Text     │ • Tool Handlers │ • DynamoDB (State)          │
│ • Analysis      │ • GA Reports    │ • S3 (Artifacts)            │
│ • Automation    │ • Credentials   │ • Secrets Manager (Auth)    │
│                 │ • HTTP/stdio    │ • EventBridge (Events)      │
└─────────────────┴─────────────────┴─────────────────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│ User Requests   │───▶│ Interactive      │───▶│ Live Analytics  │
│ "Show me users  │    │ Setup & Reports  │    │ Data & Insights │
│  by country"    │    │                  │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Where Files Live in the Project

aws-ai-agent-bus/
├── mcp-server/src/
│   ├── reports/                    # 📊 This is what we built!
│   │   ├── users-by-country.js     # Live GA data report
│   │   ├── users-by-country-sample.js # Demo version
│   │   └── README.md               # Report documentation
│   ├── scripts/
│   │   └── setup-ga-credentials.js # Interactive setup wizard
│   ├── services/
│   │   └── google-analytics.js     # GA API service
│   └── modules/mcp/handlers/
│       └── google-analytics.js     # MCP integration
├── package.json                    # npm run commands here
└── README.md                      # Getting started guide

Browse the complete structure: mcp-server/src/

The system follows clean architecture principles with clear separation of concerns:

• User Interface: NPM scripts and interactive prompts
• Application Layer: Report scripts and setup wizards
• Service Layer: Google Analytics API abstraction
• Security Layer: AWS Secrets Manager integration
• Infrastructure: AWS services and MCP server

The Magic: One-Command Setup

The most challenging part of any Google Analytics integration is the initial setup. OAuth2 flows, credential management, token refresh – it’s a lot of moving pieces. We solved this with an interactive setup script:

npm run setup:ga-credentials

This single command walks you through:

1. Google Cloud Console Setup: Step-by-step guidance for creating OAuth2 credentials
2. Interactive OAuth Flow: Automated browser-based authentication
3. AWS Integration: Automatic storage in AWS Secrets Manager
4. Validation Testing: Immediate verification that everything works

See the setup script: mcp-server/scripts/setup-ga-credentials.js

Here’s what the experience looks like:

🔧 Google Analytics Credentials Setup for AWS Secrets Manager

What would you like to do?
1. Create new credentials (first-time setup)
2. Update existing credentials  
3. Test existing credentials
4. Show setup instructions
Choose (1-4): 1

📝 Creating new Google Analytics credentials...

Enter your Google OAuth2 Client ID: 
Enter your Google OAuth2 Client Secret:
Enter your Google Analytics Property ID: 

🌐 Starting OAuth2 flow to get access tokens...
Please visit this URL to authorize the application:
https://accounts.google.com/oauth/authorize?...

✅ Credentials successfully stored in AWS Secrets Manager!
🎉 Credentials are working correctly!

Under the Hood: The Technical Implementation

Google Analytics Service

At the core is our GoogleAnalyticsService class that handles all the complexity of OAuth2 authentication, service account support, and report generation.

See the full implementation: mcp-server/src/services/google-analytics.js

Key features:

• Auto-detects credential type (OAuth2 vs Service Account)
• Handles token refresh automatically for OAuth2 flows
• Supports both Analytics Data API and Search Console API
• Clean error handling with actionable error messages
• Comprehensive report formatting with geographic insights

AWS Secrets Manager Integration

Security is handled through AWS Secrets Manager with proper IAM policies and encrypted storage.

See the implementation: mcp-server/src/modules/mcp/handlers/google-analytics.js

The integration provides:

• Secure credential retrieval from AWS Secrets Manager
• Automatic initialization of the Google Analytics service
• Proper error handling for missing or invalid credentials
• Environment-based secret management (dev/staging/prod)

The secret structure follows Google’s OAuth2 format:

{
  "client_id": "your-oauth-client-id.apps.googleusercontent.com",
  "client_secret": "GOCSPX-your-client-secret-here",
  "access_token": "ya29.a0A[...truncated...]",
  "refresh_token": "1//0[...truncated...]",
  "property_id": "YOUR_GA4_PROPERTY_ID"
}

Security Note: The actual tokens are much longer and should never be shared or committed to version control.

Sample Report Output

Here’s what our Users by Country report generates:

=== UNIQUE USERS BY COUNTRY - LAST 30 DAYS ===

┌──────┬──────────────────┬──────────────┬─────────────┬──────────────┬─────────────────┐
│ Rank │ Country          │ Country Code │ Total Users │ Active Users │ Engagement Rate │
├──────┼──────────────────┼──────────────┼─────────────┼──────────────┼─────────────────┤
│ 1    │ 'United States'  │ 'US'         │ '15,420'    │ '12,830'     │ '68.00%'        │
│ 2    │ 'Canada'         │ 'CA'         │ '3,240'     │ '2,890'      │ '72.00%'        │
│ 3    │ 'United Kingdom' │ 'GB'         │ '2,890'     │ '2,450'      │ '65.00%'        │
└──────┴──────────────────┴──────────────┴─────────────┴──────────────┴─────────────────┘

Summary:
• Total unique users across all countries: 33,900
• Countries represented: 15
• Geographic distribution: NA (56.5%), Europe (29.0%), APAC (11.9%)

Top 5 Countries by Users:
1. United States: 15,420 users (45.49%)
2. Canada: 3,240 users (9.56%)
3. United Kingdom: 2,890 users (8.53%)
4. Germany: 2,110 users (6.22%)
5. Australia: 1,850 users (5.46%)

Highest Engagement Countries:
1. Sweden: 77.00% engagement rate
2. Netherlands: 74.00% engagement rate
3. Belgium: 73.00% engagement rate

Security Best Practices

Our implementation follows enterprise security standards:

🔐 Encryption at Rest

All credentials are encrypted in AWS Secrets Manager using AWS KMS keys.

🔑 IAM Least Privilege

Minimal permissions required for secure operation – only Secrets Manager read access for the specific Google Analytics secret.

See IAM configuration: Review the infrastructure setup in infra/workspaces/ for production-ready IAM policies and roles.

🔄 Token Rotation

Built-in support for automated credential rotation:

aws secretsmanager update-secret \
    --secret-id "your-project/google-analytics" \
    --rotation-lambda-arn "arn:aws:lambda:us-east-1:account:function:rotate-ga-credentials" \
    --rotation-rules AutomaticallyAfterDays=90

📊 Audit Trail

CloudTrail integration provides complete audit logging of credential access.

Prerequisites: What You Need Before Starting

Before diving in, make sure you have:

Required Accounts & Access

• ✅ AWS Account with credentials configured (aws configure)
• ✅ Google Analytics 4 property (free Google Analytics account)
• ✅ Google Cloud Console access (same Google account as GA4)
• ✅ Node.js 18+ installed locally

AWS Permissions Needed

Your AWS credentials need access to:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow", 
      "Action": [
        "secretsmanager:CreateSecret",
        "secretsmanager:GetSecretValue",
        "secretsmanager:UpdateSecret"
      ],
      "Resource": "*"
    }
  ]
}

Google Analytics Setup

• A Google Analytics 4 property with data (even demo data works)
• Admin access to enable API access
• The Property ID (found in GA4 Admin → Property Settings)

Quick Start: Try It in 2 Minutes (No Setup Required!)

Want to see what this looks like without any setup? Try our sample report:

git clone https://github.com/Baur-Software/aws-ai-agent-bus.git
cd aws-ai-agent-bus
npm install
npm run report:users-by-country-sample

This runs with demo data and shows you exactly what the real reports look like!

Full Setup: From Zero to Live Analytics in 5 Minutes

Ready to connect to your actual Google Analytics? Here’s the complete process:

1. Clone and Install:git clone https://github.com/Baur-Software/aws-ai-agent-bus.git cd aws-ai-agent-bus npm install
2. Verify AWS Access:aws sts get-caller-identity # Should show your AWS account
3. Interactive Setup:npm run setup:ga-credentials # Choose option 1 for first-time setup
4. Generate Your First Report:npm run report:users-by-country # Live data from your GA4!

For development and testing, we include sample data versions:

npm run report:users-by-country-sample  # No credentials needed!

Testing Strategy: 100% Coverage

We built comprehensive testing with multiple layers to ensure reliability:

Test Files

• Unit Tests: mcp-server/test/unit/google-analytics.test.mjs
• Integration Tests: mcp-server/test/integration/google-analytics-mcp.test.mjs
• OAuth2 Tests: mcp-server/test/ga-oauth2-simple.test.mjs

What We Test

• Service initialization with both OAuth2 and Service Account credentials
• Report generation with mock Google Analytics data
• Error handling for invalid credentials and API failures
• MCP tool integration through the complete request/response cycle
• Credential validation including OAuth2 token structure

Run tests: npm test (100% pass rate required for deployment)

Production Deployment

The system is designed for production from day one:

Environment Configuration

# Production
export AWS_REGION=us-east-1
export GA_SECRET_ID=your-project/google-analytics

# Development  
export AWS_REGION=us-west-2
export GA_SECRET_ID=dev-google-analytics

Error Handling

Comprehensive error handling with actionable error messages:

❌ Error: Could not load credentials from any providers
💡 Solution: Configure AWS credentials with `aws configure`

❌ Error: Failed to initialize Google Analytics
💡 Solution: Run `npm run setup:ga-credentials` and choose option 3 to test

Troubleshooting: Common Issues for Newcomers

“I don’t have AWS credentials configured”

# Install AWS CLI first
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

# Configure with your AWS keys
aws configure
# AWS Access Key ID: [Your key]
# AWS Secret Access Key: [Your secret] 
# Default region: us-east-1
# Default output format: json

# Test it works
aws sts get-caller-identity

“I don’t know my Google Analytics Property ID”

1. Go to Google Analytics
2. Click Admin (gear icon, bottom left)
3. Select your property from the middle column
4. Click Property Settings
5. Copy the Property ID (just the numbers, like 987654321)

“The OAuth flow isn’t working”

• Make sure you’re using http://localhost:3000/auth/callback as a redirect URI in Google Cloud Console
• Check that both Analytics Data API and Search Console API are enabled
• Try running the setup script again – tokens can expire during setup

“I get permission errors in AWS”

Your AWS user/role needs these permissions:

# Quick fix: Attach this AWS managed policy (for development)
aws iam attach-user-policy --user-name YOUR_USERNAME --policy-arn arn:aws:iam::aws:policy/SecretsManagerReadWrite

# Or create a minimal custom policy (production)
aws iam create-policy --policy-name GASecretsAccess --policy-document file://ga-policy.json

“The sample report works but live data doesn’t”

This usually means:

1. Your Google Analytics property has no data (wait 24-48 hours after setup)
2. The Property ID is wrong (check GA4 Admin → Property Settings)
3. API permissions weren’t properly granted during OAuth flow

Run the test to diagnose:

npm run setup:ga-credentials  # Choose option 3: Test existing credentials

Monitoring

CloudWatch integration for production monitoring:

// Automatic event publishing for monitoring
await EventsHandler.send({
  detailType: 'GoogleAnalytics.Report.Generated',
  detail: {
    reportType: 'users-by-country',
    userCount: data.length,
    timestamp: new Date().toISOString()
  }
});

AI-Powered Content Analysis & Automation

Beyond simple reports, the system includes sophisticated AI-powered content analysis and automation capabilities that can transform your content strategy.

🤖 Automated Content Opportunity Analysis

The system automatically analyzes your Google Analytics and Search Console data to identify content opportunities:

Available as MCP Tools:

• mcp__aws__ga_analyzeContentOpportunities – Combines GA4 and Search Console data for insights
• mcp__aws__ga_generateContentCalendar – Creates actionable monthly content calendars

See the implementation: mcp-server/src/modules/mcp/handlers/google-analytics.js:225-265

📊 What It Analyzes

The content analysis engine provides:

1. High-Performing Content Identification
   • Pages with highest engagement rates
   • Content themes that resonate with your audience
   • Seasonal performance patterns
2. Keyword Opportunity Detection
   • Keywords ranking 11-20 (prime optimization targets)
   • High-impression, low-CTR opportunities
   • Content gaps in your keyword coverage
3. Audience Behavior Analysis
   • Geographic performance variations
   • Device and platform preferences
   • User journey optimization opportunities
4. Competitive Content Gaps
   • Topics your competitors rank for but you don’t
   • Content types performing well in your niche
   • Untapped search volume opportunities

📅 Automated Content Calendar Generation

The system goes beyond analysis to create actionable content calendars:

# AI-powered content calendar generation
npm run ai:generate-content-calendar

Generated Calendar Includes:

• Pillar Content based on your highest-performing pages
• Social Media Posts targeting keyword opportunities
• Blog Posts to fill identified content gaps
• Seasonal Content based on historical performance patterns

See the calendar generation logic: mcp-server/src/modules/mcp/handlers/google-analytics.js:344-408

🎯 Content Strategy Automation

Each generated content item includes:

{
  type: 'pillar|social|blog',
  title: 'AI-generated content title',
  description: 'Actionable content description',
  dueDate: '2024-09-15T00:00:00.000Z',
  keywords: ['target', 'keywords'],
  priority: 'high|medium|low',
  platform: 'linkedin|facebook' // for social content
}

🔄 Event-Driven Workflow Integration

The system publishes EventBridge events for downstream automation:

• ContentAnalysis.Opportunities.Generated – Triggers when new insights are available
• ContentCalendar.Generated – Can trigger Trello/Asana board updates
• GoogleAnalytics.Report.Generated – Notifies teams of new data availability

See event integration: mcp-server/src/modules/mcp/handlers/google-analytics.js:234-253

🧠 Specialized Google Analytics Agent

The system includes a dedicated AI agent that specializes in Google Analytics analysis and content strategy:

Meet the Google Analytics MCP Expert: .claude/agents/specialized/google-analytics/google-analytics-mcp-expert.md

What the Agent Does:

• Translates GA data into actionable content recommendations
• Identifies content themes that resonate with your audience
• Creates data-driven content calendars with specific priorities
• Provides SEO insights by combining GA4 with Search Console data
• Monitors performance trends to optimize content strategy

Key Capabilities:

• Content Strategy Integration – Transforms analytics into editorial planning
• SEO & Marketing Intelligence – Combines multiple data sources for insights
• Automated Report Generation – Creates comprehensive monthly strategy reports
• Team Collaboration – Provides accessible insights for non-technical stakeholders

This agent works alongside the MCP tools to provide intelligent analysis and recommendations, turning raw analytics data into strategic business intelligence.

🛠️ Using the MCP Tools in Practice

The system provides several MCP tools that you can use directly from any MCP-compatible AI assistant (like Claude):

Basic Analytics Queries

// Get top performing pages for the last 30 days
await mcp__aws__ga_getTopPages({
  propertyId: "properties/YOUR_PROPERTY_ID",
  days: 30
});

// Get Search Console keyword data  
await mcp__aws__ga_getSearchConsoleData({
  siteUrl: "https://example.com",
  days: 30
});

Advanced Content Analysis

// Comprehensive content opportunity analysis
const insights = await mcp__aws__ga_analyzeContentOpportunities({
  propertyId: "properties/YOUR_PROPERTY_ID",
  siteUrl: "https://example.com"
});

// Returns structured insights including:
// - topPerformingContent: Pages with highest engagement
// - keywordOpportunities: High-potential search terms  
// - contentGaps: Missing content your audience is searching for
// - seasonalTrends: Time-based performance patterns

Automated Content Planning

// Generate a complete content calendar for next month
const calendar = await mcp__aws__ga_generateContentCalendar({
  propertyId: "properties/YOUR_PROPERTY_ID", 
  siteUrl: "https://example.com",
  targetMonth: "2024-10"  // Optional - defaults to next month
});

// Returns actionable content items with:
// - Pillar content based on top performers
// - Social media posts targeting keyword gaps
// - Blog posts to fill content opportunities  
// - Due dates and priority levels

Integration with AI Assistants

Since these are MCP tools, you can use them directly in conversations with AI assistants:

You: “Analyze my website’s content opportunities and generate a content calendar for October”

AI Assistant: Uses mcp__aws__ga_analyzeContentOpportunities and mcp__aws__ga_generateContentCalendar

“Based on your analytics data, I found 12 content opportunities. Your top-performing content theme is ‘productivity tips’ with 45% higher engagement. I’ve generated a 31-item content calendar focusing on…”

This makes analytics insights immediately actionable within your existing AI-powered workflows.

Extending the System

The architecture makes it easy to add new reports by following the existing patterns.

Example Reports

• Users by Country: mcp-server/src/reports/users-by-country.js (live data)
• Sample Report: mcp-server/src/reports/users-by-country-sample.js (demo data)

Adding New Reports

1. Create a new report script in mcp-server/src/reports/
2. Follow the existing patterns from the users-by-country reports
3. Add npm scripts to package.json for easy execution
4. Include both live and sample data versions

Building a Secure, Automated Google Analytics Integration for AI

Since implementing this system, we’ve seen:

• ⚡ 95% reduction in setup time (from hours to minutes)
• 🔒 100% elimination of hardcoded credentials
• 🧪 100% test coverage with comprehensive mocking
• 📊 Zero-downtime credential rotation capability
• 🔍 Complete audit trail for compliance requirements

Key Takeaways

1. Security First: AWS Secrets Manager integration eliminates credential management headaches
2. Developer Experience Matters: Interactive setup scripts make complex integrations approachable
3. Clean Architecture: Clear separation of concerns enables easy extension and testing
4. Production Ready: Comprehensive error handling, monitoring, and documentation from day one

Get Started Today

The complete implementation is available in our AWS AI Agent Bus repository.

git clone https://github.com/Baur-Software/aws-ai-agent-bus.git
cd aws-ai-agent-bus
npm install
npm run setup:ga-credentials

Want to see it in action? Try the sample report (no credentials needed):

npm run report:users-by-country-sample

Use Cases: Who Should Use This?

This Google Analytics integration is perfect for:

📊 Product Teams

• Monthly user analysis by geography
• Automated reporting for stakeholders
• Geographic expansion planning

🤖 AI/ML Engineers

• Training data for geo-targeting models
• Analytics feature pipelines
• Automated insight generation

🔧 DevOps/Platform Teams

• Secure credential management patterns
• AWS + Google API integration templates
• Production monitoring and alerting

👨‍💻 Indie Developers

• Quick analytics for SaaS apps
• Geographic user insights
• No complex dashboard setup needed

What’s Next?

We’re planning to extend this pattern to other analytics platforms:

• Google Search Console reports (keyword performance, page insights)
• Facebook/Meta Analytics integration
• Custom dashboard generation with automated insights
• Real-time alerting based on analytics thresholds
• Multi-tenant credential management for agencies

Ready to Get Started?

Just Want to See It Work? (30 seconds)

git clone https://github.com/Baur-Software/aws-ai-agent-bus.git && cd aws-ai-agent-bus
npm install && npm run report:users-by-country-sample

Want to Connect Your GA4? (5 minutes)

1. Make sure you have AWS credentials configured
2. Run npm run setup:ga-credentials
3. Follow the interactive prompts
4. Get live analytics data!

Building Your Own Integration?

• Fork the repository and extend the reports module
• Use our GoogleAnalyticsService as a foundation
• Follow our clean architecture patterns
• Contribute back with PRs!

---

This Google Analytics integration with AWS Secrets Manager showcases how modern development practices can make complex integrations both secure and developer-friendly. By focusing on developer experience while maintaining enterprise-grade security, we’ve created a system that scales from development to production seamlessly.

Questions? Issues? Ideas?

• 📖 Full Documentation
• 🐛 Report Issues
• 💡 Request Features