Skip to content

Guide

Why Your Facebook Event Match Quality Score Is Low (and How to Raise It Above 8)

  • event match quality
  • emq
  • facebook conversions api
  • advanced matching
  • meta capi
  • server-side tracking

You set your data sharing to “Maximum,” connected the Conversions API, opened Meta Events Manager expecting a healthy green score - and your Event Match Quality is sitting at 4.3. Your purchases are tracked, your ROAS looks soft, and Meta keeps nudging you with “your event match quality could be improved” without telling you the one thing you actually want to know: what is missing, and how do I fix it.

This guide answers exactly that. We will define what EMQ measures (and what it does not), show you the parameters Meta scores and which ones matter most, walk through the specific reasons your score is stuck, and lay out the server-side architecture that reliably lifts EMQ from the 4-6 range into the 8+ range - without guesswork.

What Event Match Quality Actually Measures

Event Match Quality (EMQ) is a score from 0 to 10 that estimates how well the customer information you send with each event lets Meta match that event to a real Meta user account. It is reported per event type (Purchase, AddToCart, ViewContent, and so on) in Events Manager, and Meta also labels the ranges qualitatively - roughly Poor below 4, OK in the middle, and Great above 7. In practice you want every important event sitting at 8 or higher.

Meta calculates the score from three things working together:

  1. Which customer-information parameters you send (email, phone, the click and browser IDs, name, location, and so on).
  2. The quality of that information - correctly formatted, normalized, and hashed.
  3. The percentage of events that actually carry those parameters and get matched to an account.

That third factor is the one most people miss. A perfect set of parameters on 20% of your events scores far worse than a smaller set present on 100% of them. Coverage is part of the grade.

What EMQ is not

Three separate Meta concepts get tangled together constantly. Keep them distinct:

  • Deduplication controls how many times a conversion is counted. It uses event_name and event_id, and it has nothing to do with EMQ. (If your conversions doubled after adding CAPI, that is a deduplication problem - see Facebook CAPI Deduplication.)
  • Coverage / “additional conversions” is about how many events you capture that the browser pixel alone would lose.
  • Event Match Quality is about how accurately each event you do send is tied to a known user.

You can have flawless deduplication and a terrible EMQ, or great EMQ with broken deduplication. Fixing one does nothing for the other. This article is only about the third one - matching accuracy. For the broader definition, see our Event Match Quality glossary entry.

Where to Find Your Score (and How to Read It)

In Meta Events Manager: open Data Sources, select your dataset (pixel), and look at the Event Match Quality column next to each event in the Overview or Events tab. Click the score for any event and Meta opens a breakdown showing which parameters you are sending, how often each one is present, and suggestions for what to add.

That breakdown is the single most useful screen in this entire process, because it tells you precisely which parameters are missing or thinly covered. Before you change anything, read it - your fix should be aimed at the specific gaps it shows, not at a generic checklist.

The score only covers what Meta received. To see what your store actually sends from the browser, run our free Meta Pixel and CAPI checker: it shows whether the _fbp and _fbc cookies are set and how long Safari keeps them, and whether each event carries the event_id a Conversions API copy needs for deduplication.

Why a Low Score Quietly Costs You Money

EMQ is not a vanity metric. The chain is direct:

Better matching → more conversions correctly attributed to the ads that drove them → Meta’s optimization learns from accurate signal → delivery improves and your reported ROAS reflects reality.

When matching is weak, conversions that your ads genuinely caused never get connected to those ads. Meta under-credits your campaigns, the bidding algorithm optimizes against a partial and skewed picture, and your cost per result looks worse than it truly is. A store sitting at EMQ 4 is leaving attributed conversions - and therefore budget efficiency - on the table every single day. Raising the score is one of the highest-leverage tracking fixes available, because it improves the quality of every event you already send.

The Parameters Meta Scores - Ranked by Signal

Meta matches events using the user_data you provide. Here are the parameters that contribute, with their Conversions API field keys, roughly ordered by matching power:

Parameter Field key Hashed? Notes
Email em SHA-256 Highest-signal identifier; the single biggest lever.
Phone ph SHA-256 Very high signal; must be E.164 (country code, digits only).
Facebook click ID fbc No Built from the fbclid URL parameter; deterministic when present.
Facebook browser ID fbp No The _fbp first-party cookie Meta’s pixel sets.
External ID external_id SHA-256 Your stable customer/user ID.
First / last name fn / ln SHA-256 Strengthens matching alongside email/phone.
City / State / Zip / Country ct / st / zp / country SHA-256 Location signals; help disambiguate.
IP address client_ip_address No Required on server events for matching.
User agent client_user_agent No Required on server events for matching.

The headline takeaway: email and phone are the heaviest levers, and the two cookie IDs (fbc, fbp) are deterministic gold when they are present. A setup that sends only an email is the most common cause of a mediocre score. Stacking more correctly-formatted parameters is what pushes you toward 10.

The Six Reasons Your EMQ Is Stuck

Work through these in order. Most stores at EMQ 4-6 are hitting at least two of them at once.

1. You are only sending one parameter

The default browser pixel, left alone, often sends little more than the fbp cookie and maybe an email if Advanced Matching is enabled and the field happens to be on the page. One or two parameters caps your score in the 4-6 band no matter what else you do. Meta literally cannot match better than the data you give it. This is why advertisers say their score is “stuck on Maximum” - Maximum sharing in the pixel UI does not magically invent parameters that were never collected.

2. You collect PII at checkout but never back-fill the earlier events

A store can have a great Purchase EMQ and a dreadful ViewContent or AddToCart EMQ, dragging the overall picture down. This is extremely common on stores whose native channel only attaches hashed email/phone at checkout, when the customer finally types it in. Every upper-funnel event fires with almost no identifiers, so those event types score low and Meta optimizes your top-of-funnel delivery on weak signal.

An important distinction here, because advertisers panic about the wrong thing: a bare PageView scoring 3-5 is normal and correct - it fires before the visitor has typed anything, so it can only carry fbp, fbc, IP, and user agent. The real fix is session enrichment: the moment you learn a visitor’s email (a newsletter popup, an account login, a returning customer), store it and attach it to every subsequent event in that session - AddToCart and InitiateCheckout included. Without enrichment, you throw away identity you already had; with it, your mid-funnel events stop scoring like anonymous traffic.

2b. You added CAPI but the score barely moved

The most common disappointment: you turned on the Conversions API expecting EMQ to jump, and it stayed put. The reason is conceptual - CAPI is a delivery channel, not a data-enrichment mechanism. If you forward the same thin browser-pixel payload server-side, Meta receives the same sparse parameters by a different road and matches them no better. Server-side only helps EMQ when the server actually adds the parameters the browser could not send reliably - phone, the real IP and user agent, a persisted email, fbp, and fbc. The channel is necessary but not sufficient; the data has to be there first.

3. Hashing and normalization errors

This silently destroys matching even when the data is present. The classics:

  • Hashing a value that is already hashed (double-hashing) - Meta gets a string that matches nothing.
  • Hashing fbp, fbc, IP, or user agent. These must be sent in the clear. Hash them and they become useless.
  • Skipping normalization. John@Example.com , john@example.com, and JOHN@EXAMPLE.COM hash to three different values. Without lowercasing and trimming first, the same person looks like three people.
  • Phone numbers without a country code. Meta needs E.164. (555) 123-4567 will not match; 15551234567 will.

A single normalization bug can knock a parameter’s contribution to zero while it still looks present in your payload.

4. Missing or stale fbc and fbp

The fbp browser ID and the fbc click ID are deterministic matching keys, and a huge number of server-side setups drop them entirely because the server never sees the browser cookies. Two specifics:

  • fbc is constructed from the fbclid parameter Meta appends to ad-click URLs, in the format fb.1.<timestamp>.<fbclid>. If you never capture fbclid at landing, you never have an fbc to send.
  • Stale cookies hurt. fbc/fbp change over time; sending an old captured value matches worse than the current one. Capture them first-party and send the freshest value.

Missing these two is one of the most common reasons a server-side integration underperforms a plain browser pixel on matching.

One caveat so you do not chase a phantom: fbc only exists when the visitor actually arrived from a Meta ad click. If a large share of your traffic is organic, direct, or email, those sessions never had an fbclid, so an fbc coverage figure well below 100% can be completely normal rather than a bug. Make sure you capture fbc whenever it is available; do not try to fabricate it for traffic that never clicked an ad.

5. Server events without IP and user agent

For web events sent through the Conversions API, client_ip_address and client_user_agent are required inputs to matching - and they must be the real visitor’s IP and UA, not your server’s. An integration that forwards events from the backend without capturing and passing through the original client IP and user agent throws away two reliable signals and depresses EMQ on every server event.

6. Low coverage percentage

Even with the right parameters, if they are only present on a fraction of your events, your score reflects that fraction. The Events Manager breakdown shows coverage per parameter for a reason. A “send email when we have it” approach that captures email on 30% of sessions produces a 30%-covered email signal. Closing coverage gaps - capturing identifiers earlier and persisting them across the session - is as important as adding parameters.

The Fix: Full Parameter Set, Server-Side, on Every Event

Every cause above resolves to the same prescription:

  1. Send the complete user_data set - email, phone, name, city, state, zip, country, external_id, plus fbp, fbc, IP, and user agent - not just an email.
  2. Send it on every event, from ViewContent through Purchase, so each event type scores well, not just checkout.
  3. Send it server-side through the Conversions API, where ad blockers and browser privacy controls cannot strip the fields the way they strip the browser pixel. (Why this matters in general: signal loss and Why Server-Side Tracking Matters.)
  4. Hash and normalize correctly, following the exact rules below.
  5. Capture fbp/fbc first-party at landing and pass the freshest values, with the real client IP and user agent.
  6. Enrich the session. The instant you learn a visitor’s identity, persist it and attach it to every later event in the session, so mid-funnel events stop scoring like anonymous traffic.

One guardrail while you do this: do not chase a perfect 10 by stripping events. Match quality is graded alongside volume, and Meta would rather optimize on more conversions at a solid score than fewer conversions at a pristine one. Enrich your events; do not delete the ones that lack identifiers.

The hashing and normalization rules, exactly

This is where most manual integrations break. Get it precisely right:

Hash with SHA-256 (after normalizing):

  • em (email) - lowercase, trim whitespace, then hash.
  • ph (phone) - strip everything except digits, include the country code (E.164), then hash.
  • fn, ln (names) - lowercase, trim, then hash.
  • ct, st, zp, country - lowercase/normalize (state and country as standard codes where applicable), then hash.
  • external_id - hash your stable user/customer ID (it can legitimately contain an email, so hash it).

Never hash - send in the clear:

  • fbp (the _fbp cookie value, as-is)
  • fbc (the fb.1.<timestamp>.<fbclid> value, as-is)
  • client_ip_address
  • client_user_agent

Do not double-hash. If a value is already a 64-character hex SHA-256 string, do not hash it again. Hash each raw value exactly once.

Done by hand, that is a real engineering surface: capturing identifiers and cookies first-party before consent flows strip them, persisting them across the session, normalizing each field to Meta’s spec, hashing the right subset exactly once, attaching the real client IP and user agent, and doing all of it on every event type - then keeping it correct as your theme and checkout change. Every one of those steps is a place EMQ silently leaks.

How AxiTrace Solves This by Design

AxiTrace implements that full chain so the score takes care of itself:

  • The server-side Conversions API integration sends the complete advanced-matching set on every event - email, phone, first and last name, city, state, country, zip, external_id, fbp, fbc, plus the real client_ip_address and client_user_agent - not just an email at checkout.
  • Normalization and hashing are handled automatically and correctly. PII fields (email, phone, names, city, state, country, zip) are normalized then SHA-256 hashed; external_id is hashed; and fbp, fbc, IP, and user agent are sent in the clear - exactly as Meta requires. There is no setting to misconfigure and no way to double-hash.
  • The browser SDK captures fbp and constructs fbc from the fbclid at landing, stores them first-party, and forwards the freshest values - so the deterministic cookie IDs are present on events that would otherwise lack them, including upper-funnel ones.
  • Because enrichment happens at ingestion and applies to every event type, ViewContent and AddToCart score as well as Purchase - closing the per-event gaps that drag overall EMQ down.
  • AxiTrace persists identity across the session: once a visitor’s email or profile is known, it is attached to later events automatically, so mid-funnel events carry the same identifiers as the purchase instead of arriving anonymous.
  • The same enriched, correctly-hashed identity is forwarded from one ingestion point to Meta CAPI, the TikTok Events API (which has its own match-quality score), and Google Ads - with the correct field names and hashing rules for each platform.
  • Native plugins for Shopify, WooCommerce, Magento, and Shopware wire this up without touching theme or checkout code.

If your CAPI is brand new, start with the complete Conversions API setup guide; if your conversions doubled, fix deduplication first - then come back and raise EMQ.

Getting Started

  1. Install the plugin for your platform - the Shopify App Store, WordPress.org for WooCommerce, or Packagist for Magento and Shopware.
  2. Connect your Meta Pixel ID and CAPI token in the AxiTrace dashboard.
  3. Fire a few real events, then open Events Manager → Data Sources → your dataset → Event Match Quality and watch the per-event scores climb as the full parameter set arrives.
  4. Check the breakdown - coverage on email, phone, fbp, and fbc should jump, lifting the score on every event type, not just Purchase.

The free tier covers 10,000 visits per month, which is plenty to confirm your EMQ moving from the 4-6 band into the 8+ range before you commit to a paid plan. The real-time dashboard shows which events reached Meta with which parameters, so you can watch matching improve without leaving AxiTrace. The full list of identifiers each platform receives is on the AxiTrace Conversion API page.

Frequently Asked Questions

What is a good Event Match Quality score?

EMQ is scored 0-10. Meta labels roughly below 4 as Poor and above 7 as Great. Practically, aim for 8 or higher on your important events (especially Purchase). A store sending only an email from the browser pixel typically sits around 4-6; sending the full customer-information set server-side via the Conversions API is what lifts it past 8.

Why is my EMQ low even though I set data sharing to “Maximum”?

“Maximum” only controls how much of the data you already collect is shared - it cannot send parameters that were never captured. If your setup only ever collects an email (or only collects PII at checkout), Maximum sharing still leaves you in the 4-6 band. The fix is to actually send more parameters - phone, name, location, external_id, fbp, fbc, IP, and user agent - on every event, server-side.

Which parameters improve Event Match Quality the most?

Email and phone are the heaviest levers, followed closely by the deterministic cookie IDs fbc (the click ID) and fbp (the browser ID). After those, external_id, name, and location fields each add incremental matching power. The single most common upgrade is going from “email only” to “email + phone + fbp + fbc + IP + user agent” on every event.

Do I hash fbp, fbc, IP, and user agent?

No. fbp, fbc, client_ip_address, and client_user_agent must be sent in the clear. Only the personal-data fields - email (em), phone (ph), names (fn/ln), location (ct/st/zp/country), and external_id - are SHA-256 hashed, and only after normalization (lowercase, trim, phone in E.164). Hashing the cookie/IP/UA values, or double-hashing already-hashed PII, silently breaks matching.

Does improving EMQ fix double-counted conversions?

No - those are independent. Deduplication (which controls double-counting) uses event_name and event_id; EMQ measures match accuracy. You can have a perfect EMQ and still double-count, or vice versa. If your conversions inflated after adding CAPI, fix deduplication separately.

Does Event Match Quality apply to TikTok and other platforms?

Meta’s EMQ is Meta-specific, but the underlying principle - richer, correctly-hashed customer data produces better matching and attribution - applies across platforms. The TikTok Events API has its own match-quality score driven by the same kinds of identifiers. Sending the enriched identity from one server-side source keeps match quality high everywhere at once.

Server-side sending recovers the parameters that browser-blocked or consent-stripped events lose, but you must still respect consent: only send identifiers for users who have consented, in line with your privacy policy and applicable law. The gain is that for consented users, the full parameter set reaches Meta reliably instead of being silently dropped by ad blockers and browser privacy controls.

Written by

Chris Gaudy

Founder & CEO

Building accurate conversion tracking for e-commerce teams.

Get tracking insights in your inbox

Tips on server-side tracking, conversion optimization, and product updates. Delivered weekly.

No spam. Unsubscribe anytime.