For a business that buys advertising on the web, Google Ads is hard to avoid. The usual way to measure a campaign is to put Google's scripts in your pages, and those scripts send Google what your visitors do.

At SoftInstigate we measure the Google Ads campaigns of Ulabase from our server. No Google script runs in the browser. When a visitor who came from an ad signs up, our server tells Google that the click became a conversion.

Server-Side Tracking Protects User Privacy

This post explains how it works, what Google receives and what it does not, and what changed for us.

If you want to do the same in your application, write to SoftInstigate at team@softinstigate.com.

The Problem with Traditional Tracking

The Google Ads tag and the Google Analytics tag are scripts that run in the visitor's browser. They read the page, set cookies and talk to Google's servers directly. You decide to install them. After that, Google decides what they collect.

Three things follow:

  • In the EU those cookies need consent, so the site needs a banner, and the visitors who refuse are not measured.
  • Ad blockers and the tracking protection of Safari and Firefox stop the scripts, so those visitors are not measured either.
  • The visitors who are measured are followed by Google's code on every page.

The Server-Side Solution

The mechanism rests on one parameter. When someone clicks an ad, Google adds a click id to the address of the landing page: ?gclid=abc123.

Our frontend reads that parameter and keeps it in the browser's local storage. Nothing goes to Google at this point.

When the visitor signs up, the click id travels to our backend with the sign-up, and the frontend deletes it. Our server then sends one conversion event to Google, through the Data Manager API.

Google matches the click id with the click it recorded, and credits the campaign.

What Google Receives

This is the full list, read from our code.

For a conversion, and only when the visit carries a click id, our server sends:

  • the click id;
  • the date and time of the conversion;
  • which conversion it is: a sign-up, a new service, a purchase;
  • for a purchase, the order id, the value and the currency;
  • the email of the user, hashed with SHA-256.

The hashed email is personal data. Google can compare it with the hashes of the emails it knows, and that is what it is for: it helps the match when the click id alone is not enough. We send it only together with a click id, never alone. The click id is enough for attribution, so you can leave the email out.

For a page view, our server sends Google Analytics the address of the page, the referrer, the click id when there is one, and a random id. That id lives in the browser tab and disappears when the tab is closed.

Google does not receive cookies, the IP address of the visitor, or anything a script could read from the browser. The calls come from our server, so the address Google sees is ours.

What We Get From It

No Google script in the page

Our pages load no Google Tag Manager, no Analytics tag and no Ads tag. There is less JavaScript to download. An ad blocker has nothing to block, since the measurement happens between our server and Google.

No consent banner

We removed the consent banner from the site. Our pages set no tracking cookie and load no third-party script. The browser stores two things: the click id, until the sign-up, and the random id of the tab.

This is the assessment we made for our site. The rules look at what a site stores on the visitor's device and why, so make your own assessment for yours.

Campaigns optimized on conversions

Google Ads can optimize a campaign for clicks or for conversions. With the conversions coming from our server, Smart Bidding works on sign-ups.

Take two campaigns. Campaign A brings 1000 clicks and 10 sign-ups. Campaign B brings 500 clicks and 50 sign-ups. Measured on clicks, A looks better. Measured on sign-ups, B brings five times as many with half the clicks.

When the Click Id Is Missing

Some browsers and ad blockers remove the gclid parameter from the address. For those visits we have no click id, and no conversion goes to Google.

The sign-up is still recorded in our database, marked as not sent. So we know how many conversions Google does not see.

Sending Conversions Through the Data Manager API

Our server first sent conversions with the Google Ads API call ConversionUploadService.UploadClickConversions. In November 2026 we moved our credentials to a new Google Cloud project. A validation request from the new project showed that Google now refuses the upload, with CUSTOMER_NOT_ALLOWLISTED_FOR_THIS_FEATURE.

The error message explains it: "New integrations for uploading click conversions should use the Data Manager API". Google accepts UploadClickConversions only from integrations that already used it. A newer Cloud project counts as a new integration.

So the server now sends each conversion to the Data Manager API, with a POST to https://datamanager.googleapis.com/v1/events:ingest. The OAuth token needs the scope https://www.googleapis.com/auth/datamanager.

The request names the Google Ads account and the conversion action, then lists the events. This is the request our server builds, with placeholders in place of the real values:

{
  "destinations": [
    {
      "operatingAccount": { "accountType": "GOOGLE_ADS", "accountId": "YOUR_CUSTOMER_ID" },
      "loginAccount": { "accountType": "GOOGLE_ADS", "accountId": "YOUR_CUSTOMER_ID" },
      "productDestinationId": "YOUR_CONVERSION_ACTION_ID"
    }
  ],
  "encoding": "HEX",
  "events": [
    {
      "adIdentifiers": { "gclid": "GCLID_FROM_THE_AD_CLICK" },
      "eventTimestamp": "2026-11-06T10:15:30Z",
      "eventSource": "WEB",
      "transactionId": "YOUR_ORDER_ID",
      "conversionValue": 49.0,
      "currency": "EUR",
      "userData": {
        "userIdentifiers": [ { "emailAddress": "SHA256_OF_THE_EMAIL_IN_HEX" } ]
      }
    }
  ]
}

The account id goes in as digits only. transactionId is present only for a sale, so a purchase delivered twice is counted once. conversionValue and currency are present only when the conversion has a value.

The email is lowercased, trimmed and hashed with SHA-256 before it leaves our server. encoding: HEX tells Google how the hash is written.

A 200 response carries a requestId. It means Google found the request valid and accepted it. Google matches the click id to an ad click later, on its side.

Older guides tell you to get a developer token and send it in a header. Google retired the developer token on 2026-09-09: the header is now optional and ignored. The access level belongs to the Google Cloud project of your OAuth client.

If you start today, use the Data Manager API from the first request. Set validateOnly: true in the request while you test: Google checks it and writes nothing.

What Changed for Ulabase

  • Our pages contain no Google script.
  • The site has no consent banner.
  • Every conversion is in our own database, sent or not, with Google's answer or the reason it was not sent.
  • What leaves our infrastructure is the list above, and it can be read in our code.

Is This Right for You?

It fits if you run Google Ads campaigns, the conversion happens on a backend you control, and you want to decide what Google receives.

It does not fit if you need the reports that depend on Google's scripts in the browser, such as audiences and remarketing lists.

It also takes backend work: reading the click id, keeping it until the conversion, calling the API and handling its errors.

Build your app on Ulabase

Your backend is ready in minutes, and you spend your time on your app. The Free plan needs no credit card.