What the Conversions API is and why it exists
Meta documents the Conversions API as a tool that creates a direct connection between your marketing data, held on your server, website platform or CRM, and Meta's systems, so that ad delivery can be optimised, costs reduced and results measured. The contrast is with the pixel, which depends on code executing in the visitor's browser and on that browser being willing to store identifiers and send requests. Every year a larger share of visits fails one of those conditions: content blockers, private browsing, consent refusals, browsers that shorten cookie lifetimes, and operating systems that limit tracking at the device level.
The server does not have those problems. It knows when an order was placed, by whom, for how much, and it can tell Meta without asking a browser's permission to run a script. The Conversions API is the channel for that message. It also opens a door the pixel never could: events that happen nowhere near a web page. A lead qualified by a sales team, a subscription renewed by a billing system, a purchase in a shop, a cancelled order that should be removed from the count. All of these can be sent as events with the appropriate action source, and delivery can learn from them. Which of those events an ad set should optimise for, and what value each should carry, is best decided once for every platform, as the guide to conversion events and values across ad platforms explains.
Meta's recommendation is a redundant setup: pixel and Conversions API together, sending the same web events, with deduplicationRemoving double counts when one conversion is reported by more than one source. so that each action is counted once. The pixel contributes browser identifiers that match well; the server contributes reliability and data the browser does not have. The measurement hub places both in the wider stack with Events Manager and attribution settings.
Browser and server events together: the flow
Think of one purchase. The visitor completes checkout. In the browser, the pixel fires a purchase event with value, currency, the contents and an event ID generated for this order. At the same moment, or shortly afterwards, the server that processed the order sends a purchase event to Meta's endpoint with the same event name and the same event ID, plus customer information from the order record, the time the event happened, the page URL and an action source of website.
Meta receives two copies. Because the names and IDs match, it keeps one and discards the other, retaining the richest set of identifiers across both. The surviving event is then matched to a person, attributed to an ad interaction under the account's attribution setting, counted in reporting and fed to delivery. Which copy survives does not matter to you; what matters is that exactly one does.
Now imagine the browser copy never arrives, because a blocker stopped the script. The server copy still reaches Meta, is matched using the customer information it carries, and the purchase is counted. Without the API that purchase would simply be missing, and so would its lesson for delivery: that this person, in this placement, from this ad, bought. Conversion rate (CVRShare of visits or clicks that convert.) as Meta sees it rises not because more people bought but because more of the people who bought are seen. The conversion rate calculator is a quick way to compare the rate Meta reports before and after launch against the rate the shop's own records imply.
The flow is the same for leads, registrations and any other standard event. The difference for events that never had a browser copy, such as an offline sale or a CRM stage change, is that there is nothing to deduplicate against; they are simply sent once with the correct action source. Meta documents the required fields for each: event name, event time, action source, and customer information sufficient to match.
Deduplication with event IDs
Deduplication is the part most integrations get wrong, and the consequences are expensive: a doubled purchase count flatters every report and teaches delivery that conversions are easier than they are. Meta documents event ID and event name as the primary deduplication keys. The rule is that when a browser event and a server event share both, received within Meta's deduplication window, they are treated as one. Meta also documents an alternative key based on the browser identifier combined with an external identifier, but the event ID route is the one to design around.
| Requirement | What it means in practice | Where it breaks |
|---|---|---|
| One ID per action | Generated once when the order or lead is created, not once per request | Browser generates its own ID and the server another |
| Same event name | Purchase on both sides, not Purchase in the browser and a custom name on the server | Partner integration renames the event |
| Both copies sent | The pixel call and the server payload each carry the ID | Pixel tag has no event ID parameter |
| Sent close in time | The server copy should not lag by days | Batch uploads sent weekly for web events |
| Stable across retries | A retried server send reuses the same ID | Retry logic creates a fresh ID each attempt |
The cleanest implementation stores the ID in the thing that represents the action: the order number, the lead record identifier, the subscription ID. Then the browser reads it from the data layer on the confirmation page, and the server reads it from the same record. For the pixel side, the pixel setup tutorial adds an event ID variable to every event tag for exactly this reason.
Events Manager shows whether deduplication is happening. The overview for a dataset lists events by connection method, and the detail for an event reports what share of browser and server copies were deduplicated. A share near zero after launch means the IDs or names do not match; a share that drops after a site release means something changed on one side only.
Event match quality and customer information parameters
A server event has no browser to identify the person, so it must carry identifiers of its own. Meta calls these customer information parameters. The documented set includes email address, phone number, first and last name, city, region, postcode, country, date of birth, gender, an external identifier of your own, the client IP address, the client user agent, and the two browser identifiers the pixel sets, usually called fbp and fbc. Personal fields such as email and phone are hashedConverting an identifier such as an email address into a fixed string with a one-way function, so platforms can match records without the raw value. before sending, normalised according to Meta's rules, with the standard hashing function Meta specifies; the IP address, user agent and browser identifiers are sent as they are.
Events Manager rates each event with an event match quality score. The score reflects how many and which parameters arrive and how well they match Meta accounts; a higher score means more events are attributed and more useful signal reaches delivery. The score is a diagnostic, not a target in itself, but a low one tells you which parameters are missing. In practice the biggest single improvement is usually sending the browser identifiers with web events, since they tie the server event to the same session the pixel saw, followed by a correctly normalised email address.
Three practical notes. First, normalisation is strict: an email address with capitals or trailing spaces hashes to a different value and matches nothing, so apply Meta's documented rules before hashing. Second, send only what you lawfully hold and have a basis to share; more parameters raise the score, but each is personal data. Third, the parameters available differ by action source. A website purchase can carry browser identifiers; a CRM lead cannot, and must rely on hashed contact details instead. The AttributionAssigning conversion credit to touchpoints. step that follows matching can only credit an ad for events that were matched to a person who saw or clicked it.
Setup options
Meta documents several routes to the same endpoint, from no-code to full developer control.
| Route | What it involves | Best for | Watch for |
|---|---|---|---|
| Partner integration | Enable in Events Manager; the platform sends events from its back end | Hosted shop and form platforms with a maintained integration | Platform decides event names and parameters; check deduplication with its own pixel |
| Conversions API Gateway | A Meta-provided service, hosted on your cloud account, that receives pixel events and forwards server copies | Sites without a back end team that still want redundancy | Hosting cost; events are mirrored from the browser, so blocked browsers are still blocked |
| Direct integration | Your developers call the API from the server with your own payloads | Custom platforms, CRM events, offline and app events | Developer time; you own normalisation, hashing, retries and deduplication |
| Server-side tag manager | A server container (GTMTag management system.) receives client events and a Meta tag forwards them | Teams already running server-side tagging | Server container hosting; the client must send the identifiers the tag needs |
The tag manager route makes most sense where server-side taggingRunning tags on a server the business controls instead of in the visitor's browser. is already in place, since the Meta tag is then one more destination for an event stream the server receives anyway. When that route is chosen, the server-side tagging go-live checklist covers deduplication against the pixel and event match quality as part of the cutover.
The Gateway deserves a note. It is attractive because it needs no code, but because it re-sends events the browser already reported, it does not recover events from browsers where the script never ran. It improves reliability for events that did fire and simplifies the dual setup; it does not see what the browser cannot. A direct or platform integration reads the server's own record of the order and so does.
For lead-generation businesses the direct route is often the only one that reaches the events that matter. The form submission is a pixel event, but the qualified lead or the signed contract lives in a CRM, and sending that stage change as a server event, keyed to the hashed email captured at submission, is what lets delivery learn which clicks became customers. The comparable mechanism on another platform is described in the enhanced conversions guide; the ideas are alike even though the plumbing differs.
A specialist insurer sends qualified leads from its CRM
A specialist insurer runs lead campaigns to a quote form. The pixel recorded about 1,900 form submissions a month, but the sales team qualified roughly 540 of those and wrote around 160 policies. Campaigns optimised on submissions had drifted towards cheap, poorly qualified traffic. The developer built a direct integration: the form stores the hashed email, phone and a lead ID; when a lead is marked qualified in the CRM, the server sends a custom qualified-lead event with those identifiers, and when a policy is written it sends a purchase event with the premium as value. Event match quality for the CRM events settled around 6 out of 10, lower than the web events because no browser identifiers were available. After eight weeks with the qualified-lead event as the optimisation goal, submissions fell to about 1,400 a month while qualified leads rose to roughly 610, and cost per policy written fell by about a quarter. Reported submissions looked worse; the business did better.
Verifying in Events Manager
Launch is not the end. Verification has four parts, all in Events Manager. The test events view accepts a test event code that you include in server payloads during development; events carrying it appear in the view without entering reporting, so you can inspect names, parameters and timing before going live. The overview for the dataset lists each event with its connection methods, browser and server, and the counts received by each; a server event with no browser counterpart, or the reverse, is immediately visible. The event detail shows the deduplication share and the event match quality score with the parameters contributing to it. The diagnostics tab flags problems Meta detects: missing required parameters, badly formatted values, events received too long after they happened, and deduplication failures.
Beyond the interface, compare counts. Server purchase events over a week should be close to the shop's order count for the same week, before attribution is applied; a large gap means events are missing or doubled. Then compare attributed results in Ads Manager before and after the launch date, remembering that more matched conversions will raise reported performance without any change in the campaigns. Note the launch date in change history so that later analysis does not mistake a measurement improvement for a creative win.
Privacy, consent and data minimisation
Moving events from browser to server changes where the consent decision is enforced. In the browser, a tag that does not fire is a visible fact; on the server, nothing stops the integration sending every order unless you build the stop yourself. The consent choice recorded by the banner has to travel with the session into the order record and be respected by the server code: a visitor who declined gets no server event, exactly as they got no pixel event. Meta documents data processing options that limit how it uses data from certain jurisdictions, which are sent as parameters on the event and also need to be set on the server side.
Data minimisation follows the same logic. Send the parameters that improve matching for your action source and nothing more. Store hashes rather than raw values where the raw values are not needed for anything else. Keep the integration's logs free of personal data. And document the flow in the privacy notice: which events, which parameters, which recipient. Meta's business tools terms govern what you may send and what Meta does with it; the lawful basis under local law is your responsibility. The author's conversion tracking expertise page describes how these decisions are made alongside the technical ones.
When purchases appear twice after launch, the troubleshooting page for duplicate Conversions API events shows how to read the deduplication evidence and trace it to the ID, name, timing or sender at fault.
When browser events arrive but the server column stays empty or falls silent after a change, the diagnosis for Conversions API events that are not showing follows each route to the point where the events disappear.
When the match quality rating stays poor on an optimised event, the low event match quality diagnosis separates missing and malformed parameters from limits that consent rightly imposes.
For service businesses capturing enquiries on their own site, the Meta Ads lead generation setup shows where server-sent lead events sit beside instant forms and CRM feedback.
For a side-by-side view of what the pixel and the server each contribute to one dataset, the comparison of the Meta Pixel and the Conversions API sets out when either source is enough on its own.
Common mistakes
- Launching without checking deduplication. A doubled purchase count for a month, then a target reset when it is fixed.
- Different event names on each side. Purchase in the browser, order on the server; two events, no match.
- Hashing without normalising. Capitalised emails and spaced phone numbers that match nobody.
- Treating the Gateway as full coverage. It mirrors what the browser sent; it cannot report what the browser never saw.
- Sending every lead as a conversion. The server can send the qualified stage; optimising on raw submissions wastes the API's main advantage.
- Forgetting the consent flag on the server. The banner stops the pixel, but nothing stops the server integration unless the recorded choice travels with the order and the code honours it.
- Ignoring the attribution setting. More matched events change what is counted; the attribution settings guide explains how to read the result without fooling yourself.
