Marketing reporting is one of those tasks that looks simple until you’re doing it at 23:00 on a Sunday because the client call is Monday morning. You pull GA4 manually. You export a spreadsheet from the ad platform. You open another tab for social analytics. Then you paste it all together and try to write something that sounds like a human made a decision, not a robot concatenated numbers.
We’ve been through this enough times at Choco Media to know it doesn’t have to work that way. Automating your weekly marketing report with AI is not a grand transformation project — it’s a set of practical pipeline decisions that, once made, run quietly in the background while you use Mondays for actual thinking.
This post walks through exactly how we build that pipeline: which data sources to pull, how to connect them without custom code, where AI adds genuine value in the summarisation step, and what the finished report looks like in practice. The phrase you’ll keep hearing is “automate marketing report” — not because it sounds impressive, but because that’s precisely what this is.
Why weekly reporting is worth automating before monthly reporting
Most automation conversations start with the monthly report. Monthly is flashier, more strategic, goes to stakeholders. But monthly cadence means you discover problems four weeks after they started. Weekly cadence means you catch a broken conversion event, a collapsed CTR, or a mis-paced budget before it compounds.
Weekly also has less political weight. If the automated report is slightly imperfect, the cost is low. You fix the prompt or the data connection. By the time you’re comfortable with weekly, monthly is a shorter version of the same pipeline with a longer lookback window.
- Weekly reports run when nothing is on fire, so you can review the output calmly
- A failed weekly report affects one meeting, not a board pack
- The feedback loop is tighter — you improve the pipeline every seven days, not every thirty
- Weekly data is clean enough for AI summaries; monthly data often needs manual context that AI can’t infer
Start with weekly. The monthly version arrives automatically once the plumbing works.
The four data sources that cover 90% of marketing reports
Before any automation, you need to know what goes into the report. Most agencies and in-house teams pull from some combination of these four:
GA4 — traffic, engagement, conversions
GA4 is the foundation. You need sessions, engaged sessions, conversion events, and landing page performance at minimum. The GA4 Data API allows direct querying without exporting CSVs.
Meta Ads — reach, spend, ROAS, CPL
Meta’s Marketing API returns campaign, ad set, and ad-level data. For automated reports, we usually pull at the campaign level: spend, impressions, clicks, results (defined as your primary conversion), and cost per result.
Google Ads — same dimensions, different auction
The Google Ads API or Google Ads scripts can export weekly data into a Google Sheet automatically. Most teams with modest spend prefer Ads scripts over the full API — they run inside Google Ads, require no hosting, and write directly to Sheets.
A CRM event or email platform
Depending on the business, this might be HubSpot deals created, Klaviyo revenue, or form submissions. This is where the “so what” of paid media and SEO lives. Traffic means nothing without conversion downstream.
- GA4 Data API (free, requires OAuth or service account)
- Meta Marketing API (free, requires a System User and App)
- Google Ads scripts (free, runs natively inside Google Ads)
- HubSpot/Klaviyo — most platforms have a native Zapier or Make connector
If all four feel overwhelming, start with two: GA4 and whichever ad platform drives the most spend. A two-source report is already 80% of the value.
The Make or n8n pipeline: how the data flows
We use Make (formerly Integromat) for most client pipelines because it handles OAuth refreshes without manual intervention. n8n is a strong alternative if you prefer self-hosted. Zapier works but becomes expensive at weekly cadence across multiple data sources.
The basic flow looks like this:
- A scheduled trigger fires every Monday at 07:00 (before anyone is in the office)
- Each data source module pulls the previous seven days of data into a structured object
- The data is merged into a single JSON blob or passed as formatted text
- An AI module (OpenAI or Claude) receives the data plus a system prompt
- The AI output is written to a Google Doc or sent as an email
The AI step is where most teams underestimate the prompt work. The model doesn’t know what good looks like for your client. It doesn’t know that a 2.1x ROAS is actually strong for a high-AOV product with long attribution windows, or that a 15% drop in sessions is expected because of a seasonal pattern you’ve tracked for two years. That context has to be in the prompt.
The system prompt structure we use
A system prompt for weekly report generation should contain:
- Client context: industry, typical AOV, primary conversion goal, current campaign focus
- Benchmarks: what “good”, “acceptable”, and “needs attention” look like for each metric
- Tone guidance: how formal or informal, whether the client wants bullet commentary or prose
- An explicit instruction to flag anomalies, not just describe numbers
- A section template: what headings to use and in what order
Without this context, AI summaries read like a school report where the model lists what happened without saying whether it matters. With it, the output reads like a draft written by a junior analyst who understood the brief.
What the AI actually does well in this pipeline
Let’s be direct about where AI adds value here and where it doesn’t.
AI is good at pattern matching across numbers, drafting narrative commentary, and flagging deviations from a baseline you defined. It is not good at knowing whether a deviation matters, spotting root causes in data it can’t see, or replacing the conversation you need to have with the client about their business.
Specifically, AI handles these steps well in a report pipeline:
- Summarising week-over-week movement across multiple metrics in plain language
- Highlighting the two or three metrics that moved most significantly
- Drafting a brief “next steps” section based on patterns in the data
- Adapting tone to match whether the week was strong or weak
- Translating raw numbers (e.g. “CTR fell from 1.8% to 1.2%”) into plain English (“click-through rate dropped by a third”)
What it does poorly:
- Understanding why a metric changed without additional context you supply in the prompt
- Knowing which metrics the client actually cares about unless you tell it
- Producing insight about seasonality unless you include historical baselines
- Replacing the human review that catches “this number looks wrong” before it goes out
This is the same split we explore in our work on AI automation for marketing teams — the principle is consistent: AI handles structured, repeatable summarisation; humans handle contextual judgement.
Connecting GA4 to Make: the practical steps
This is where most guides get vague. Here’s what the connection actually requires.
- Create a Google Cloud project and enable the GA4 Data API
- Create a service account with Viewer access to your GA4 property
- Download the JSON key file and add it to Make as a custom connection
- In Make, use the Google Analytics 4 module with the “Run a report” action
- Set dimensions (e.g. pagePath, sessionDefaultChannelGroup) and metrics (e.g. sessions, conversions, engagementRate)
- Set the date range to “last 7 days” using Make’s dynamic date syntax
The service account route is more reliable than OAuth for scheduled automation because it doesn’t expire when someone changes their Google password. Set it up once and it runs indefinitely.
Formatting the data before the AI step
Raw API output is not ready for an AI prompt. You need to flatten nested JSON, calculate derived metrics (e.g. conversion rate = conversions / sessions), and format numbers consistently.
In Make, the built-in tools handle most of this. For anything more complex — like joining data from multiple sources into a single table — a short JavaScript or Python module inside Make or a Google Sheets intermediary is the cleanest approach.
Structuring the report output
The final report should answer three questions in order:
- What happened this week? (summary of key numbers)
- What matters about what happened? (anomalies, significant changes, trend confirmation)
- What should we do next? (one or two concrete actions)
Anything beyond this gets skimmed. We’ve tested long reports versus short ones across dozens of client relationships and the short format wins every time — not because clients are unsophisticated, but because long reports shift the burden of finding the point onto the reader.
Our standard weekly report template includes:
- A one-paragraph overview (AI-generated, human-reviewed)
- A metrics table: this week vs. last week vs. same week last year where available
- A highlights section: two to three observations worth discussing
- A one-paragraph next-steps recommendation
For clients on our AI content creation retainers, we append a content performance block showing which posts drove the most organic sessions that week and whether any are trending for new keywords.
The human review step you cannot skip
Fully automated means the report goes out without anyone reading it first. That is a risk we don’t take, and we’d recommend against it for any client-facing output.
The human review takes two to four minutes. You’re not rewriting — you’re checking for three failure modes:
- Data pulled incorrectly (wrong date range, missing source, API error)
- AI commentary that sounds plausible but contradicts what you know about the account
- Tone that’s off — overly optimistic when the week was weak, or flat when it was strong
Build this review into the schedule as a non-negotiable step. The pipeline produces a draft; a human sends the report. The time saving is still significant — from 90 minutes of assembly to four minutes of review.
For clients where trust is high and the report format is stable, some teams move to a “approve or amend” model: the report is drafted and staged for sending, and the reviewer either approves with a single click or opens the doc to amend. This works well once you’ve run the pipeline for at least six weeks without issues.
Common failure modes and how to prevent them
API token expiry
Service accounts for GA4 don’t expire. OAuth tokens for Meta Ads do. Set a calendar reminder every 60 days to check that Meta connections are still active, or use a Make error notification to alert you when a step fails.
Date range drift
If your pipeline runs on Monday and pulls “last 7 days”, confirm whether “today” is included. Some platforms report Monday’s data by Tuesday. If in doubt, pull data for the week ending Sunday and run the pipeline Tuesday morning.
Metric definition mismatches
GA4’s “conversions” count every conversion event that fires. If you have five conversion events, this number is misleading as a headline metric. Define a “primary conversion” in your prompt and instruct the AI to use that as the lead number.
AI hallucinating context
If the prompt leaves gaps, the model fills them. It may invent a reason why a metric changed or compare against a benchmark you didn’t provide. Solve this with explicit instructions: “Do not speculate about causes unless the data provided supports the inference” and “Use only the baselines listed below.”
- Test every connection manually on the first three runs
- Log each run to a Google Sheet: timestamp, data received (yes/no), report sent (yes/no)
- Add an error step in Make that sends you a Slack or email notification if any module fails
How long does this take to build?
For a two-source pipeline (GA4 + one ad platform), a Make scenario, and a Google Doc output: four to six hours on the first build, including prompt iteration. A four-source pipeline with a polished email output format takes eight to twelve hours.
That’s a one-time investment. Once running, the ongoing maintenance is around thirty minutes per month: checking connections, tweaking the prompt as the account evolves, and refreshing benchmarks quarterly.
At three clients, the break-even on a four-hour build is two weeks of Monday mornings.
The kind of systematic automation thinking that shapes this pipeline is also central to how we approach bespoke retainer engagements — we build the infrastructure once and let it run so the attention stays on decisions, not on data collection.
If you’re considering whether this is worth building for your agency or in-house team, the honest answer is: if you’re manually assembling the same report more than twice a month, the pipeline pays for itself quickly. Get in touch if you’d like to talk through what the build would look like for your specific stack.