The Facebook Conversions API is a server-to-server connection that sends conversion events from your backend, app or CRM to Meta. The Meta Pixel fires those events inside the visitor’s browser, where an ad blocker, a failed script load or Safari’s cookie limits can lose them. The Conversions API sends them from infrastructure you control. When the event starts on your backend, such as a payment webhook, it doesn’t depend on the browser at all. When it starts in the browser and is relayed through your server, it is less exposed but not immune.

Meta and Facebook are the same ad platform, and the Conversions API, the Meta Conversions API and the Facebook Conversions API are three names for the same thing. Advertisers still search for both.

I deploy tracking implementations for clients, and I built Advanced Tracking Academy around the containers I use in production. This page is the fundamentals: what a request contains, how Meta matches and deduplicates it, the ways to set it up, and where it stops helping. The server container setup lives in the Meta Conversions API with GTM guide.

Why the Conversions API exists

Several forces made the browser a weaker place to measure conversions. Ad blockers and page-load errors stop Pixel requests from firing. Safari deletes script-set cookies such as _fbp after seven days without user interaction with the site, and caps them at 24 hours when the visitor arrived through a decorated link from a site WebKit classifies as a tracker (WebKit tracking prevention, checked 2026-10-17). Apple’s App Tracking Transparency, introduced in 2021, cut the signals flowing through apps.

Consent is a different category. When a visitor declines tracking, both the Pixel and the Conversions API have to honor that choice. It is not a gap the server is meant to fill. A server channel helps with blockers, loading failures and cookie caps, not with a visitor who said no.

The server-side tracking guide covers the wider data-decay problem, and the first-party versus third-party cookies guide covers how each browser treats cookies.

Flow diagram: a purchase sends one event through the Conversions API from your server, and one through the browser pixel that often never arrives.
Both paths describe the same purchase. Only one of them depends on the visitor's browser cooperating.

What a Conversions API request contains

Your server makes an HTTPS POST to https://graph.facebook.com/<api_version>/<pixel_id>/events, authenticated with an access token. Meta’s Using the API documentation shows the Pixel ID in the path, even though Events Manager may group sources under a dataset. A system-user token suits an unattended production service, because it isn’t tied to a person’s login. The FAQ below covers the narrower token Events Manager generates.

Each event object carries three groups of fields.

  • Event data covers event_name (Purchase, Lead, AddToCart and the rest of the standard set) and event_time, a Unix timestamp in seconds for when the event actually happened. Meta’s server event reference says event_time can be up to 7 days before you send it, and if any event in a request is older, Meta rejects the whole request (checked 2026-10-17). action_source declares where the event happened, with values such as website, app, physical_store, system_generated, email, phone_call, chat and other. event_source_url is required for website events. event_id is optional at the API level, but Meta recommends it for deduplication.
  • User data is the customer information Meta uses to match the event to a person. For action_source set to website, client_user_agent is also required (customer information parameters, checked 2026-10-17). Send the visitor’s original browser user agent, never the one belonging to the webhook sender or your own HTTP client.
  • Custom data describes the conversion: value, currency, contents, content_type and order_id.

Here is the shape of a website Purchase. The values are synthetic, written for this page, not copied from a client:

{
  "data": [{
    "event_name": "Purchase",
    "event_time": 1792159500,
    "event_id": "order_8472",
    "action_source": "website",
    "event_source_url": "https://shop.example.com/checkout/thank-you",
    "user_data": {
      "em": ["<SHA-256 of the trimmed, lowercased email>"],
      "client_ip_address": "203.0.113.24",
      "client_user_agent": "<the visitor's browser user agent>",
      "fbp": "fb.1.1792158000000.1234567890",
      "fbc": "fb.1.1792158000000.<fbclid exactly as received>"
    },
    "custom_data": { "currency": "USD", "value": 49.00, "order_id": "8472" }
  }]
}

A valid payload gets a 2xx response, and Meta’s documentation says the response carries minimal data. On a test send from one of our own sites on 2026-10-05, the reply was HTTP 200 with events_received: 1. That proves receipt, not that the event matched a person or counted once.

You can build that request three ways: write it yourself against the Graph API, route it through a Google Tag Manager server container, or use a partner integration such as Meta’s Conversions API Gateway. Meta doesn’t care which path sends the event, only that the payload is well formed and authenticated.

How Meta matches your events to people

For web events, Meta shows an Event Match Quality score out of 10 per event in Events Manager (best practices, checked 2026-10-17). Treat it as a setup diagnostic. It doesn’t confirm that a purchase was real, prove that Pixel and server events were deduplicated, or predict campaign results. The Event Match Quality score guide explains why coverage differs by event and when the dashboard recommendation is noise.

The score depends on the user data you send. The common customer information parameters for website events:

Parameter Meaning Hashing treatment
em Email SHA-256 required
ph Phone SHA-256 required
fn, ln First and last name SHA-256 required
ge Gender SHA-256 required
db Date of birth SHA-256 required
ct, st, zp City, state, zip SHA-256 required
country Country SHA-256 required
external_id Your own customer ID SHA-256 recommended
fb_login_id Facebook Login ID No
subscription_id Subscription ID No
fbc Click ID from the ad No
fbp Browser cookie ID No
client_ip_address, client_user_agent Network and device No; the user agent is required for website events

The personal fields are normalized and SHA-256 hashed on your server before they leave. Meta hashes the same way and compares. Hashing is pseudonymization, not anonymization: a hashed email is still tied to a person, and consent and data-protection obligations still apply. The click ID, browser ID, Login ID, subscription ID, IP address and user agent travel unhashed over the same HTTPS connection. Document that when you map the data flow.

Two things follow. The match-quality ceiling is set at collection: if your checkout never asks for a phone number, no configuration can produce a ph value. And extra parameters only help when they belong to the same customer and follow Meta’s current formatting rules. Accurate coverage beats a long payload.

If the purchase happens on another domain, the hosted checkout click ID index explains how to keep those browser identifiers until the paid webhook can send them.

Pixel and Conversions API work as a pair

The Pixel and the Conversions API are two delivery paths for the same measurement system. The Pixel sees browser context directly: the page, the referrer, the Meta browser identifiers. The Conversions API can use data held by your checkout, backend or CRM. Meta recommends sending both and deduplicating them.

Its deduplication documentation sets two conditions: the Pixel’s eventID must match the server’s event_id, and the event names must match. There is also a time condition. Meta only pairs the two copies when both arrive within 48 hours of the first event with that ID, so a delayed webhook or a late replay counts as a second event. Send the server event promptly and keep the original event_id on any retry. This is separate from the 7-day limit on event_time. The order-ID deduplication guide covers the Purchase case in detail.

Meta Pixel (browser) Conversions API (server)
Sees the page and referrer Yes Only what you forward
Hashed identifiers it can pass Yes, via Advanced Matching, when the page has them Yes, from server and checkout data, more consistently
Exposure to ad blockers Often blocked Less exposed, depending on event origin
Reliance on browser cookies capped by Safari Heavy Lighter, depending on event origin
Acts as one path of a deduplicated event Yes Yes

The qualifier “depending on event origin” matters. A first-party server endpoint keeps real advantages when the event starts in the browser: it is less exposed to common blocklists, and it lets you normalize the event on the server. But the browser can still drop the request before it reaches your server. Backend events, such as a confirmed payment webhook or a CRM status change, are the independent source.

Ways to set up the Conversions API

Meta’s get-started page says there are “several methods for integrating with the Conversions API, and they vary by level of effort, cost, and the features they enable” (Meta for Developers, checked 2026-10-25). The table compares four common approaches; server-side GTM is one way to build a direct integration.

Route What it needs What it can send Where to start
One-click setup in Events Manager A Meta Pixel on your site Website events Meta’s Events Manager
Conversions API Gateway Your own AWS or Google Cloud account The website events your Pixel sees, from a server you host The Gateway setup guide
Server-side GTM A server container and hosting such as Stape Browser events relayed through your server, plus events you forward from your backend The Meta Conversions API with GTM guide
Direct integration Code on your server and an access token Any event your backend records, such as a confirmed payment Meta’s developer docs and the Stripe walkthrough

Meta describes the one-click option as setting up the Conversions API “for website events in one click from Meta Events Manager, with no code, configuration, or setup fees” (Conversions API overview, checked 2026-10-25). The Gateway is “a self-serve configuration option in Events Manager” that you host on AWS or Google Cloud. A direct integration is, in Meta’s words, “a connection between an advertiser’s server and Meta’s Conversions API endpoint”; a server GTM container is one way to build it without writing the request code yourself.

The first two approaches start from your Pixel, so they cover website events. To report confirmed payments or CRM status changes without depending on a browser event, use an integration that receives those outcomes from your backend. ATA Edge receives payment webhooks from Stripe one-time payments, Hotmart and 26 more checkouts in your own Cloudflare account, and sends a Purchase to Meta for sales matched to a tracked ad visit.

What the Conversions API cannot recover

Its limits start before the request is sent. It cannot create consent, invent identifiers the customer never supplied, or decide whether a reported purchase settled. Those are separate problems with separate controls: a consent platform records the visitor’s choice, checkout and CRM systems hold customer data, and a payment webhook confirms the transaction.

Consent and opt-out still apply. Under regimes such as GDPR and ePrivacy in the EU or CCPA in California, whether an event can be sent depends on your legal basis, the data involved and the signals your consent platform recorded. The server has to honor those signals the same way the browser does. The specific obligations belong to whoever owns your privacy compliance.

The API ships whatever event you hand it. If your Purchase fires when someone lands on the thank-you page, a page refresh, a bot crawling the URL and a payment that failed after the redirect all become purchases. The reliable fix is to make the payment system the source of truth: a confirmed charge sends a webhook to your server, the server matches it to the stored attribution, and only then fires the event. The Stripe walkthrough shows the webhook-validated flow end to end.

A server-routed event can still vanish before your server. If your only Conversions API path depends on a browser event reaching your tagging server, the browser can drop it on the way. A purchase that starts on your backend does not have that weakness.

What the Conversions API costs

Meta charges no fee to receive Conversions API events. You pay for the infrastructure and the work to build, test and maintain the flow.

Managed server-side GTM hosting is billed monthly by request volume. Stape, for example, lists a free tier up to 10,000 requests a month and Pro at $20 a month, or $17 billed annually, for up to 500,000 requests (Stape pricing, checked 2026-10-17). Self-hosting on Google Cloud is cheap in a one-instance test, but Google’s Cloud Run setup guide recommends a minimum of 2 instances to reduce the risk of data loss, at roughly $45 a month each for its reference configuration of 1 vCPU, 0.5 GB and CPU always allocated (checked 2026-10-17). Budget about $90 a month for that production setup, not the test price.

Setup time is usually the larger variable. A custom build with deduplication and webhook validation depends on the data layer, the payment platform and how quickly you get account access.

For the container build, the Meta Conversions API with GTM guide covers the server setup and its test steps. For the managed route, the Conversions API Gateway setup guide covers its Pixel prerequisite, domain, tests, cost and limits, and the Gateway versus server-side GTM comparison lays out the trade-offs.

If you are adding OpenAI as a second destination, the field map does not carry over unchanged. OpenAI’s Conversions API accepts hashed phone numbers in phone_numbers_sha256 but no raw contact fields, and its timestamps must fall within the last 7 days (checked 2026-10-17). The ChatGPT Ads conversion tracking guide covers that API.

If you would rather deploy than build, ATA Edge runs the webhook-validated flow from your own Cloudflare account: it records every approved sale in your panel and sends a Purchase to Meta’s Conversions API for the sales it matches to an ad visit.

For a separate LinkedIn implementation, the LinkedIn Conversions API guide covers its rule URN, shared event IDs and browser-copy precedence. Meta payload fields do not transfer unchanged.