Meta Conversions API: The Complete Guide for Media Buyers

In this article, we'll explain how Meta Conversions API works, why you should use it alongside Meta Pixel, what Event Match Quality tells you, and how improper event deduplication can lead to inaccurate conversion data. We've also put together a practical CAPI setup checklist for Facebook Ads.

Дата обновления: 12/10/2019

Publication date: 5/11/2026

Author: Profit Rental

Reading time: 7 min

Introduction

If your campaigns run on an agency ad account, Meta's optimization is only as good as the data you feed it. Since iOS 14+ and browser-level tracking restrictions, the Pixel alone no longer sees a full picture of what happens on your site. The Meta Conversions API (CAPI) closes that gap by sending conversion events straight from your server, and it's now the difference between an account that learns fast and one that stays stuck in the learning phase burning spend.

This guide covers what CAPI actually does, how it works alongside the Pixel, and the two metrics — Event Match Quality and deduplication — that determine whether your setup is actually helping.

What Is the Meta Conversions API

The Meta Pixel fires in the visitor's browser: it watches page behavior and sends events to Meta from the client side. The Conversions API sends the same kind of events — PageView, AddToCart, Purchase — but from your server directly to Meta's API, with no dependency on the visitor's browser executing any script.

That server-side path matters because it isn't affected by what happens in the browser: an ad blocker, a disabled cookie, or a privacy prompt the visitor declined. The server sends the event regardless.

Any personal identifier included with an event — email, phone number, name — has to be SHA-256 hashed before it leaves your server. Meta never receives raw personal data, only the hash, which it compares against its own hashed records to find a match.

Pixel vs Conversions API

They aren't competing methods — they're the same event sent through two different paths, and Meta explicitly recommends running both together, not picking one.

Why both, not just CAPI: the Pixel still contributes browser-specific signals (fbp, fbc) that help tie a server event back to a specific ad click. Running them together and deduplicating gives Meta a more complete record than either path alone — the Pixel's reach plus the server's reliability.

The practical reason this matters more than it used to: since iOS 14+ made the App Tracking Transparency prompt opt-in (and most users decline it), plus Safari and Brave stripping tracking parameters by default, the industry-wide estimate is that browser-only tracking now misses a meaningful share of real conversions — commonly cited as a quarter or more, though the exact number depends on your traffic mix and browser split. Meta's optimization only works on what it can see; a Purchase event that never arrives can't inform who to show your ad to next.

How the Conversions API Actually Works

At a technical level, a CAPI event is a POST request from your server (or through a partner integration — Shopify, GTM server-side container, a CRM webhook) to Meta's Graph API, containing:

Event data: event name (Purchase, Lead, CompleteRegistration), timestamp, source URL, value/currency for commerce events.
User data: whatever identifiers you have — hashed email, hashed phone, name, IP address, user agent, city/state/zip, external_id (your own stable user ID), and the browser-set fbp/fbc cookies if you're also running the Pixel.
event_id: a unique ID you generate, shared with the matching Pixel event if one exists — this is what makes deduplication possible (more on this below).

Meta's matching engine takes whatever hashed identifiers arrive and checks them against its own user graph — which is why the API is only as useful as the data quality behind it. Sending only an IP and a user agent gives Meta almost nothing to match against; sending a hashed email and phone alongside it gives Meta something close to certain identification.

Event Match Quality: The Number That Actually Tells You If It's Working

Setting up CAPI without checking Event Match Quality (EMQ) is how teams end up thinking their integration works when it's barely helping. EMQ is a 0–10 score Meta assigns to your events in Events Manager, reflecting how confidently it could match that event to a real account.

What moves the score, roughly in order of impact:

Hashed email and phone — by far the strongest identifiers, since Meta can match them directly against account data.
Name and location — meaningful secondary signal when email/phone aren't available.
Server-side implementation itself — CAPI simply has access to more customer data than the Pixel ever will.
fbp/fbc cookies — tie the server event back to a specific browser session and ad click.
external_id — a stable identifier (your own user or order ID) that helps even without personal data.
Correct hashing — SHA-256, with email lowercased and trimmed before hashing; a formatting mistake here silently breaks matching even though the request succeeds.

As a baseline: hashed email plus fbp, IP, and user agent is usually enough to push EMQ to 7 or higher. If your account is sitting below 5, the fix is almost always missing customer data, not a broken integration.

Deduplication: Running Both Without Double-Counting

The moment you run Pixel and CAPI together, every conversion fires twice — once from the browser, once from your server. Without deduplication, that's double-counted conversions and an optimization signal that's twice as noisy as it should be.

Meta's primary deduplication method matches on event_id + event_name together. Generate one event_id per actual conversion, and send it with both the Pixel event and the matching CAPI event, using the same event_name on each side (Purchase on both — not Purchase on one and purchase_complete on the other). Meta sees the matching pair, keeps one, discards the duplicate.

A weaker fallback exists — matching on _fbp cookie plus event_name when no event_id is present — but it's less precise and can occasionally miss a real duplicate or merge two unrelated events that happen to arrive close together.

Common ways deduplication breaks in practice:

Mismatched or missing event_id between the Pixel call and the server call — the single most common cause.
Different event_name values on each side, even for the same logical event.
Client-side-only ID generation when the browser is blocked — the server never learns the ID it should reuse.
Delayed server-side batching that pushes the event outside Meta's matching window.

Verifying it's actually working is simple: in Events Manager, check that reported conversions track your real order/lead count, not roughly double it, and that events show as deduplicated rather than as two separate entries.

CAPI Setup Checklist

Why This Matters More on an Agency or Rented Ad Account

A long-running, self-owned ad account has years of pixel history for Meta to lean on even when server-side data is thin. A newer or agency account doesn't have that cushion — Meta's algorithm has less to work with, so the quality of every event you send matters more, not less. Weak EMQ on a fresh account shows up as a longer, more expensive learning phase and volatile early CPAs — exactly the period where a rented cabinet's limits and billing health are most exposed.

Getting CAPI and event matching right from day one is one of the few levers a media buyer fully controls, regardless of which account is running the spend.

FAQ

Do I still need the Pixel if I set up the Conversions API? Yes. Meta recommends running both. The Pixel still contributes fbp/fbc signals that help match server events to specific ad clicks, and deduplication handles the overlap.

What's a "good" Event Match Quality score? 6.5–8 is a solid, properly configured setup; 8–10 is excellent. Below 5 usually means you're sending mostly technical identifiers (IP, user agent) without customer data like hashed email or phone.

Why are my reported conversions roughly double my real orders? Deduplication is failing — almost always a mismatched or missing event_id, or a different event_name between the Pixel and server events for the same conversion.

Does CAPI replace the need for consent/cookie compliance? No. CAPI changes how the event reaches Meta, not your legal basis for collecting it — consent and privacy requirements still apply to the underlying data.

How fast will EMQ or performance actually change after setup? In practice, EMQ typically reflects the new data within a couple of days; performance effects (CPA, ROAS) take longer to show since the algorithm needs a fresh batch of conversions to re-learn from — don't judge the setup on day one.

Conclusion

A reliable setup is straightforward: Pixel + CAPI + proper event_id configuration + high-quality event matching data + regular monitoring in Events Manager.
The higher your ad spend and the more your team relies on Meta's optimization algorithms, the more important data quality becomes. This is especially critical for new and agency ad accounts, where the algorithm has less historical data to work with. Every correctly tracked conversion helps Meta identify which traffic is actually worth scaling.

If you're looking for Facebook agency ad accounts to launch and scale your campaigns, Profit Rental can help you find the right setup for your GEOs, products, and spending volumes. Your priority is to establish accurate conversion tracking from the start, ensuring Meta receives reliable data it can use to learn and optimize campaign performance.

Message us via our Telegram bot to learn more.

Share: