MediaMath Integrations

Integrations linking MediaMath with analytics platforms, DMPs, and programmatic advertising tools.

Overview

MediaMath's TerminalOne platform provides a comprehensive demand-side platform (DSP) ecosystem with extensive integration capabilities across data management platforms, analytics tools, attribution partners, and verification providers. As a programmatic advertising platform, MediaMath enables marketers to connect first-party data, activate audiences across channels, and measure performance with advanced attribution models.

This guide covers all available integration options for MediaMath, including native platform features, third-party partnerships, API access patterns, and data export capabilities to build a complete programmatic advertising stack.

Integration Capabilities

Native Platform Integrations

MediaMath's TerminalOne platform includes several native integration features:

TerminalOne Operating System

Unified campaign management interface
Cross-channel campaign orchestration
Real-time bidding and optimization
Automated budget pacing and allocation
Creative management and versioning
Audience building and segmentation tools

MediaMath API

RESTful API for programmatic access
Campaign automation and bulk operations
Real-time reporting and analytics
Audience management endpoints
Creative upload and approval workflows
Budget and bid management

Brain Optimization Engine

AI-powered bid optimization
Predictive performance modeling
Automated creative selection
Cross-device frequency capping
Viewability and completion rate optimization
Budget reallocation based on performance

Source Platform

Native data onboarding capabilities
First-party data activation
Segment creation and management
Audience insights and overlap analysis
Privacy-compliant identity resolution

Platform Requirements

Access Levels

Advertiser user: Campaign viewing and basic reporting
Campaign manager: Campaign creation and editing
Account admin: User management and billing access
API user: Programmatic API access with OAuth credentials
Agency access: Multi-advertiser account management

Technical Prerequisites

Active MediaMath TerminalOne account
Advertiser organization ID
OAuth client credentials for API access
Tag management system for pixel deployment (optional but recommended)
Data warehouse for advanced reporting (optional)

Data Management Platform Integrations

Adobe Audience Manager

Integration Type: Server-to-server audience syncing Setup Process:

Enable Adobe integration in TerminalOne platform settings
Configure destination in Adobe Audience Manager
Map Adobe segments to MediaMath taxonomy
Set up real-time or batch sync schedule
Test audience activation in campaigns

Features:

Real-time audience syncing (latency < 15 minutes)
Bidirectional data flow for conversion feedback
Trait-level targeting capabilities
Segment overlap analysis
Frequency and recency controls

Use Cases:

CRM audience activation for prospecting
Website visitor retargeting
Cross-device targeting using Adobe's device graph
Lookalike modeling based on converter segments
Sequential messaging across customer journey stages

Data Available:

Audience segment IDs and sizes
Segment match rates
Conversion data for optimization
Device graph for cross-device targeting

Oracle BlueKai

Integration Type: Server-to-server data exchange Setup Process:

Contact MediaMath and Oracle to enable integration
Configure BlueKai taxonomy mapping
Set up data sync cadence (real-time or batch)
Enable conversion pixel for attribution loop
Activate audiences in TerminalOne campaigns

Features:

Third-party data marketplace access
Custom audience creation using BlueKai data
Offline data onboarding
Cross-channel audience activation
Attribution and measurement feedback loops

Use Cases:

Purchase intent targeting with third-party data
B2B account-based marketing with firmographic data
Competitive conquest campaigns
Demographic and psychographic targeting overlays
Multi-touch attribution modeling

Lotame

Integration Type: Audience segment sharing via ID sync Setup Process:

Enable Lotame integration in TerminalOne
Map Lotame segment IDs to MediaMath targeting
Configure sync frequency and priority rules
Set up conversion tracking for feedback
Test segment activation and match rates

Features:

Second-party and third-party data access
Custom audience segments
Lookalike modeling
Data enrichment with Lotame Panorama
Privacy-compliant data activation

Use Cases:

Audience expansion with lookalike modeling
Contextual targeting using content segments
Data collaboration with publisher partners
Seasonal and event-based targeting
Suppression lists for frequency management

DMP Integration Best Practices

Segment Naming Conventions:

[Source]_[Type]_[Intent]_[Recency]
Examples:
- AAM_Retarget_Cart_7d
- BlueKai_3rdParty_AutoIntenders_30d
- Lotame_Lookalike_Converters_90d

Sync Configuration:

Use real-time sync for retargeting audiences (< 15 min latency)
Use daily batch sync for prospecting audiences
Set up conversion feedback loops for optimization
Monitor match rates (target > 60% for activation)
Implement frequency caps across segments

Common Issues:

Low match rates: Check cookie sync configuration
Audience size discrepancies: Review sync latency and attribution windows
Segment overlap: Use exclusion lists to prevent audience conflicts
Cost inefficiencies: Set up segment priority hierarchies

Analytics Platform Integrations

Google Analytics

Integration Method: MediaMath pixel + UTM parameter tagging

Setup:

Deploy MediaMath pixel on website alongside GA tracking
Enable auto-tagging in TerminalOne for UTM parameters
Configure conversion goals in Google Analytics
Import GA goals into MediaMath via conversion pixel
Set up custom dimensions for campaign metadata

UTM Structure:

utm_source=mediamath
utm_medium=display (or video, native, etc.)
utm_campaign=[campaign_name]
utm_term=[strategy_name]
utm_content=[creative_id]

Conversion Tracking:

<!-- MediaMath conversion pixel with GA integration -->
<script>
  // Fire MediaMath pixel on conversion
  var mt_conversion_pixel = document.createElement('img');
  mt_conversion_pixel.src = 'https://pixel.mathtag.com/event/img?mt_id=123456&mt_adid=789012&mt_exem=&mt_excl=&v1=&v2=&v3=';
  document.body.appendChild(mt_conversion_pixel);

  // Also send to Google Analytics
  ga('send', 'event', 'MediaMath', 'Conversion', 'Campaign-ID');
</script>

Available Data in GA:

Campaign performance metrics by UTM parameters
User behavior flow for MediaMath traffic
Goal completions and conversion funnels
Multi-channel attribution reports
Audience overlap with other channels

Adobe Analytics

Integration Method: MediaMath container tag + eVar/prop mapping

Setup:

Deploy MediaMath pixel container via Adobe Launch
Configure conversion events in Adobe Analytics
Map MediaMath campaign parameters to eVars
Set up processing rules for data normalization
Create calculated metrics for MediaMath performance

eVar Mapping Example:

// Adobe Analytics implementation with MediaMath data
s.eVar10 = "MediaMath"; // Channel
s.eVar11 = "[campaign_id]"; // Campaign ID
s.eVar12 = "[strategy_id]"; // Strategy ID
s.eVar13 = "[creative_id]"; // Creative ID
s.events = "event10"; // MediaMath impression
s.events = "event11"; // MediaMath click
s.events = "event12"; // MediaMath conversion

Use Cases:

Cross-channel attribution analysis
Customer journey mapping with MediaMath touchpoints
Segment performance analysis
ROI measurement with Adobe attribution models
A/B test analysis for creative variations

Custom Analytics Integration

Server-Side Tracking:

import requests
import json

def track_mediamath_conversion(user_id, campaign_id, conversion_value):
    """Send MediaMath conversion to custom analytics platform"""

    # Fire MediaMath conversion pixel (server-side)
    mediamath_pixel_url = f"https://pixel.mathtag.com/event/img"
    params = {
        'mt_id': '123456',
        'mt_adid': campaign_id,
        'v1': user_id,
        'v2': conversion_value,
        'v3': 'server_side'
    }
    requests.get(mediamath_pixel_url, params=params)

    # Send to custom analytics
    analytics_payload = {
        'user_id': user_id,
        'event': 'conversion',
        'channel': 'mediamath',
        'campaign_id': campaign_id,
        'value': conversion_value,
        'timestamp': datetime.utcnow().isoformat()
    }
    requests.post('https://analytics.yourcompany.com/events', json=analytics_payload)

Attribution and Verification Partners

Nielsen Digital Ad Ratings (DAR)

Integration Type: Third-party measurement tag Purpose: Audience verification and demographic measurement

Setup:

Contact Nielsen to set up campaign measurement
Add Nielsen DCR (Digital Content Ratings) tag to creatives
Configure campaign in Nielsen Campaign Manager
Receive Nielsen tracking tags from rep
Apply tags to MediaMath campaigns

Metrics Provided:

On-target percentage (demographic accuracy)
Gross Rating Points (GRPs) for TV equivalency
Unique audience reach and frequency
Demographic composition (age, gender, income)
Device and platform distribution

Use Cases:

Brand campaign measurement
Upfront commitments and guarantees
Cross-media planning with TV
Audience quality validation

Moat Analytics

Integration Type: Viewability and attention measurement Purpose: Viewability tracking and brand safety

Setup:

Enable Moat integration in TerminalOne
Moat tags automatically apply to display campaigns
Configure viewability thresholds in platform
Access reports in Moat Analytics dashboard
Set up alerts for viewability performance

Metrics Provided:

Viewability rate (MRC and GroupM standards)
In-view time and attention metrics
Human vs. non-human traffic
Brand safety violations
Audibility for video ads

Optimization:

Automatically optimize bids for viewability
Exclude low-viewability inventory
Set minimum viewability thresholds (e.g., 70%)
Monitor by publisher, placement, and creative

Integral Ad Science (IAS)

Integration Type: Pre-bid and post-bid verification Purpose: Brand safety, viewability, and fraud prevention

Setup:

Enable IAS integration in TerminalOne platform
Configure brand safety categories and sensitivity levels
Set viewability requirements for campaigns
Enable pre-bid filtering for qualified inventory
Monitor post-campaign verification reports

Protection Features:

Pre-bid contextual targeting and avoidance
Real-time brand safety scanning
Viewability prediction and measurement
Invalid traffic (IVT) detection
Geo-compliance verification

Brand Safety Categories:

Adult content
Violence and hate speech
Illegal drugs
Offensive language
Controversial topics (configurable sensitivity)

DoubleVerify

Integration Type: Verification and optimization platform Purpose: Quality assurance across brand safety, viewability, and fraud

Setup:

Add DoubleVerify to MediaMath campaigns
Configure targeting and avoidance lists
Set performance standards (viewability, fraud rates)
Enable authentic reach measurement
Access DV Pinnacle dashboard for reporting

Features:

Pre-bid avoidance of unsafe inventory
Fraud and IVT prevention
Viewability optimization
Authentic reach measurement
Geographic verification
App and CTV quality scoring

Performance Standards:

Recommended thresholds:
- Brand Safety: < 5% risk rate
- Viewability: > 70% MRC standard
- Invalid Traffic: < 2% IVT rate
- Authentic Reach: > 90% human traffic

API Integration Patterns

Authentication

MediaMath API uses OAuth 2.0 for authentication:

import requests
from requests.auth import HTTPBasicAuth

def get_access_token(client_id, client_secret, username, password):
    """Authenticate with MediaMath API"""

    url = "https://api.mediamath.com/api/v2.0/login"

    response = requests.post(
        url,
        auth=HTTPBasicAuth(username, password),
        headers={
            'Content-Type': 'application/x-www-form-urlencoded'
        },
        data={
            'grant_type': 'password'
        }
    )

    if response.status_code == 200:
        data = response.json()
        return data['token']
    else:
        raise Exception(f"Authentication failed: {response.text}")

Campaign Management

Create Campaign:

def create_campaign(token, advertiser_id, campaign_data):
    """Create a new campaign via MediaMath API"""

    url = "https://api.mediamath.com/api/v2.0/campaigns"

    headers = {
        'Cookie': f'adama_session={token}',
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }

    payload = {
        'name': campaign_data['name'],
        'advertiser_id': advertiser_id,
        'ad_server_id': 1, # MediaMath ad server
        'status': campaign_data.get('status', 'on'),
        'start_date': campaign_data['start_date'],
        'end_date': campaign_data.get('end_date'),
        'goal_type': campaign_data.get('goal_type', 'cpc'),
        'goal_value': campaign_data.get('goal_value'),
        'budget': campaign_data.get('budget'),
        'use_optimization': campaign_data.get('use_optimization', True)
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json()

Update Campaign Budgets:

def update_campaign_budget(token, campaign_id, new_budget):
    """Update campaign budget via API"""

    url = f"https://api.mediamath.com/api/v2.0/campaigns/{campaign_id}"

    headers = {
        'Cookie': f'adama_session={token}',
        'Content-Type': 'application/json'
    }

    payload = {
        'budget': new_budget
    }

    response = requests.put(url, headers=headers, json=payload)
    return response.json()

Reporting API

Performance Report:

def get_campaign_performance(token, campaign_id, start_date, end_date):
    """Fetch campaign performance metrics"""

    url = "https://api.mediamath.com/reporting/v1/std/performance"

    headers = {
        'Cookie': f'adama_session={token}',
        'Content-Type': 'application/json'
    }

    payload = {
        'report': {
            'name': 'Campaign Performance Report',
            'start_date': start_date,
            'end_date': end_date,
            'dimensions': ['campaign_id', 'strategy_id', 'day'],
            'metrics': ['impressions', 'clicks', 'total_spend', 'total_conversions', 'ctr', 'cpc'],
            'filter': f'campaign_id={campaign_id}'
        }
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json()

Audience Segment Report:

def get_audience_performance(token, organization_id, date_range):
    """Analyze performance by audience segments"""

    url = "https://api.mediamath.com/reporting/v1/std/audience"

    payload = {
        'report': {
            'organization_id': organization_id,
            'start_date': date_range['start'],
            'end_date': date_range['end'],
            'dimensions': ['pixel_bundle_id', 'segment_name'],
            'metrics': ['reach', 'impressions', 'clicks', 'conversions', 'conversion_rate'],
            'time_rollup': 'by_day'
        }
    }

    headers = {'Cookie': f'adama_session={token}'}
    response = requests.post(url, headers=headers, json=payload)
    return response.json()

Bulk Operations

Bulk Creative Upload:

def bulk_upload_creatives(token, advertiser_id, creative_list):
    """Upload multiple creatives via API"""

    url = "https://api.mediamath.com/api/v2.0/atomic_creatives"
    headers = {'Cookie': f'adama_session={token}'}

    results = []
    for creative in creative_list:
        payload = {
            'advertiser_id': advertiser_id,
            'concept_id': creative['concept_id'],
            'name': creative['name'],
            'tag': creative['tag'],
            'tag_type': creative.get('tag_type', 'IMG'),
            'width': creative['width'],
            'height': creative['height']
        }

        response = requests.post(url, headers=headers, json=payload)
        results.append(response.json())

    return results

Data Export and Warehouse Integration

Export Options

TerminalOne Reporting UI:

Manual CSV/Excel exports
Scheduled email reports (daily, weekly, monthly)
Custom date ranges and dimensions
Saved report templates

API-Based Exports:

Real-time data via Reporting API
Programmatic report generation
JSON format for easy parsing
Unlimited historical data access

Data Feeds:

S3 bucket delivery (enterprise tier)
SFTP delivery option
Hourly or daily cadence
Log-level impression data
Conversion event feeds

Data Warehouse Integration

BigQuery Integration:

from google.cloud import bigquery
import requests

def sync_mediamath_to_bigquery(token, project_id, dataset_id):
    """Sync MediaMath campaign data to BigQuery"""

    # Fetch data from MediaMath
    performance_data = get_campaign_performance(
        token,
        campaign_id='all',
        start_date='2024-01-01',
        end_date='2024-01-31'
    )

    # Transform to BigQuery schema
    rows = []
    for row in performance_data['data']:
        rows.append({
            'date': row['day'],
            'campaign_id': row['campaign_id'],
            'strategy_id': row['strategy_id'],
            'impressions': row['impressions'],
            'clicks': row['clicks'],
            'spend': row['total_spend'],
            'conversions': row['total_conversions']
        })

    # Load to BigQuery
    client = bigquery.Client(project=project_id)
    table_id = f"{project_id}.{dataset_id}.mediamath_performance"

    errors = client.insert_rows_json(table_id, rows)
    if errors:
        print(f"Errors: {errors}")
    else:
        print(f"Loaded {len(rows)} rows to BigQuery")

Snowflake Integration:

import snowflake.connector

def load_mediamath_to_snowflake(token, snowflake_config):
    """Load MediaMath data into Snowflake"""

    # Fetch MediaMath data
    data = get_campaign_performance(token, 'all', '2024-01-01', '2024-01-31')

    # Connect to Snowflake
    conn = snowflake.connector.connect(
        user=snowflake_config['user'],
        password=snowflake_config['password'],
        account=snowflake_config['account'],
        warehouse=snowflake_config['warehouse'],
        database=snowflake_config['database'],
        schema=snowflake_config['schema']
    )

    cursor = conn.cursor()

    # Create staging table
    cursor.execute("""
        CREATE OR REPLACE TABLE mediamath_staging (
            date DATE,
            campaign_id VARCHAR,
            impressions INTEGER,
            clicks INTEGER,
            spend DECIMAL(10,2),
            conversions INTEGER
        )
    """)

    # Insert data
    for row in data['data']:
        cursor.execute("""
            INSERT INTO mediamath_staging
            VALUES (%s, %s, %s, %s, %s, %s)
        """, (row['day'], row['campaign_id'], row['impressions'],
              row['clicks'], row['total_spend'], row['total_conversions']))

    conn.commit()
    cursor.close()
    conn.close()

Common Integration Issues

Issue 1: Low Audience Match Rates

Symptoms:

DMP segments showing < 60% match rate
Small audience sizes in TerminalOne
Poor campaign performance despite large DMP segments

Causes:

Cookie sync not configured properly
Domain mismatch between DMP and MediaMath
Privacy settings blocking cookie syncing
Stale audience data in DMP

Solutions:

Verify cookie sync pixel is firing:

// Check for MediaMath cookie sync
console.log(document.cookie.includes('mt_misc'));

Test DMP segment refresh rates
Enable server-to-server syncing instead of pixel-based
Review privacy compliance settings
Increase segment lookback window

Issue 2: Conversion Tracking Discrepancies

Symptoms:

MediaMath reporting fewer conversions than GA/Adobe
Attribution window mismatches
Duplicate conversion counting

Causes:

Different attribution methodologies
Time zone differences
Conversion pixel not firing properly
Cross-device attribution differences

Solutions:

Align attribution windows across platforms
Use post-click and post-view windows consistently:
- Post-click: 30 days (industry standard)
- Post-view: 1-7 days (conservative estimate)
Implement server-side conversion tracking for accuracy
Deduplicate conversions using transaction IDs
Accept 10-15% variance as normal

Issue 3: API Rate Limiting

Symptoms:

429 Too Many Requests errors
API calls timing out
Incomplete data exports

Causes:

Exceeding API rate limits (60 requests/minute default)
Large bulk operations without pagination
Concurrent requests from multiple processes

Solutions:

import time
from functools import wraps

def rate_limit(max_per_minute):
    """Decorator to rate limit API calls"""
    min_interval = 60.0 / max_per_minute
    last_called = [0.0]

    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            left_to_wait = min_interval - elapsed
            if left_to_wait > 0:
                time.sleep(left_to_wait)
            ret = func(*args, **kwargs)
            last_called[0] = time.time()
            return ret
        return wrapper
    return decorator

@rate_limit(max_per_minute=50)
def safe_api_call(token, endpoint):
    """API call with rate limiting"""
    return requests.get(endpoint, headers={'Cookie': f'adama_session={token}'})

Issue 4: Viewability Below Thresholds

Symptoms:

Campaign viewability < 70% MRC standard
High impression counts but low engagement
Verification partner flagging inventory

Causes:

Buying low-quality inventory
Below-the-fold placements
Auto-play video without viewability controls
Mobile web viewability challenges

Solutions:

Enable Brain optimization for viewability
Apply pre-bid filters for predicted viewability:

Viewability threshold: >= 70%
Apply to: All display and video campaigns
Verification partner: Moat or IAS

Exclude specific publishers or apps with low viewability
Adjust bid modifiers: +20% for high-viewability inventory
Review creative sizes (larger ads typically more viewable)

CRM and Marketing Automation Integration

Salesforce Integration

Method: Offline conversion uploads + account-based targeting

Setup:

Export MediaMath exposure data via API
Match to Salesforce leads/opportunities by email (hashed)
Upload closed deals back to MediaMath as offline conversions
Build ABM audiences from Salesforce account lists
Measure marketing-influenced pipeline

Use Case Example:

def sync_salesforce_conversions_to_mediamath(token, sf_opportunities):
    """Upload Salesforce closed-won deals as MediaMath conversions"""

    for opp in sf_opportunities:
        # Check if contact was exposed to MediaMath ads
        if opp['mediamath_exposed']:
            # Fire conversion pixel
            conversion_data = {
                'mt_id': '123456',
                'mt_exem': opp['email_hash'],
                'v1': opp['amount'],
                'v2': opp['id']
            }
            fire_conversion_pixel(conversion_data)

HubSpot Integration

Method: Form fills + CRM enrichment

Setup:

Deploy MediaMath pixel on landing pages with HubSpot forms
Capture form submissions as MediaMath conversions
Send conversion data to HubSpot via API
Build retargeting audiences from HubSpot lists
Attribute revenue to MediaMath campaigns in HubSpot

Compliance and Privacy

IAB TCF 2.0 Implementation:

MediaMath supports IAB Transparency & Consent Framework 2.0
Automatically reads consent strings from CMP
Only bids on inventory with appropriate consent
Provides data processing agreement (DPA)

Required Consents:

Purpose 1: Store and/or access information on a device
Purpose 2: Select basic ads
Purpose 3: Create personalized ads profile
Purpose 4: Select personalized ads

CCPA Compliance

California Privacy Controls:

Honors IAB's U.S. Privacy String
Respects "Do Not Sell" signals
Provides opt-out mechanisms
Limited Data Use (LDU) flag support

Implementation:

// Check for CCPA opt-out signal
if (window.usprivacy && window.usprivacy.startsWith('1YY')) {
    // User has opted out - do not load MediaMath pixels
    console.log('CCPA opt-out detected');
} else {
    // Load MediaMath tracking
    loadMediaMathPixel();
}

Brand Safety

Settings in TerminalOne:

Navigate to Strategy Settings > Brand Safety
Select verification partner (IAS or DoubleVerify)
Set sensitivity levels:
- Conservative: Blocks most potentially objectionable content
- Moderate: Balanced approach (recommended)
- Permissive: Minimal blocking, maximum reach
Add custom keyword blocks
Enable contextual targeting for brand alignment

Support and Resources

When to Contact Support

MediaMath Support (support@mediamath.com):

Campaign delivery issues
Billing and payment questions
Platform access problems
Integration setup assistance
Available: 24/7 for critical issues

Technical Support:

API authentication issues
Data feed delivery problems
Pixel implementation questions
Performance optimization guidance

Account Management:

Strategic planning and best practices
New integration recommendations
Quarterly business reviews
Beta feature access

Additional Resources

Backlog & Opportunities

Explore Brain AI optimization for advanced bidding strategies and multi-touch attribution
Evaluate privacy-first identity solutions like UID2.0 for cookieless targeting
Implement server-side conversion tracking for improved accuracy and privacy compliance
Test connected TV (CTV) integrations for omnichannel campaigns
Build custom ML models on exported data for proprietary optimization
Integrate with retail media networks for commerce data activation
Explore attention metrics partnership for beyond-viewability measurement
Implement creative dynamic optimization with real-time product feeds

Overview

Integration Capabilities

Native Platform Integrations

Platform Requirements

Data Management Platform Integrations

Adobe Audience Manager

Oracle BlueKai

Lotame

DMP Integration Best Practices

Analytics Platform Integrations

Google Analytics

Adobe Analytics

Custom Analytics Integration

Attribution and Verification Partners

Nielsen Digital Ad Ratings (DAR)

Moat Analytics

Integral Ad Science (IAS)

DoubleVerify

API Integration Patterns

Authentication

Campaign Management

Reporting API

Bulk Operations

Data Export and Warehouse Integration

Export Options

Data Warehouse Integration

Common Integration Issues

Issue 1: Low Audience Match Rates

Issue 2: Conversion Tracking Discrepancies

Issue 3: API Rate Limiting

Issue 4: Viewability Below Thresholds

CRM and Marketing Automation Integration

Salesforce Integration

HubSpot Integration

Compliance and Privacy

GDPR Compliance

CCPA Compliance

Brand Safety

Support and Resources

When to Contact Support

Additional Resources

Backlog & Opportunities