Meridian: Google open-source MMM framework 2026 practical guide

Meridian — Google's open-source Marketing Mix Modeling framework — was released late 2024 and has matured into a credible alternative to commercial MMM vendors by 2026. It's free, Python-based, and designed for advertisers running paid acquisition campaigns on Google + other channels.

This guide covers Meridian specifics: how it compares to Robyn (Meta's MMM framework), technical setup, first-model implementation timeline, and a 90-day playbook. We assume general MMM familiarity — if starting from zero, see our MMM vs Attribution guide first.

What Meridian is and why Google released it

Meridian is a Python library for building Marketing Mix Models. Key features:

• Bayesian methodology (vs frequentist OLS)
• Saturation curves (Hill or Adbudg shapes)
• Adstock / decay effects modeling
• Geo-experiment integration (combines MMM + geo lift test data)
• Posterior probability distributions (uncertainty quantification)
• Open-source Apache 2.0 license

Released by Google's Marketing Sciences team late 2024. Designed specifically for advertiser use (vs purely academic frameworks). Integrated with typical advertiser data structures: Google Ads, Meta, LinkedIn ad platforms; ecommerce + B2B SaaS outcome metrics.

Why this matters for 2026 advertisers: free, well-documented, maintained by Google, growing community. Lowers MMM barrier to entry for mid-market accounts that couldn't afford €100k+/year commercial MMM.

Meridian vs Robyn (Meta) vs commercial vendors

For 2026 advertisers: Meridian or Robyn are equivalent technical choices — pick based on team language preference. Commercial vendors only justify cost at enterprise scale or when internal data science capacity is limited.

Technical requirements and architecture

Software stack:

• Python 3.9+ (3.11 recommended in 2026)
• Meridian package (pip install google-meridian)
• BigQuery / Snowflake / similar data warehouse
• Jupyter notebooks for development
• Production: Docker + Airflow / Cloud Composer for orchestration

Hardware / cloud:

• Local development: standard laptop sufficient for initial work
• Production runs: Cloud Run or Vertex AI custom training jobs
• Cost: €500-2k/month typical compute + storage

Team:

• Lead data scientist (Bayesian methods background)
• Data engineer (pipelines + cloud infrastructure)
• Marketing analytics lead (translates business needs)
• Executive sponsor (drives organizational adoption)

Total ongoing investment:

• People: 1-2 FTE data scientists at €100-200k/year
• Infrastructure: €5-20k/year
• Total: €100-400k/year (vs commercial vendor €50-500k/year)

ROI cross-over: in-house Meridian becomes cheaper than commercial vendor around €200k/year MMM spend.

Setup: Python environment + data ingestion

Step 1 — Python environment:

python -m venv meridian-env
source meridian-env/bin/activate
pip install google-meridian pandas numpy matplotlib jupyterlab

Step 2 — Validate install:

python -c "import meridian; print(meridian.__version__)"

Expected output: version number (e.g. 1.0.x in 2026).

Step 3 — Data ingestion structure: Meridian expects pandas DataFrames with specific columns:

• time: weekly date stamps
• geo: geographic identifier (if geo-experiment integrated)
• KPI: outcome variable (revenue, conversions)
• media_spend: spend by channel (one column per channel)
• media_impressions: optional, impressions by channel
• controls: seasonality, promotions, competitor activity

Step 4 — Data pipeline from BigQuery:

from google.cloud import bigquery
import pandas as pd

client = bigquery.Client()
query = """
SELECT week_start, SUM(google_ads_spend) AS gads,
       SUM(meta_spend) AS meta, SUM(revenue) AS revenue
FROM marketing_data
GROUP BY week_start
"""
df = client.query(query).to_dataframe()

For production: schedule daily BigQuery extracts, weekly Meridian model refresh, quarterly full retrain.

Running first model: configuration + execution

Initial model configuration (simplified):

from meridian.model import Meridian

model = Meridian(
    n_media_channels=4,
    n_control_channels=3,
    adstock_specifications=[...],
    saturation_specifications=[...],
)

model.fit(
    data=df,
    n_samples=10000,
    n_chains=4,
)

Expected run time:

• Small model (3-5 channels, 2 years data): 30-60 minutes on standard laptop
• Medium model (6-10 channels, 3 years data): 2-4 hours
• Large model (15+ channels, 3+ years data): 8-24 hours on cloud compute

Key outputs:

• Channel contribution: % of total outcome attributed to each channel
• Saturation curves: response to additional spend per channel
• Adstock decay: temporal lag per channel
• Posterior distributions: uncertainty quantification

Visualize via Meridian's built-in plotting functions or custom matplotlib.

Validating outputs: holdout testing

Critical validation step:

Holdout methodology:

1. Train Meridian on 80% of historical data
2. Predict on remaining 20% (most recent 6 months)
3. Compare predictions to actuals
4. Calculate R² and MAPE (mean absolute percentage error)

Acceptable thresholds:

• R² > 0.7 on holdout: model captures real signal
• R² 0.5-0.7: model partially captures, needs refinement
• R² < 0.5: model not capturing real dynamics, audit inputs / methodology

Common holdout failures:

• Missing significant external factors (promotion, competitor launch)
• Data quality issues (inconsistent channel naming)
• Inappropriate adstock/saturation priors
• Insufficient data history

Iteration: refine model based on holdout findings. Add control variables, adjust priors, validate again. Expect 3-5 iteration cycles before production-ready.

When Meridian fits vs alternatives

Meridian fits when:

• €500k-5M/year marketing spend (sweet spot)
• In-house Python data science team
• Multi-channel mix including offline
• Willingness to invest 3-6 months for first model
• Want full control over methodology

Alternatives better when:

• Robyn (Meta MMM): same fit profile but team prefers R language or has Meta-heavy spend
• Commercial vendor (Analytic Partners, etc.): enterprise scale (€5M+), limited data science capacity, need managed service
• No MMM (just attribution + incrementality): below €500k/year, digital-only marketing

For most mid-market accounts in 2026 considering MMM: Meridian or Robyn is the right path. Commercial vendors are over-spec'd for sub-enterprise needs.

90-day Meridian implementation playbook

The HowTo schema details day-by-day. Strategic phasing:

Month 1 — Setup: team, prerequisites, data collection, Python environment.

Month 2 — Modeling: initial model build, holdout validation, refinement cycles.

Month 3 — Activation: stakeholder review, scenario planning, production deployment, quarterly refresh setup.

For complementary measurement context, see our MMM vs Attribution guide, incrementality testing guide, and first-party data strategy.

If you'd like AI-driven Google Ads optimization that aligns with Meridian-derived budget allocation, SteerAds runs a free 14-day audit on Google + Microsoft Ads.

Sources

• github.com/google/meridian — Meridian open-source repository
• developers.google.com/marketing-mix-modeling — Meridian documentation
• research.google/pubs — Google research on MMM methodology
• github.com/facebookexperimental/Robyn — Robyn comparison reference
• thinkwithgoogle.com — Google industry insights

FAQ