MediaMath Integrations | OpsBlu Docs

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:

  1. Enable Adobe integration in TerminalOne platform settings
  2. Configure destination in Adobe Audience Manager
  3. Map Adobe segments to MediaMath taxonomy
  4. Set up real-time or batch sync schedule
  5. 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:

  1. Contact MediaMath and Oracle to enable integration
  2. Configure BlueKai taxonomy mapping
  3. Set up data sync cadence (real-time or batch)
  4. Enable conversion pixel for attribution loop
  5. 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:

Lotame

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

  1. Enable Lotame integration in TerminalOne
  2. Map Lotame segment IDs to MediaMath targeting
  3. Configure sync frequency and priority rules
  4. Set up conversion tracking for feedback
  5. 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:

  1. Deploy MediaMath pixel on website alongside GA tracking
  2. Enable auto-tagging in TerminalOne for UTM parameters
  3. Configure conversion goals in Google Analytics
  4. Import GA goals into MediaMath via conversion pixel
  5. 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:

  1. Deploy MediaMath pixel container via Adobe Launch
  2. Configure conversion events in Adobe Analytics
  3. Map MediaMath campaign parameters to eVars
  4. Set up processing rules for data normalization
  5. 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:

  1. Contact Nielsen to set up campaign measurement
  2. Add Nielsen DCR (Digital Content Ratings) tag to creatives
  3. Configure campaign in Nielsen Campaign Manager
  4. Receive Nielsen tracking tags from rep
  5. 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:

  1. Enable Moat integration in TerminalOne
  2. Moat tags automatically apply to display campaigns
  3. Configure viewability thresholds in platform
  4. Access reports in Moat Analytics dashboard
  5. 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:

  1. Enable IAS integration in TerminalOne platform
  2. Configure brand safety categories and sensitivity levels
  3. Set viewability requirements for campaigns
  4. Enable pre-bid filtering for qualified inventory
  5. 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:

  1. Add DoubleVerify to MediaMath campaigns
  2. Configure targeting and avoidance lists
  3. Set performance standards (viewability, fraud rates)
  4. Enable authentic reach measurement
  5. 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:

  1. Verify cookie sync pixel is firing:
// Check for MediaMath cookie sync
console.log(document.cookie.includes('mt_misc'));
  1. Test DMP segment refresh rates
  2. Enable server-to-server syncing instead of pixel-based
  3. Review privacy compliance settings
  4. 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:

  1. Align attribution windows across platforms
  2. Use post-click and post-view windows consistently:
    • Post-click: 30 days (industry standard)
    • Post-view: 1-7 days (conservative estimate)
  3. Implement server-side conversion tracking for accuracy
  4. Deduplicate conversions using transaction IDs
  5. 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:

  1. Enable Brain optimization for viewability
  2. Apply pre-bid filters for predicted viewability:
Viewability threshold: >= 70%
Apply to: All display and video campaigns
Verification partner: Moat or IAS
  1. Exclude specific publishers or apps with low viewability
  2. Adjust bid modifiers: +20% for high-viewability inventory
  3. Review creative sizes (larger ads typically more viewable)

CRM and Marketing Automation Integration

Salesforce Integration

Method: Offline conversion uploads + account-based targeting

Setup:

  1. Export MediaMath exposure data via API
  2. Match to Salesforce leads/opportunities by email (hashed)
  3. Upload closed deals back to MediaMath as offline conversions
  4. Build ABM audiences from Salesforce account lists
  5. 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:

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

Compliance and Privacy

GDPR Compliance

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:

  1. Navigate to Strategy Settings > Brand Safety
  2. Select verification partner (IAS or DoubleVerify)
  3. Set sensitivity levels:
    • Conservative: Blocks most potentially objectionable content
    • Moderate: Balanced approach (recommended)
    • Permissive: Minimal blocking, maximum reach
  4. Add custom keyword blocks
  5. 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

Advanced Capabilities

The integrations listed above cover the most common use cases. For additional integration options, custom API connections, or enterprise data pipeline requirements, consult the platform's developer documentation or API reference.

Back to top