Event match quality (EMQ) is Meta's score, out of 10, for how well the customer information on your events lets Meta match them to people on its platforms. You raise it by sending more of the right identifiers with each event, especially hashed email and phone, the fbc click ID, the fbp browser ID, client IP address and user agent, all correctly formatted. You do not raise it by inventing data or sending information you have no consent to share.
For agencies, EMQ matters because events Meta cannot match to a person cannot be attributed to an ad or used well for optimization. A Conversions API setup that sends a bare Lead event with no customer data technically works, and still leaves the account learning from less than it could. This guide covers what the score reflects, which parameters actually move it, how to hash and normalize them, how to capture the click ID, where privacy limits apply, and how to verify the result.
What event match quality is
Meta shows an EMQ score per event in Events Manager. It is most relevant for events sent through the Conversions API, because server events carry only the identifiers you choose to include. A browser Pixel event automatically carries cookies and browser context; a server event carries whatever your code puts in its user_data object.
Meta describes the score in bands (poor, OK, good, great) and shows which parameters you send, how often each one is present, and which ones it suggests adding. The score is an estimate of matching effectiveness, not a performance metric. A higher score does not guarantee cheaper leads. It means Meta has a better chance of connecting the conversion to the person who saw the ad.
The customer information parameters that matter
Meta accepts a long list of customer information parameters. In practice a handful do most of the work for lead-gen and e-commerce clients.
| Parameter | What it is | Hash it? | Where it usually comes from |
em | Email address | Yes, SHA-256 | Form field, checkout |
ph | Phone number | Yes, SHA-256 | Form field, checkout |
fn, ln | First and last name | Yes, SHA-256 | Form fields |
ct, st, zp, country | City, state, ZIP, country | Yes, SHA-256 | Address fields, checkout |
external_id | Your own ID for the person, such as a CRM contact ID | Recommended | CRM or customer database |
fbp | Meta browser ID from the _fbp cookie | No | Cookie set by the Pixel |
fbc | Meta click ID from the _fbc cookie or fbclid | No | Cookie or landing page URL |
client_ip_address | Visitor IP address | No | Server request |
client_user_agent | Browser user agent string | No | Server request |
For website events sent via the Conversions API, Meta requires the client user agent, and in practice you should always send the IP address too. Both must come from the visitor's browser, not from your server. A server GTM container or a backend that sends its own IP and user agent instead of the visitor's is a common, quiet mistake.
Which ones move the needle
Email and phone are generally the strongest identifiers because people use them to sign up for Meta's apps. The fbc click ID ties an event directly to an ad click, which is valuable for attribution. fbp ties server events to the browser that also sent Pixel events. Names and location fields add less on their own but help when combined with others.
external_id is worth sending consistently on both Pixel and server events. It does not identify the person to Meta directly, but it helps Meta link events from the same person across sessions and channels.
Hashing and normalization
Meta requires personal fields like email, phone and name to be hashed with SHA-256 before you send them through the Conversions API. Hashing alone is not enough; you have to normalize first, or the hash will not match Meta's hash of the same value.
- Email: trim whitespace, convert to lowercase.
Jane@Example.com becomes jane@example.com before hashing.
- Phone: digits only, including the country code, with no plus sign, spaces, dashes, brackets or leading zeros. A US number becomes something like
15551234567.
- Names: lowercase, no punctuation, trimmed. Use UTF-8 for names with special characters.
- City: lowercase with spaces removed. State: two-letter code in lowercase for US states. ZIP: for the US, the first five digits. Country: two-letter ISO code in lowercase.
The most common hashing errors we see:
- Phone numbers hashed with the plus sign or without the country code, so they never match.
- Email hashed before lowercasing, so mixed-case addresses fail.
- Double hashing: a plugin hashes the value and a server tag hashes it again.
- Hashing
fbp, fbc, IP or user agent, which must be sent unhashed.
On the browser side, the Pixel can send customer information through advanced matching. Automatic advanced matching, turned on in the Pixel settings, lets the Pixel pick up fields like email from forms on the page. Manual advanced matching passes values in the Pixel's init call, and the Pixel hashes them before sending. Either way, check what is actually being sent rather than assuming.
Capturing fbc from fbclid
When someone clicks a Meta ad, the landing page URL usually carries an fbclid parameter. The Pixel turns it into the _fbc cookie, with a format like fb.1.1730000000000.AbCdEf123: a prefix, a subdomain index, a creation timestamp in milliseconds and the click ID itself.
For server events, you want that value in the fbc field. There are three common ways to get it:
- Read the cookie. If the Pixel ran, the
_fbc cookie exists. Server GTM receives cookies on requests to your first-party endpoint; a backend can read it if the form posts to the same domain, or you can copy it into a hidden form field.
- Build it from the URL. If the Pixel was blocked, the cookie may not exist. In that case you can construct
fbc from the fbclid in the landing page URL, using the same format and the time of the click. Meta documents this format; follow it exactly and do not modify the click ID's case.
- Store it with the lead. Save the
fbc value and fbclid on the CRM record. This matters for later events, such as a qualified lead sent from the CRM days afterwards, when the browser is long gone.
The trap here is the redirect. If the landing page redirects (a tracking link, a language redirect, a form tool on another domain), the fbclid can be stripped before anything reads it. Click a real ad, or paste a URL with a test fbclid, and follow it through to the form. Our CRM lead attribution service covers keeping click IDs alive from landing page to CRM, and the guide to lead source attribution in HubSpot and GoHighLevel walks through the fields.
Consent and privacy limits
Match quality is not a reason to ignore consent. A few rules apply regardless of how good the score could be:
- Only send what you collected for this purpose. If the client's privacy policy and consent flow do not cover sharing customer data with advertising platforms, fix that first, with the client and their legal advice.
- Respect consent choices on the server too. If a visitor declines marketing cookies, the server should not send their event with identifiers as if they had agreed. Moving tracking to the server does not move it outside consent rules.
- Use Meta's consent and data processing tools where relevant. The Pixel supports consent grant and revoke calls, and Meta offers Limited Data Use through data processing options for certain US state privacy laws. Which ones a client needs depends on where they operate.
- Do not send sensitive data. Health conditions, financial details and similar information do not belong in event parameters or URLs. Meta restricts some categories of business, and its systems may block events that look like they carry sensitive information.
For clients with EEA or UK traffic, the consent setup on the site determines what Meta can receive at all. That is a site-wide decision, not a Meta setting. The Consent Mode v2 implementation guide covers the Google side, and the same consent banner usually controls the Meta tags too.
How to raise the score honestly
Work through these in order. Each step is about sending data you legitimately have, correctly.
- Send the visitor's IP and user agent on every server event. Make sure they are the visitor's, not the server's.
- Send
fbp and fbc on every server event where they exist. This often lifts match quality and also helps deduplication. Pair it with a shared event ID, as covered in the Conversions API deduplication guide.
- Send hashed email and phone on conversion events where the form collects them. Lead and Purchase events are where you have this data; a PageView will never have it, and that is fine.
- Add
external_id consistently, using the same value on the Pixel and the server.
- Add name and location fields if the form already collects them. Do not add form fields just to raise the score; that costs conversion rate.
- Fix normalization errors. Check formats in Events Manager's parameter breakdown and in the payloads themselves.
Expect different events to have different scores. A Lead event with email and phone can score well while ViewContent stays low, because there is no customer information on a product page view. Focus on the events campaigns actually optimize for.
How to verify
Do not rely on the score alone, because it updates over days and averages across all events. Check the payload directly.
- Test Events. Send a server event with the test event code and open it. Test Events shows which customer information parameters arrived. Confirm email, phone,
fbp, fbc, IP and user agent are present and that hashed fields look like 64-character hex strings.
- Server GTM preview or backend logs. Inspect the outgoing request. Compare the hashed email against a hash you compute yourself from the normalized test address.
- Events Manager over time. After a few days of production traffic, check the EMQ score per event and the parameter coverage. Coverage tells you what share of events include each parameter, which is often more useful than the score.
- Click a real ad path. Use a URL with an
fbclid and confirm fbc arrives on the server event, including when the browser blocks the Pixel.
What we check in an audit
- EMQ per event, and which events campaigns actually optimize for
- Each customer parameter sent from browser and server, and its coverage
- Normalization and hashing on email, phone and names, checked against test submissions
- Whether IP and user agent belong to the visitor or the server
- How
fbclid survives redirects and whether fbc is stored with the lead
- Consent behavior: what is sent when a visitor declines
If you want to check a client quickly before a full review, the tracking health check gives a first read.
Getting it fixed
Low match quality is usually a few missing or misformatted fields, not a rebuild. Our Meta Conversions API service adds the right hashed parameters, captures the click ID and documents the before and after scores in the client's own Events Manager.