Enhanced Conversions for Leads: Setup, Verification, and the Things That Quietly Break It

Enhanced Conversions for Leads is the feature that lets a lead-generation advertiser tell Google Ads which clicks actually turned into revenue, weeks after the click happened. It is also one of the easiest things in Google Ads to half-configure: the setup completes, the status looks fine, and the data never arrives. This walks through the setup, the verification step most people skip, and the specific changes that break it without raising an error.

What it actually does, and why it is different from Enhanced Conversions for Web

The two features share a name and almost nothing else. It is worth being precise, because configuring the wrong one is a common and expensive mistake.

• Enhanced Conversions for Web improves the measurement of a conversion that already happened on your site. Someone buys, your tag sends a hashed email alongside the purchase, and Google uses it to recover attribution that cookies lost. The conversion and the match key arrive together.
• Enhanced Conversions for Leads (ECL) is for conversions that happen later and somewhere else. Someone submits a form today. Your sales team closes them in six weeks, in a CRM Google has never seen. ECL captures a hashed identifier at form submit, stores it against the click, and waits. When you upload the closed deal with the same identifier, Google joins the two and credits the original click.

That delay is the whole point. It is also why ECL fails quietly: the gap between configuring it and seeing a result is measured in weeks, so a broken setup looks exactly like a slow sales cycle.

The two halves, and why both must work

ECL is a join between two independent data flows. Most broken implementations have one working perfectly and the other not running at all.

1. Capture. When the lead form is submitted, your site sends Google Ads a lead conversion along with a hashed identifier, normally the email address. This is the half that lives in your tagging.
2. Upload. When that lead becomes a qualified opportunity or a closed deal, you send Google Ads a conversion upload containing the same identifier and a conversion value. This is the half that lives in your CRM or a scheduled export.

Google joins them on the hashed identifier. If the capture step hashes a lowercased, trimmed email and your upload sends the raw address with different capitalisation, the two never match, and both halves will report themselves as healthy while producing nothing.

Setting up the capture half

There are three supported routes. Pick one deliberately, because running two at once is a reliable way to create duplicates.

Route 1: the Google tag, with automatic collection

The lowest-effort option. In Google Ads, open the conversion action for your lead form, turn on enhanced conversions, and choose the Google tag method with automatic collection. The tag then scans the page for fields that look like an email address at the moment the conversion fires.

It works well on a plain server-rendered form on the same page as the conversion. It fails on multi-step forms where the email field has already been unmounted by the time the submit event fires, on single-page apps that navigate before the tag reads the DOM, and anywhere the field is inside a third-party iframe, which the tag cannot read across origins.

Route 2: manual configuration with CSS selectors

The same mechanism, but you tell Google exactly which element holds the email rather than letting it guess. More reliable, and more brittle in a specific way: the selector is a contract with your front end that nobody on the front end knows exists. A redesign that renames a class silently ends the capture.

If you use selectors, write the selector against something stable. An id or a data- attribute survives a restyle; a generated class name from a CSS framework does not.

Route 3: Google Tag Manager with a user-provided data variable

The route most agencies end up on, and the one the autocomplete suggestions for “enhanced conversions for leads google tag manager” are pointing at. You create a User-Provided Data variable in GTM, point it at a dataLayer value your form pushes on submit, and reference that variable from the conversion tag.

This is the most robust option because it does not depend on the DOM at all. The form pushes what it knows at the moment it knows it. It also moves the failure point: if the developer changes the dataLayer key, the variable resolves to undefined and the tag fires without user data, which Google accepts without complaint.

Hashing: the detail that silently voids everything

Google accepts either plain text, which it hashes in the browser before transmission, or a SHA-256 hash you compute yourself. If you hash it yourself, the normalisation has to match exactly what Google expects on the upload side:

• Strip leading and trailing whitespace.
• Convert to lowercase.
• For gmail.com and googlemail.com addresses, remove periods from the local part.
• Hash the result with SHA-256 and send it hex-encoded.

Any difference in that pipeline between capture and upload produces two different hashes for the same person. There is no error for this. The lead is recorded, the upload is accepted, and the match rate is zero. If your ECL has been live for two months with nothing to show, mismatched normalisation is the first thing to check.

Proving it is actually recording

This is the step that separates a working setup from a hopeful one. Do not rely on the setup wizard reporting success.

1. Check the conversion action's diagnostics. In Google Ads, open the lead conversion action and look at the enhanced conversions section. It reports whether enhanced conversion data is being received, and it is explicit when the tag is firing without user-provided data.
2. Submit a real test lead. Use an address you control, fill the form the way a customer would, and complete it on a real device rather than a desktop with every extension disabled.
3. Inspect the outbound request. In the browser network panel, find the conversion request and confirm a user-data payload is attached. An empty or absent one means capture is not happening, whatever the UI says.
4. Wait, then check the diagnostics again. Enhanced conversion reporting is not instant. Give it 24 to 48 hours before concluding anything from an empty report.

The changes that break it

ECL does not degrade gradually. It works until something specific changes, and then it stops entirely. In rough order of how often they cause it:

• A form redesign. New markup, new class names, new field order. Automatic collection stops finding the email; a CSS selector stops matching. Nobody tells marketing, because to the developer it was a visual change.
• A consent management platform. If ad storage consent is denied, the conversion may still fire in a modelled form while the user-provided data is withheld. You keep seeing conversions, so nothing looks wrong, and the match data dries up.
• Moving to an embedded form.Swapping a native form for an embedded third-party widget puts the email field inside an iframe on another origin. The tag cannot read it, and no amount of selector tuning will fix that. The form vendor's own dataLayer push becomes the only route.
• A single-page-app routing change. If the thank-you navigation now happens before the tag reads the form, capture gets an empty DOM.
• A CRM field change on the upload side. The capture half keeps working perfectly while the join quietly stops, which is the hardest version to notice because the conversion count never moves.

The upload half, briefly

Uploads can go through the Google Ads UI as a file, through a scheduled import from Google Sheets or SFTP, or through the API. Whichever route, three things matter more than the mechanism:

• Use the same normalisation as the capture half. This is the single most common cause of a zero match rate.
• Respect the conversion window.A deal closed outside the conversion action's click-through window cannot be attributed, however correct the upload is. Lead-gen businesses with long sales cycles routinely leave the window at the default and then wonder why half their closed deals never appear.
• Upload on a schedule, not when someone remembers. A monthly manual upload means Smart Bidding spends a month optimising on form fills rather than revenue, which is the exact thing ECL exists to prevent.

Why this one is worth monitoring rather than checking

Most tracking failures announce themselves eventually: conversions drop, a dashboard goes flat, somebody notices. ECL does not, because the thing that breaks is not the conversion count. Form fills keep recording at exactly the same rate. What stops is the quality of the signal underneath them, and the only place that is visible is a diagnostics panel inside a single conversion action, in a single account, that nobody opens unless they already suspect a problem.

For an agency running lead-gen across a dozen accounts, that is a dozen panels to check on a schedule nobody keeps. Taglert watches Google Ads conversion actions continuously and emails you when one changes state, so a form redesign on a Tuesday does not become a quarter of bidding on the wrong signal. There is more on how the checks work in our FAQ.