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:
- Which customer-information parameters you send (email, phone, the click and browser IDs, name, location, and so on).
- The quality of that information - correctly formatted, normalized, and hashed.
- 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_nameandevent_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 |
|---|---|---|---|
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, andJOHN@EXAMPLE.COMhash 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-4567will not match;15551234567will.
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:
fbcis constructed from thefbclidparameter Meta appends to ad-click URLs, in the formatfb.1.<timestamp>.<fbclid>. If you never capturefbclidat landing, you never have anfbcto send.- Stale cookies hurt.
fbc/fbpchange 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:
- Send the complete
user_dataset - email, phone, name, city, state, zip, country, external_id, plusfbp,fbc, IP, and user agent - not just an email. - Send it on every event, from ViewContent through Purchase, so each event type scores well, not just checkout.
- 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.)
- Hash and normalize correctly, following the exact rules below.
- Capture
fbp/fbcfirst-party at landing and pass the freshest values, with the real client IP and user agent. - 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_fbpcookie value, as-is)fbc(thefb.1.<timestamp>.<fbclid>value, as-is)client_ip_addressclient_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 realclient_ip_addressandclient_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_idis hashed; andfbp,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
fbpand constructsfbcfrom thefbclidat 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
- Install the plugin for your platform - the Shopify App Store, WordPress.org for WooCommerce, or Packagist for Magento and Shopware.
- Connect your Meta Pixel ID and CAPI token in the AxiTrace dashboard.
- 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.
- Check the breakdown - coverage on email, phone,
fbp, andfbcshould 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.
Will server-side matching work if customers reject cookie consent?
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.