Facebook Conversions API: What It Is and How It Works

If you’ve come across the acronym CAPI in a Meta Ads conversation and weren’t sure what it actually solves, this guide is for you. The Facebook Conversions API is how conversion events reach Meta from a server instead of a browser. And if your funnel runs through Telegram, it deserves your full attention: here, CAPI isn’t an optional advanced feature. It’s the only way to track real conversions all the way through.

What is the Facebook Conversions API (CAPI)?

The Conversions API (officially Meta’s Conversions API, still widely called the Facebook Conversions API) lets you send conversion events to Meta Ads directly from a server, without relying on a script running in the browser of the person who converted. It exists largely in response to a problem that has grown over the past few years: ad blockers, browser and device-level tracking restrictions (like Safari’s Intelligent Tracking Prevention and Apple’s App Tracking Transparency) and ever-tighter privacy rules have made client-side tracking through the Pixel alone less reliable. Meta started strongly encouraging advertisers to combine the Pixel with CAPI precisely to make up for that lost client-side signal with a more resilient channel, one that doesn’t depend on what happens (or fails to happen) in the user’s browser.

In plain terms: the Pixel counts what it can observe from inside the browser; CAPI counts what your own system knows happened, regardless of what the browser reported (or failed to report).

CAPI vs. Pixel: what changes

The Pixel runs in the browser of whoever visits your page. It’s JavaScript that fires an event (PageView, Lead, Purchase) the moment something happens on screen. CAPI does the same thing conceptually (it tells Meta a conversion event happened), but through an authenticated HTTP call made by a server, never touching the browser.

In most web funnels, the recommendation is to run both at once: the Pixel captures what it can in the browser, CAPI reinforces it with the same event (or with events the browser missed), and Meta deduplicates the two when they arrive with the same event_name and the same event_id, so each one covers the other’s gaps. In a Telegram funnel with Track4you the recommendation is different: the script already covers the page events, so you don’t install a separate Pixel (more on that at the end of this article).

CAPI in different funnel contexts

It’s worth placing CAPI in each type of funnel, because how “mandatory” it is changes a lot:

• Regular website or e-commerce store: the Pixel works, with variable signal loss (ad blockers, stricter browsers). CAPI complements it, recovering what the Pixel misses.
• Mobile app: tracking tends to rely more on mobile measurement SDKs, but the principle of complementing client-side signal with server-side signal still applies.
• Telegram: there’s no browser or app SDK running while the person interacts inside the channel. CAPI stops being a complement and becomes the only possible signal path for the join, exit and deposit events.

Why CAPI isn’t optional on Telegram

This is the difference that matters if you run traffic to Telegram. On a regular website, even when the Pixel loses signal to tracking blockers, there’s still a page running, a browser, a DOM. On Telegram, once the person leaves your site (or your bridge page) and opens the Telegram app, there’s no browser following what happens. The channel join only exists inside Telegram’s own API, observable by a bot.

That means there’s no “Pixel reinforced by CAPI” for this specific event. CAPI is the only way that data reaches Meta. See the Facebook Pixel for Telegram guide for the full technical flow in this case.

How it works technically

A CAPI event call carries, at minimum: the event name (Lead, Purchase or a custom event), the moment it actually happened (not the moment it was sent), the event source (where it was generated: browser, system, chat), a deduplication identifier (event_id), the user data available (personal identifiers such as email and phone hashed with SHA-256; IP address, user agent and the fbp/fbc cookies sent unhashed) and extra value data when relevant (like the amount of a deposit).

In simplified form, a typical call carries something like this (illustrative values):

event_name: "Lead"
event_time: 1752480000
action_source: "system_generated"
event_id: "abc123"
user_data: { em: "hashed_email", client_ip_address: "..." }
custom_data: { value: 50, currency: "USD" }

Each implementation (a homegrown bot, a dedicated tool) builds this structure a little differently under the hood, but the conceptual fields are always these. The Facebook Pixel for Telegram guide walks through them step by step, applied to the specific case of a channel join.

Why personal identifiers must be hashed

When the call includes an email, phone number or another personal identifier (name, external ID), Meta requires it to be processed with SHA-256, a function that turns the original value into an irreversible string of characters. That lets Meta compare the hash it receives with hashes it already has (from user accounts, for example) without the personal data itself traveling or being stored in plain text at any point. Technical session data (IP address, user agent and the fbp/fbc cookies) falls outside that rule and goes unhashed.

Deduplication and Event Match Quality, explained

Deduplication is the mechanism that stops Meta from counting the same event twice when it arrives through both the Pixel and CAPI. Both need to arrive with the same event_name and the same event_id for Meta to understand they’re one conversion seen through two paths. The Pixel and CAPI deduplication guide covers how to set it up and test it.

Event Match Quality (EMQ) is the score Meta gives to how well it can match an event to a specific person and ad, based on how many user_data fields the call includes (email, phone, IP, Pixel cookies). The more complete the data you send, the higher EMQ tends to be, and events with low EMQ tend to contribute less to campaign optimization, even when they’re technically “correct.”

You’ll find the score in each event’s details, on the pixel’s Overview in Events Manager (not on the Test Events tab). It’s worth checking periodically instead of setting it once and forgetting it: changes to your page, your bot or the way data is collected can quietly drag EMQ down over time, with no visible error, just a gradual decline in optimization quality. If yours is low, see how to improve Event Match Quality.

Common mistakes when you’re new to CAPI

• Treating CAPI as a Pixel “upgrade”: where there’s no browser (like Telegram), CAPI doesn’t improve anything. It’s the only path.
• Hashing the wrong fields: personal identifiers (email, phone, name, external ID) must be SHA-256 hashed; sending them in plain text is an implementation error. The reverse happens too: IP, user agent and the fbp/fbc cookies go unhashed, and Meta can’t use them if they’re hashed.
• Testing only in production: Meta’s Events Manager has a Test Events tab built specifically to validate CAPI calls before you run a real campaign with them.
• Getting event_time wrong: the timestamp should reflect when the event actually happened, not when the API call was processed.
• Forgetting the shared event_id (with the same event_name): without it, the Pixel and CAPI report one event as two, artificially inflating campaign results.
• Sending too few user_data fields: a technically valid call with very little user data still tends to get low EMQ. Send every field you have, not just the minimum needed to avoid rejection.

Where Track4you fits in

For Telegram specifically, Track4you builds and fires these calls for you, so you don’t have to implement the technical integration described above from scratch. You register your pixel (ID + Conversions API token), run the test event and create the funnel. From then on, each step reaches the pixel as an event: ViewContent on the page visit, Lead on the button click, enter_channel on the channel join (the main conversion) and left_channel on exit. Along with the events, Track4you sends the IP address, user agent and fbp/fbc cookies (when available): the matching data that feeds Event Match Quality, with no user_data fields for you to build.

Because the script already sends ViewContent and Lead to the funnel’s pixel, Track4you recommends not installing your own Pixel on the funnel pages. If it’s already there, Meta deduplicates automatically; it just isn’t needed.

Registrations, FTDs and deposits, which happen on the platform rather than in the channel, come in through Integrations (Pro and Enterprise plans), via an S2S postback from the platform: registrations as CompleteRegistration, the FTD as the custom event FTD and deposits as Purchase. Every conversion that arrives by postback is sent to the pixel, with no time limit on Track4you’s side, and becomes signal for the algorithm. Whether it’s credited to a campaign in Ads Manager depends on Meta’s attribution window (by default, 7 days after the click and 1 day after the view). Plans and terms are at track4you.app.

Frequently asked questions

Related terms (postback, deduplication, Event Match Quality) also appear in the glossary.

Conclusion

CAPI isn’t an advanced feature for people who “already have the basics down.” It’s the piece that closes tracking in any context where the browser isn’t in the middle of the path, and on Telegram that’s always the case. Understanding the difference between the Pixel and CAPI, why one doesn’t replace the other in every context, and what actually makes up a well-built event call (name, time, source, deduplication, user data with personal identifiers hashed) is the first step toward any serious tracking setup on this channel, whether you’ll implement it by hand or just want to understand what a dedicated tool is doing behind the dashboard.