DASHBOARD

Performance Marketers: 6 Fixes for Purchase Event Match Quality

  • Blog
  • Posted on1 week ago
Hands wiring network hardware with glowing lights

Event Match Quality is Meta’s 1-10 confidence score for how well the data in your events matches real Meta accounts. The single highest-priority fix for most advertisers: get hashed email, hashed phone, and correct event_id deduplication onto every Purchase event. Do that first, and optimization speeds up while cost per acquisition drops.

TL;DR:

  • Adding hashed email and phone to every Purchase event can significantly increase your Event Match Quality scores, especially from a 5-6 range into the high 7s or above.
  • The goal should be to achieve a Purchase EMQ score of 8 or higher by focusing on key identifiers and ensuring consistent hashing and event_id usage across Pixel and server-side events.
  • Diagnostic tools within Events Manager help identify missing identifiers, formatting errors, and deduplication issues that impact match confidence.
  • Implementing server-side enrichment with tools like TrackAff can automate and maintain high-quality, consistent data flow, boosting ROAS by up to 70%.

Table of Contents

What Event Match Quality Means for Your Meta Campaigns

Event Match Quality is not the same thing as match rate. Match rate tells you what percentage of events Meta could tie to a known user. EMQ goes deeper, scoring the confidence of that match on a 1 to 10 scale based on which identifiers you sent and how clean they were, according to Meta’s own documentation.

That distinction matters because Meta’s ad-delivery system doesn’t just count conversions. It uses matched events to refine who it shows your ads to, build lookalike audiences, and calibrate bidding. A Purchase event that matches with high confidence tells the algorithm exactly who converted. A Purchase event that barely matches gives the system a shaky signal it has to guess around.

Per-event scoring is the part advertisers overlook most. Your account doesn’t have one EMQ score. It has a separate score for Purchase, for AddToCart, for ViewContent, and for every other event you send. A blended average can hide a serious problem: a store might show a respectable aggregate number while its Purchase events, the ones that actually drive spend decisions, sit at a 4 or 5.

Purchase carries the most weight for one simple reason: it’s the event most campaigns optimize toward, and it’s the one connected most directly to revenue. A few reference points worth knowing:

  • Email-only matching commonly lands EMQ in the 5 to 6 range.
  • Adding hashed phone frequently pushes that same event into the 7-plus range.
  • Upper-funnel events like PageView and ViewContent tend to score lower by nature, since fewer identifiers exist that early in a session.

If you’re only going to fix one event this quarter, fix Purchase.

The Identifiers That Actually Move Your Score, and How to Format Them

Meta doesn’t weigh every identifier equally. Some carry real matching power. Others add marginal help. Getting the formatting wrong on any of them can silently zero out their value, even when the field is technically present.

Hashed email (em), hashed phone (ph), and external_id do the heaviest lifting. These three identifiers are what Niblin’s diagnostic guidance points to as the highest-impact levers for moving a mediocre score into a strong one. Below them sit fbp (the Meta browser cookie), fbc (the click identifier), IP address, user agent, and personal details like name and address. These secondary fields help, but they rarely rescue a Purchase event that’s missing email or phone entirely.

Formatting is where most implementations quietly fail. A field can be present in your payload and still contribute nothing if it isn’t normalized the way Meta expects.

Identifier Format Meta expects Common mistake
Email (em) Lowercase, trimmed, then hashed with SHA-256 Hashing before lowercasing, or including trailing spaces
Phone (ph) E.164 format (country code, no symbols), then SHA-256 Local formatting with symbols sent unhashed or unformatted
External_id Consistent hashed identifier tied to a user or session Different ID generated per event, breaking continuity
Address/state Two-letter ISO country and state codes Full state names or non-standard abbreviations
fbp / fbc Sent as plaintext strings, never hashed Accidentally hashing cookie values meant to stay raw

These normalization rules come from practical audit work on Conversions API setups, and they’re consistent with what Michael Dishmon’s technical breakdown documents in detail.

The failure mode to watch for is subtle: a hashed field that’s malformed often looks identical to a correctly hashed field in your logs. Nothing throws an error. Meta simply can’t match it, and your EMQ quietly stays lower than it should.

Pro Tip: Run the same customer record through your Pixel-side hashing function and your server-side hashing function, then compare the two hash outputs directly. If they don’t match character for character, your Pixel and CAPI events are describing the same person in two different “languages” Meta can’t reconcile.

How to Check Your Event Match Quality Score in Events Manager

You don’t need a third-party dashboard to audit this. Meta gives you the tools inside Events Manager, and the process takes about ten minutes once you know where to click.

  1. Open Events Manager and select the data source (Pixel or dataset) tied to your ad account.
  2. Click into the Overview tab and find the events table. Each event name, Purchase, AddToCart, ViewContent, shows its own EMQ score, not a blended average.
  3. Click a specific event row to drill into its detail view. This shows identifier coverage: the percentage of that event’s traffic that included email, phone, external_id, and so on.
  4. Use the Connection Method filter to split Pixel-sourced events from Conversions API-sourced events. This is often where the real gap hides. Browser-side Pixel events might carry great fbp/fbc coverage while server-side CAPI events are missing hashed email entirely, or vice versa.
  5. Open the Diagnostics tab to see Meta’s own flagged warnings, missing parameters, deduplication conflicts, formatting errors.
  6. Send test traffic through Test Events before pushing a fix live. This confirms your payload structure is correct without waiting on real conversion volume to reveal a mistake.

Once you make a change, don’t expect instant results. EMQ typically updates within a 24 to 48 hour window, but full stabilization across your event history can take 3 to 5 days as Meta reprocesses matched traffic. Checking your score six hours after a fix and concluding it didn’t work is one of the most common false alarms in this process.

Audit Purchase first, then work backward through your funnel. A clean per-event check on ViewContent and AddToCart often surfaces leaks that never show up if you’re only glancing at the aggregate score.

Hands holding smartphone with dark analytics screen

The Priority Order for Raising Purchase EMQ

Not every fix deserves equal urgency. Some changes move the needle immediately. Others matter but can wait. Work through this list in order, and don’t move to step three until steps one and two are confirmed working.

  1. Add hashed email and hashed phone to every Purchase event, on both Pixel and server side. This is the single highest-leverage change available to most advertisers. Email-only setups commonly sit around EMQ 5 to 6; adding a properly hashed phone number often pushes that same event past 7, according to Niblin’s audit findings. If you fix nothing else this week, fix this.

  2. Forward fbp and fbc cookie values from browser to server. Your Pixel captures these values automatically when a visitor lands on your site. Your server-side Conversions API call needs to receive and forward those same values unchanged, sent as plaintext, never hashed. A surprising number of implementations either drop these cookies entirely on the server side or accidentally hash them, which breaks their usefulness.

  3. Attach external_id to every key event, including guest checkouts. When a customer isn’t logged in, you can’t pull a database user ID, but you can synthesize a stable identifier from a browser fingerprint or an fbp-based proxy, then hash it consistently across every event tied to that session. This approach can materially lift ViewContent and AddToCart EMQ specifically because those mid-funnel events rarely have login data to draw on.

  4. Set identical event_id values between your Pixel and server-side events for the same conversion. This is what powers deduplication. Without matching event_id values, Meta may register the Pixel event and the CAPI event as two separate conversions, and neither one carries the complete identifier set the other captured. That mismatch doesn’t just inflate your counts, it can actively suppress your effective EMQ because Meta is working with two partial pictures instead of one complete one.

  5. Audit hashing consistency across every environment that sends events. Your checkout page, your server, and any third-party tag manager involved all need to apply SHA-256 the exact same way, on lowercased and trimmed input, every time. One inconsistent hashing function anywhere in that chain silently degrades match quality without throwing a visible error.

  6. Confirm domain-to-pixel mapping and Aggregated Event Measurement configuration. If you run multiple domains or subdomains, verify each one is correctly mapped to the right pixel and that your AEM event prioritization reflects your actual funnel. A misconfigured domain mapping can cause events to fire against the wrong dataset entirely.

Fixing these mechanics in order can raise EMQ by 20 to 40 percent in practical case work, and the returns taper the closer you get to a perfect score. Chasing an event already sitting at 9.0 up toward 9.5 rarely justifies the engineering time; getting every key event into the 7.5 to 8.5 band is where the real optimization gains live.

Pro Tip: Before declaring a fix “done,” send a live test purchase through your own checkout and pull that exact transaction in Events Manager’s event detail view. Confirm every identifier you expect to see (hashed email, hashed phone, external_id, matching event_id) actually appears on both the Pixel-sourced and CAPI-sourced version of that single event.

Fast Diagnostics for the Problems That Keep Coming Back

A handful of implementation problems account for most low EMQ scores. Here’s how to spot each one quickly, without a full re-audit of your tracking stack.

  • Symptom: Purchase EMQ is stuck below 6 despite sending email and phone. Test it by hashing the same customer record through both your Pixel-side and server-side hashing logic, then compare outputs. A mismatch almost always traces back to inconsistent lowercasing, trimming, or phone formatting before the SHA-256 step.
  • Symptom: fbp and fbc show as missing on server-side events in Events Manager. Check whether your backend is actually reading the browser cookie value and forwarding it unmodified. A frequent culprit: the cookie exists on the client but the server-side integration never picks it up before firing the CAPI call.
  • Symptom: ViewContent and AddToCart score noticeably lower than Purchase. These events usually fire before login, so external_id is often absent. Generating a consistent, hashed proxy identifier, from an fbp value or session token, for guest traffic closes this gap without waiting for account creation.
  • Symptom: Duplicate conversions appearing in reporting, or Diagnostics flagging deduplication warnings. This points to event_id mismatches between your Pixel and server events for the same transaction. Pull a sample transaction and confirm the exact same event_id string, not just a similar one, fires on both the browser call and the server call.

Each of these checks takes minutes once you know what to pull up in Events Manager. The pattern across nearly all of them is the same: the data exists somewhere in your stack, it’s just not reaching the event payload in the format Meta needs.

Setting Realistic Targets and Keeping EMQ Healthy Long-Term

Aim for a Purchase EMQ of 8 or higher. Mid-funnel events like AddToCart and InitiateCheckout have a realistic target closer to 6.5 to 8, since they naturally carry fewer identifiers than a completed transaction with a name, email, and shipping address attached.

Hands soldering electronic circuit board

Track four numbers on a recurring basis: per-event EMQ for your top three events, identifier coverage percentage (how many events include email, phone, and external_id), any deduplication warnings in the Diagnostics tab, and the resulting trend in CPA and ROAS. These four together tell you whether a score change is a technical issue or a real shift in customer behavior.

Check EMQ within 24 to 72 hours of any tracking change to confirm the fix landed correctly. Then shift to a weekly cadence for ongoing monitoring; daily checking mostly just captures normal fluctuation. A steady score that gradually declines over several weeks, even by half a point, usually signals a hashing update, a new checkout integration, or a CRM webhook change disrupted something upstream. Because EMQ relies on personal identifiers like email and phone, keep your hashing and consent practices aligned with regulations such as GDPR and CCPA. Hash PII before it ever leaves your server, and confirm your consent flows cover the data you’re passing to Meta.

TrackAff’s Perspective on Fixing Match Quality at the Source

Most EMQ problems trace back to one root cause: the browser pixel never sees what happens after the click. TrackAff’s approach closes that gap through server-side enrichment, a branded form that captures the actual purchase, deposit, or registration event, and consistent hashing paired with event_id deduplication between Pixel and Conversions API calls.

The identifier fixes covered above, hashed email, hashed phone, forwarded fbp/fbc, matching event_id, are exactly what this kind of setup is built to enforce automatically rather than leaving to manual QA. Advertisers using this method have reported up to a 70% improvement in ROAS, which lines up with what you’d expect once Meta’s algorithm is optimizing against complete, high-confidence purchase data instead of partial signals. Better matched events give the system a clearer picture of who actually buys, not just who clicks.

— Terry

Fix Your Conversion Data With TrackAff’s Server-Side Tracking

Everything covered above, hashing consistency, event_id deduplication, forwarding fbp and fbc, gets harder to maintain by hand as your funnel grows across landing pages, CRMs, and checkout providers. TrackAff handles that enforcement automatically: server-side Meta tracking paired with a branded form captures off-site purchases, deposits, and registrations, then reports them back through Conversions API with consistent hashing and event deduplication built in, no manual audit required every time you launch a new funnel.

Trackaff

CRM webhook integration means your sales team’s actual close data, not just form fills, feeds back into Meta so campaigns optimize around buyers instead of leads. If you’ve just walked through the priority fixes above and want the enforcement layer instead of a recurring manual audit, start a free trial with TrackAff and connect your first funnel today.

Sources

Written with BabyLoveGrowth to rank on Google

Stop guessing

Your deals close off the pixel. Meta never finds out.

TrackAff reports your real conversions back to Meta the moment they happen, tied to the exact ad that produced them. 10-minute setup, no code.

Start free 14-day trial → Card required · No charge until day 14 · Cancel in one click

Leave A Comment