- Server-side tracking has three cost lines: hosting, setup and upkeep. Pricing pages only show the first, and in the model below it is the smallest.
- Hosted sGTM vendors meter requests. Plugin-style tools like Traculo meter events. They are different units, so compare your own 30-day numbers, not plan labels.
- Google’s own Cloud Run guide puts a server at roughly $45 a month and recommends at least two. That is about $90 a month before you write a single tag (as of October 2026).
- On sticker price at 500K events a month, hosted sGTM runs from about EUR 22 (TAGGRS) to $83 (Stape) to EUR 100 (Addingwell, with custom domain). Traculo is $99. Hosting is rarely what decides it.
- sGTM can do things a plugin cannot: run any tag template and apply custom logic. If you need that, pay for it. If you do not, you are paying for flexibility you will not use.
“How much does server-side tracking cost?” has no single answer, because three different things get sold under that name: a server you run yourself, a server someone else runs for you, and a plugin that forwards events without a GTM container at all. This post prices all three at 10K, 100K, 500K, 1M and 5M events a month, with the assumptions on the table so you can change them.
All prices were read from the vendors’ own pages in October 2026. Where a number is my assumption rather than a published fact, it is labelled as one. If you want the concept first, start with what server-side GTM actually is, or the overview of the plugin approach.
Requests are not events
This is the part that quietly wrecks most cost comparisons. Hosted sGTM vendors bill for requests: every hit that reaches your server container. Stape defines it as “every incoming hit your server container receives”, including script loads such as gtm.js and gtag.js. TAGGRS says a request is every event that happens on your website, with page views, clicks and purchases as examples. Addingwell meters requests sent to your Google Tag Manager container.
An event is what your analytics shows: a page_view, a purchase, a form submission. One pageview on a typical GTM setup can produce a script load, a page_view hit, and then scroll or click hits as the visitor moves around. A page-view-heavy site (a blog, a news site, a directory) therefore generates more requests than the event count in GA4 suggests, because script loads are counted too.
Stape’s own rule of thumb: take your GA4 events for the last 30 days and add 30%. Ten thousand GA4 events become about 13,000 requests. I use that factor below for every request-metered vendor. It is a starting estimate, not a law. Your ratio depends on how many tags fire per page and how much non-human traffic your container domain sees.
How to estimate your own volume
- In GA4, open Reports, then Engagement, then Events, and set the date range to the last 30 days. Google’s help page says this report shows how many times each event was triggered, listed by event name, so add up the event counts to get your total. This is your events number.
- Multiply by 1.3 for a first request estimate. Add more if you load several tags per page.
- If you have no GA4 history, multiply monthly pageviews by the number of events your setup sends per pageview. Three (page_view, scroll, one interaction) is a reasonable placeholder, not a measurement.
- Check the cheapest plan that covers the request number, then add 20% headroom. TAGGRS states that after you exceed the limit, data can no longer be sent to the platforms until you upgrade. Addingwell bills overage per 100K requests.
The cost model and its assumptions
I model a single WordPress site with one custom domain for the tracking endpoint. Scenarios are monthly events as your analytics counts them: 10K, 100K, 500K, 1M and 5M. For request-metered vendors the requests are events times 1.3, so 13K, 130K, 650K, 1.3M and 6.5M. Prices use annual billing where a vendor discounts it, and are not converted between EUR and USD. Hosting only, no engineer time yet.
Self-hosted sGTM on Google Cloud Run
Google’s Cloud Run setup guide states that each server costs approximately $45 a month, based on 1 vCPU and 0.5 GB of memory with CPU always allocated. It recommends running a minimum of two instances to reduce the risk of data loss in an outage, and says autoscaling between 2 and 10 servers should handle 35 to 350 requests per second. Two servers is about $90 a month.
I checked that against the Cloud Run pricing page. Instance-based billing in a Tier 1 region such as us-central1 is $0.000018 per vCPU-second and $0.000002 per GiB-second. One server for a 30-day month (2,592,000 seconds) is 2,592,000 x ($0.000018 + 0.5 x $0.000002) = $49.25 before the free tier of 240,000 vCPU-seconds and 450,000 GiB-seconds, which Google applies once per billing account. Net of that, a single server lands near Google’s $45. Two servers come to roughly $93. Other regions price differently, and logging, egress and any load balancer are extra. Google also advises disabling request logging above 1 million requests a month to cut logging charges.
The important thing is the shape: this cost is nearly flat. Even 6.5M requests a month is only about 2.5 requests per second on average, far below what two servers handle. You pay for always-on capacity, not for volume.
There is a cheaper configuration, and I will call it by its name: my own modelling, not Google’s recommendation. With request-based billing (CPU only billed while handling requests) and two minimum instances kept warm, the idle rate is $0.0000025 per vCPU-second and per GiB-second, active CPU is $0.000024 per vCPU-second, and requests cost $0.40 per million after 2 million free. Assuming 100 ms of billed instance time per request, that models to roughly $19 to $38 a month across our five volumes. The trade-off is cold-start and latency behaviour you must test yourself. Google’s guide recommends the always-allocated setup for a reason.
Stape
From Stape’s pricing page: Free is $0 for up to 10K requests with no custom domain. Pro is $17 a month (billed $200 yearly) for up to 500K requests, also without a custom domain. Business is $83 a month (billed $1,000 yearly) for up to 5M requests, with a custom domain and up to 20 domains. Enterprise is $167 a month (billed $2,000 yearly) for up to 20M. Because a custom domain is what lets you set longer-lived first-party cookies, the chart uses the cheapest plan that includes one.
TAGGRS
On TAGGRS, every plan includes a custom subdomain. Annual billing prices in EUR: Free (up to 10,000 requests), Basic EUR 22 a month (750,000 requests), Pro EUR 57 (3,000,000) and Ultimate EUR 127 (10,000,000). The page says annual billing saves 13%, and also lists USD and monthly variants that I do not use here.
Addingwell
Addingwell sells plans by request volume: EUR 90 a month for 1 million requests, EUR 120 for 5 million, EUR 210 for 12 million, and larger tiers up to 100 million for EUR 1,190. Overage is EUR 2.30 per 100K requests on the first plan and EUR 2.00 on the second. A free plan covers up to 100,000 requests. Optional add-ons: a container at EUR 30 a month, a custom domain at EUR 10, and an extra region at EUR 20. I add the EUR 10 domain from the first paid plan onward, and use overage over the next plan up where overage is cheaper (1.3M requests: EUR 90 + 3 x EUR 2.30; 6.5M: EUR 120 + 15 x EUR 2.00).
Traculo
Traculo is a different shape: a WordPress plugin that forwards events from Traculo’s servers to the ad platforms. There is no container to host. Per the pricing page, plans are metered in events: Free 2,000 events a month; 10K events $12; 50K $49; 100K $79; 500K $99; 1M $139; 5M $210. Every plan includes unlimited domains and integrations, the WordPress plugin and email support. Paid plans keep 24 months of data; the free plan keeps 3. Over the limit, Traculo stops accepting new events (the API answers with HTTP 402) and notifies you until you upgrade or the next period starts. The figures here are monthly prices; on yearly billing the app counts the allowance per year, so check it before you switch.
The numbers side by side
| Events / month | Cloud Run (Google guide) | Stape (with domain) | TAGGRS | Addingwell | Traculo |
|---|---|---|---|---|---|
| 10K (13K requests) | ~$90 | $17 Pro, no domain; $83 Business | EUR 22 | Free (no domain add-on) | $12 |
| 100K (130K) | ~$90 | $83 | EUR 22 | EUR 100 | $79 |
| 500K (650K) | ~$90 | $83 | EUR 22 | EUR 100 | $99 |
| 1M (1.3M) | ~$90 | $83 | EUR 57 | EUR 107 | $139 |
| 5M (6.5M) | ~$90 | $167 | EUR 127 | EUR 160 | $210 |
Read this honestly. On pure hosting price, Traculo is not the cheapest at most volumes. Stape and TAGGRS are cheaper from 500K events up (Addingwell from 1M), and TAGGRS is far cheaper on sticker price across most of the range. At 10K events Traculo ($12) undercuts every paid option, though Addingwell’s free plan (up to 100K requests, no domain add-on) costs nothing. The number that matters is the next section.
Hidden costs: the other two thirds
A hosted container still has to be built. Someone has to:
- Build the tags. Web container, server container, a GA4 client, Meta and Google Ads tags, event deduplication. Each platform has its own required parameters and hashing rules.
- Set up the custom domain and cookies. DNS records, a CNAME or proxy, and checks that the first-party cookie survives Safari’s limits. See client-side vs server-side in WordPress.
- Debug. Preview mode, payload inspection, “why did Meta report fewer purchases” investigations. This is where the hours go.
- Maintain the GTM container. Plugin updates change the dataLayer. A theme change breaks a trigger. A new platform needs a new tag.
- Monitor. A silent failure in a server container means missing data for days. Self-hosted setups need billing alerts (Google recommends one), uptime checks and an on-call human.
The stack above uses my assumptions: $75 per hour, 20 hours of setup and 4 hours a month of upkeep for self-hosting; 12 hours and 3 hours for a hosted container; 1 hour and half an hour for a plugin. Setup is spread over 12 months. That gives about $515, $383 and $143 a month. You may well disagree with those hours. That is the point of publishing them: swap in your own and the ranking only flips if you believe a hosted container takes about as little work as a plugin.
If you are the engineer and you enjoy this, the hours are cheaper to you. If you are a marketer or an agency paying for them, they are the bill. For agencies with many small client sites, the per-site container and per-client debugging multiply quickly; see client reporting for WordPress agencies.
What each approach includes
Where a vendor’s page did not state containers, regions or overage behaviour, I have left it as “not stated” rather than guess. Check the plan comparison before you buy.
What sGTM can do that a plugin cannot
This is the honest counterweight. A server-side GTM container is a general-purpose tag runtime. That buys you:
- Any tag template. If a platform has a server-side GTM template, you can run it. A plugin supports the destinations it ships.
- Custom logic. Transform events, filter or enrich them, split by consent state, route different events to different vendors.
- One container for more than one source. It is not tied to a single WordPress site.
- Preview and debug tooling built into GTM, which many teams already know.
- Server-set cookies on your own domain. Google’s custom domain guide calls same-origin serving a best practice for them.
Traculo, by contrast, forwards events from its servers to Google Analytics 4 (Measurement Protocol), Meta Conversions API, Google Ads offline conversions, LinkedIn, TikTok, Snapchat, Pinterest and Plausible, with a delivery log per event. It is not a GTM server container host and does not replace GTM for every use. If your tag list is outside that set, or you need arbitrary transformations, a container is the right tool. Details on one destination are in the Meta Conversions API for WordPress guide, and if you run a store, WooCommerce server-side tracking covers purchases and refunds.
Which one for which site
- A WordPress or WooCommerce site with a standard ad stack (GA4, Meta, Google Ads and a couple of others): a plugin is the shortest path. You trade flexibility for hours.
- A team already fluent in GTM with many tags and custom rules: a hosted container. The vendor runs the server and you keep the logic. TAGGRS and Stape are cheapest on sticker price at high volume.
- Strict residency, scale or control requirements and an engineer to match: self-hosted Cloud Run. Budget the on-call time, not just the $90.
- An agency with many small sites: count per-container fees and per-domain limits. Traculo plans include unlimited domains; on hosted plans, multi-domain limits differ by tier (Stape Business allows up to 20 domains).
It is also fine to mix: a plugin for the common destinations and a container for the odd one. For the broader privacy and measurement picture behind this choice, see whether server-side tracking bypasses consent, and for the GA4 side specifically, GA4 server-side tracking for WordPress.
A quick way to check the numbers yourself
- Pull 30 days of GA4 events. Multiply by 1.3.
- Pick the cheapest plan that covers it with 20% headroom, including any custom-domain add-on.
- Estimate your hours honestly, once for setup and a monthly figure for upkeep.
- Price your own hours. Add them to the hosting line.
- Compare totals, not plan prices.
Frequently asked questions
Is self-hosting sGTM on Cloud Run cheaper than Stape?
Not by the numbers in Google’s own guide. About $45 a server with two recommended is roughly $90 a month, against $83 for Stape Business as of October 2026, and you also run it yourself. A leaner request-based configuration can model lower, but it is your responsibility to test it.
Are requests and events the same thing?
No. Requests are hits reaching a server container, including script loads. Events are what your analytics reports. Stape suggests events plus 30% as a rough request estimate. Plugin-style tools like Traculo meter events.
What happens if I go over my plan limit?
It depends on the vendor. TAGGRS says data can no longer be sent to the platforms after you exceed the limit unless you upgrade. Addingwell lists a per-100K-request overage rate. Stape’s pricing page does not state overage, so check its help articles.
Do I need a custom domain?
For longer-lived first-party cookies, usually yes. TAGGRS includes a custom subdomain on every plan, Stape from its Business plan, and Addingwell charges EUR 10 a month for one. A plugin that forwards events from its own servers does not need a container domain.
Can a plugin replace sGTM completely?
Only if your destinations are the ones it supports and you do not need custom event logic. Otherwise use a container.
Related reading
- Server-side tracking without GTM: the WordPress plugin approach
- Meta Conversions API for WordPress: the complete guide
- WooCommerce server-side tracking: purchases, refunds, subscriptions
- Client reporting for WordPress agencies
- What is server-side GTM (sGTM meaning)
- Server-side tracking for WordPress: a beginner’s guide
If a plugin sounds like the right fit, see how server-side event tracking works in Traculo, or check the current plans and pricing. The free plan covers 10,000 events a month, enough to test a real setup.
