---
title: "Synter Pixel vs. Google Tag Manager: Why Server-Side Conversions Win"
description: "GTM is a browser tag dispatcher. The Synter Pixel is a first-party conversion system that fans events out server-side to every ad platform, routes leads to your CRM, and is verified and monitored so it can't silently break."
date: "2026-06-26"
draft: false
category: "engineering"
tags:
  - "Product"
  - "Conversion Tracking"
  - "Engineering"
---

## Two tools people confuse — and shouldn't

If you run ads, you have almost certainly been told to "just
put it in GTM." Google Tag Manager is great at what it does.
But it does not do the thing most advertisers actually need:
reliably count conversions and send them back to your enabled ad
platforms.

The Synter Pixel does. This post explains the difference in plain
terms, shows the architecture, and — because we believe in being
honest about our own mistakes — walks through a regression we hit,
how we fixed it, and the automated guardrail that now catches it.

## The one-sentence difference

**Google Tag Manager**

A tag dispatcher. It loads in the browser and
fires whatever tags you wire up — analytics, vendor pixels,
custom HTML. It does not own your conversion data and does not
send conversions server-side on its own. When a blocker, ITP, a
bad trigger, or a removed conversion action gets in the way, it
fails silently.

**Synter Pixel**

A conversion system. One script captures a
canonical event, ships it to Synter, and Synter fans it out
server-side to your enabled, configured
ad-platform destinations using your own ad-account connection.
Leads route to your CRM when one is connected. Every attempted
send is audited, destinations are verified, and coverage is
monitored daily.




You can use both. GTM is a perfectly good way to
deploy the Synter Pixel — a Custom HTML tag that loads
synter-pixel.js. What GTM does not do is replace
Synter&apos;s server-side conversion engine.

## How the Synter Pixel works

One script tag. From there everything is automatic and canonical —
you don&apos;t hand-wire a trigger per event or a variable per click
ID.

1. Capture (browser). synter-pixel.js
auto-tracks PageView and — critically —
Lead on any form with an email field (native
HTML, HubSpot, Typeform, Contact Form 7, Webflow, Framer).
Ecommerce events (ViewContent, AddToCart, Checkout, Purchase) are
auto-captured on Shopify; on other sites you fire them with an
explicit synter(&apos;track&apos;, …) call. It also
grabs supported click IDs (gclid, fbclid
, rdt_cid, ttclid,
li_fat_id, msclkid, sccid,
epik) plus UTMs. Collection is consent-gated — the
pixel only sends once consent is granted.
2. Ingest (server). Events POST to
/api/pixel/events and are stored as one canonical
event — normalized once, not per vendor.
3. Fan out (server). A config-driven router forwards
each event to your enabled destinations using
your own platform connection and writes an audit
row for every attempted send, so a silent no-op is visible.
4. Route leads to CRM. When a CRM connection is
present, Lead events also flow to Attio, so sales sees the
conversion, not just the ad platform.

Supported destinations today: Google, Meta, LinkedIn, Reddit,
TikTok, Microsoft, Snapchat, Pinterest, X, and OpenAI Ads.
Conversions only go to the destinations you&apos;ve enabled and
configured. Each is a small adapter, so adding a platform means
registering one more adapter rather than rewriting the fan-out
logic.

## Side-by-side

| What you need | Google Tag Manager | Synter Pixel |
| --- | --- | --- |
| Where conversions are sent | Browser tags, unless you build server GTM | ✅ Server-side to enabled destinations via each
destination&apos;s API |
| Click-ID & UTM capture | Manual variables + triggers | ✅ Automatic |
| Lead detection on embedded forms | ❌ Native trigger misses Fillout/Typeform/HubSpot | ✅ Auto-detects any email form |
| Ad-blocker / ITP resilience | ❌ Each vendor pixel can be blocked individually | ✅ Consent-gated collection request (still blockable), then
server-side send once received |
| Lead routed to CRM | ❌ Not a CRM tool | ✅ Routes to Attio when connected |
| Verification it actually works | ❌ Eyeball Tag Assistant | ✅ Safe, platform-specific verification probe |
| Alerts when it breaks | ❌ Silent | ✅ Daily coverage monitor |

## The trap: the tag is live, but nothing counts

The most painful failure in conversion tracking isn&apos;t a missing
tag. It&apos;s a tag that fires correctly and
still reports zero conversions. Three usual
suspects:

- The Lead trigger doesn&apos;t fit the form.
Embedded forms (Fillout, Typeform, HubSpot, Calendly) don&apos;t
fire GTM&apos;s native gtm.formSubmit.
- The conversion action was removed in the ad
account, so the tag fires into a dead action.
- The campaign isn&apos;t bidding on conversions
(e.g. Maximize Clicks), so even correct conversions don&apos;t
change delivery.

The Synter Pixel removes the first two from the table for
server-side conversions: it owns a canonical Lead event and verifies
the destination before declaring it healthy.

## We hit this ourselves — here's what we did about it

In June 2026 we discovered that some customer pixel events were
being stored but never forwarded. A shared backend
bug — a mis-bound :settings::jsonb parameter when
saving a destination — caused destination writes to fail for weeks.
A production sweep found only 2 of 325 ad-running
orgs had a verified server-side destination. The UI said
"installed." Reality said otherwise.

The root cause was that "is the pixel installed?" and
"are conversions actually arriving?" are two different
questions, and we only checked the first. We fixed it on three
levels:

- Fixed the bug and added a regression test to
catch that parameter-bind bug if it regresses.
- Swept production — removed orphaned destination
rows and backfilled partial settings.
- Added a permanent guardrail: a daily coverage
monitor that alerts whenever an org has a Synter Pixel configured,
an active ad-platform connection, and enabled destinations but
zero verified destinations. It stays low-noise by
only paging on unambiguous breakage, not on freshly-created
pixels.


Being straight about limits: Google&apos;s
server-side conversions still require your own conversion-action
ID and a live Google connection — Synter can&apos;t invent those.
The monitor proves a destination was verifiable; campaign strategy
(are you bidding on conversions?) is a separate check.

## So: GTM or Synter Pixel?

- Want a reliable source of truth for conversions + leads? →
Synter Pixel
- Already manage every script through GTM? →
Deploy the Synter Pixel as a GTM tag. Best of
both.
- Want conversions that aren&apos;t lost to a blocked vendor pixel
and route one canonical event to your enabled destinations? →
Synter Pixel, server-side.

## Get started

Install the Synter Pixel once and it starts capturing pageviews and
leads automatically (plus ecommerce events on Shopify) — then
connect your ad accounts and Synter handles the server-side fan-out.



Install the Synter Pixel →
