Analytics and Tracking

Client (Server-Side)

Also called sGTM client

The component in a server container that receives an incoming request, claims it, and turns it into a usable event.

Quick facts: Client (Server-Side)

Category
Analytics and Tracking
Also called
sGTM client
Level
Advanced
Affects
Server-side event creation, debugging time, data completeness
Where to see it
Google Tag Manager (server container Clients, preview mode)
In this article4
  1. How a client works
  2. Why clients matter
  3. Where clients go wrong
  4. How to act on it

How a client works

A server container does not run on page views. It runs on requests arriving at its endpoint, and something has to decide what each request actually is. That something is a client. When a request comes in, the clients in the container are offered it in priority order; the first one that recognises the shape of the request claims it, and the rest never see it.

Having claimed the request, the client parses it into an event with named parameters — a purchase carrying a value and a currency, for instance — and only then do the container’s triggers and tags run against it. Google supplies clients for its own measurement formats, and other clients can be installed or written for request types they do not cover.

Why clients matter

They are the point at which a server container becomes usable at all. Without a client that recognises the incoming traffic, requests arrive, nothing claims them, and the container appears broken even though every tag inside it is correct. The tags were simply never asked to run.

Clients also set the ceiling on what the rest of the container can see. Anything the client does not parse does not exist as far as your triggers and variables are concerned, so a client reading only part of a payload quietly limits what you will ever be able to forward.

Where clients go wrong

Priority order is the usual trap. Two clients that both recognise a request type will compete for it, and priority decides the winner rather than anyone’s intent. The outcome is a request handled by the wrong client, producing an event that looks almost right — right enough to survive a quick check and fail on the details later.

The other frequent problem is a mismatch between what the browser sends and what the client expects. A payload of your own design needs a client written for it; the built-in ones will not claim it, and the debugging trail left behind is unhelpfully quiet.

How to act on it

Begin every server-side investigation at the client rather than at the tags. Open the container preview and check whether the request was claimed and by which client; if nothing claimed it, no amount of work on triggers will help. Inspect the parsed event next, and only after that look at the tags.

Keep the number of clients small, set their priorities deliberately, and write down which client handles which traffic, because that is not obvious to whoever inherits the server container next. If you are planning a move to server-side tag management, settle the client arrangement before building tags, since everything downstream depends on it.

Do and do not

Do

  • Debug the client before touching any tags
  • Set client priorities deliberately rather than by default
  • Record which client handles which traffic

Do not

  • Assume tags can run without a claim
  • Leave two clients competing for one request
  • Send a custom payload with no matching client

Questions people ask about this

What happens if no client claims a request?

Nothing downstream runs. The request arrives, every client declines it, and the container finishes without creating an event, so triggers never evaluate and tags never fire. From the outside that looks identical to a broken tag, which is why a server-side investigation should always start by checking whether the request was claimed at all.

Is a client the same as a trigger?

No. A client receives the raw incoming request and turns it into an event. A trigger then decides which tags respond to that event once it exists. The order is fixed: claim first, then trigger, then tag. A trigger cannot compensate for a request that no client recognised in the first place.

Do I need a custom client?

Only if you send request formats the built-in clients do not understand, such as a payload of your own design or a vendor endpoint you are proxying through your domain. Standard Google measurement traffic is already covered. Writing a client is developer work, so treat it as part of the build rather than a configuration step.

Related terms

Found this useful?

Share it, or ask an AI to summarise it

Back to the glossary

Knowing the term is the easy part

Applying it to your own site and budget is the work. Book a call and I will tell you what actually applies to you.