Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Meta Ads › Pixel, Conversions API & Measurement

Setting Up the Meta Conversions API

What the Conversions API adds to the pixel: server-side event flow, deduplication with event IDs, event match quality, setup options, and verification.
Guideadvanced12 min readUpdated

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 deduplication 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 (CVR) 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.

RequirementWhat it means in practiceWhere it breaks
One ID per actionGenerated once when the order or lead is created, not once per requestBrowser generates its own ID and the server another
Same event namePurchase on both sides, not Purchase in the browser and a custom name on the serverPartner integration renames the event
Both copies sentThe pixel call and the server payload each carry the IDPixel tag has no event ID parameter
Sent close in timeThe server copy should not lag by daysBatch uploads sent weekly for web events
Stable across retriesA retried server send reuses the same IDRetry 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 hashed 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 Attribution 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.

RouteWhat it involvesBest forWatch for
Partner integrationEnable in Events Manager; the platform sends events from its back endHosted shop and form platforms with a maintained integrationPlatform decides event names and parameters; check deduplication with its own pixel
Conversions API GatewayA Meta-provided service, hosted on your cloud account, that receives pixel events and forwards server copiesSites without a back end team that still want redundancyHosting cost; events are mirrored from the browser, so blocked browsers are still blocked
Direct integrationYour developers call the API from the server with your own payloadsCustom platforms, CRM events, offline and app eventsDeveloper time; you own normalisation, hashing, retries and deduplication
Server-side tag managerA server container (GTM) receives client events and a Meta tag forwards themTeams already running server-side taggingServer container hosting; the client must send the identifiers the tag needs

The tag manager route makes most sense where server-side tagging 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.

Illustrative example — not a real result

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.

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.

Frequently asked questions

Can the Conversions API replace the pixel entirely?

It can be run alone, and some app-only or offline businesses do, but Meta recommends a redundant setup with both for websites. The browser event carries the click and browser identifiers that match most reliably, and the server event fills in when the browser one never arrives. Dropping the pixel usually lowers match quality rather than simplifying anything.

What happens if my event IDs do not match between browser and server?

Meta treats the two copies as different events and counts both, so purchases and leads are overstated and delivery optimises on inflated data. The event ID has to be generated once per action and passed to both the pixel call and the server payload, with the same event name on each. Events Manager shows whether deduplication is happening, which is the first thing to check after launch.

Is a partner integration good enough, or do I need a developer?

For a hosted shop platform with a maintained integration, the partner route is usually the best option: it sends the standard commerce events with customer information and handles deduplication with the platform's own pixel. A developer is needed when the events live in a custom back end, when lead quality from a CRM should be sent, or when the integration's defaults do not match how your business counts a conversion.

Terms used on this page

Tools to try

Frameworks

Where this page is used

Part of these learning paths

Also related

Sources

  1. About the Conversions API — Meta Business Help Centre
  2. Meta Business Help Centre — Meta Business Help Centre

Related