# Meta Conversions API Setup for Lead Generation

> Set up Meta's Conversions API for a lead funnel: which events to send, which identifiers make them match, how to deduplicate, and how to check they arrived.

- Canonical: https://nask.ai/meta-conversions-api-setup-for-lead-generation
- Published: 2026-10-31
- Author: Rodrigo Nask (https://rodrigonask.com/), Nask AI

---

## Key takeaways

- The Conversions API sends events from a server, the pixel from the browser. Most lead funnels run both.
- In a lead funnel, the events that matter happen after the form: the booking, the call held, the sale.
- An event without identifiers is counted but rarely matched to an ad. Email, phone and the click identifier do the matching.
- A shared event id stops the browser copy and the server copy from being counted twice.
- A setup is finished when a test shows that Meta received the event, not when the code runs.

Meta's Conversions API is a server-to-server connection that sends your funnel events to Meta directly, so a lead, booking or sale is recorded even when the browser pixel is blocked, and Meta can match it to the ad that caused it.

You run Meta ads into a lead funnel. Ads Manager reports the leads. Your calendar shows who booked. Your CRM shows who turned up to the call and who signed. Meta sees the first of those and, even then, only if the visitor's browser let the pixel fire.

That gap is what the Conversions API closes. This guide covers what a lead funnel should send, what lets Meta match each event to an ad, how to stop double counts, three ways to set it up, and how to prove Meta received the result.

## Why lead funnels need the Conversions API more than stores do

A store sells in one sitting: click, cart and payment on a page you control, all watched by the browser pixel.

A lead funnel does not work that way. The browser sees the form. The booking happens inside a calendar tool's frame. The call happens on a video link, and the deal is won in a CRM or paid through a payment tool. None of those steps loads your thank-you page, and none of them can be seen by a script in a visitor's browser.

> **Figure (animated on the web version):** A table with four funnel steps and two columns, Browser pixel and Server. Form sent: the browser lights green, the server lights green. Booking confirmed, inside a calendar frame: the browser lights red and reads Not seen, the server lights green and reads Sent. Call held, on a video link: browser red, server green. Deal won, in the CRM: browser red, server green.
>
> The browser sees the form and little else. **The server still knows** about the booking, the call and the sale.

There is a second problem: the browser is a hostile place to measure from. Visitors run blockers, close the tab before the pixel finishes, or use browsers that restrict scripts and cookies. The [HTTP cookie standard](https://datatracker.ietf.org/doc/html/rfc6265) leaves it to the user agent to decide what to keep, so a pixel that depends on a cookie sometimes does not fire.

The cost is concrete. Meta optimizes delivery for the events it receives. If it only receives the form, it learns who fills in forms, and the money events never teach it anything.

> **Figure (animated on the web version):** A ten-day track. A marker moves from left to right. On day 1 a stop reads Form sent, Browser. On day 2 a stop reads Booking, Server. On day 5 a stop reads Call held, Server. On day 10 a stop reads Client signs, Server. Only the first stop is a browser event.
>
> The form is day one. **The client is day ten**, and by then the visitor is long gone from your site.

A server sits on your side. It knows when the booking was confirmed and sends the event whether or not anyone's browser cooperates. That is the whole case for the Conversions API in a lead funnel.

## Pixel, Conversions API or both?

Both, in most setups. They see different things.

The **browser pixel** runs on your pages. It sees what a visitor does on the page, it sets the browser identifier (the `_fbp` cookie), and it can read the click identifier that Meta adds to the address when someone clicks an ad.

The **Conversions API** runs on a server. It sends events the browser never saw, and the ones the browser saw but lost. It cannot see page behavior by itself.

Sending both is safe when every event that can arrive twice carries the same event name and event id (see deduplication below). Stages that never touch a page, like a call held, need only the server copy.

If you use [Nask AI](https://nask.ai/how-it-works), the pixel half is nsk.js. It works beside the Meta pixel on your page: it gives each stage one event id and puts that same id on the browser call and on the copy Nask AI stores, so the two count as one event. The [Nask AI pixel setup guide](https://nask.ai/nask-ai-pixel-setup-guide) walks through installing it and testing each stage.

## Which events should a lead funnel send?

Send the stages that change a decision. For a service business that is usually four:

1. **Lead.** The form is sent.
2. **Schedule.** The lead books a call.
3. **CallHeld.** The call happened. A no-show is not this stage.
4. **Purchase.** The deal is won and paid.

Meta has standard event names for most of this. Nask AI uses the seven standard ones (Lead, Schedule, StartTrial, InitiateCheckout, Purchase, Subscribe and CompleteRegistration) and lets you add your own, like CallHeld, counted as one of them. The full reasoning on which stage to optimize for is in [how to track leads from Facebook ads to sales](https://nask.ai/track-leads-from-facebook-ads-to-sales). The short version: Meta learns from the event you send it, so send the one that makes money, or the earliest one that predicts it, as long as it happens often enough to learn from.

In Nask AI, open **Brands**, pick the brand, open the **Growth** tab and find the **Conversions API** section. The **Events and values** card lists the standard events, including Cancel and Refund, with four columns: **Event**, **Value**, **Predicted LTV** and **Send**. Value is the cash actually paid in that event. Predicted LTV is what you expect the customer to be worth over their lifetime. A Purchase with no value at all is stored and reported but never sent, because Meta rejects it.

Under the table, **Your own event name, counted as a standard one** takes a name like "Deal Won" and a standard event it **counts as**. Cancel and Refund rows read "Reports only, never sent to Meta": they adjust your reports and nothing else.

## The identifiers that make an event match

An event is a name and a time. Meta needs to know who it happened to, and it finds out from the customer information you attach. The more of it an event carries, the likelier Meta is to find the person who saw the ad. Meta rates this with a score called event match quality, and an event with too little information is counted but rarely matched to an ad.

> **Figure (animated on the web version):** An event card for a Schedule event with four identifier fields. Email is filled in and lights green. Phone reads not collected and stays grey. The click identifier fbc is filled in and lights green. The browser identifier fbp is filled in and lights green. A match bar beside the card rises in steps as each green field lands and stops at three quarters, labeled Likely matched to an ad.
>
> Meta finds the person through the identifiers on the event. **The more of them an event carries**, the likelier it is matched to the ad.

What a lead funnel can usually attach:

- **Email.** The form gives you one. It is the key that joins a later stage to the original lead.
- **Phone.** Any format works in Nask AI. If a number has no country code, it is completed from the brand's **Country for phones without a code** setting, which you find under **Defaults and alerts**.
- **Your own customer id.** A payment tool's customer id or a CRM contact id.
- **The click identifier, fbc.** Added to the landing page address when someone clicks an ad, then stored in a cookie. This is the strongest link to a specific ad click.
- **The browser identifier, fbp.** Set by the Meta pixel. It does not say which ad was clicked, but it helps Meta recognize the same browser.

The [lead tracking guide](https://nask.ai/track-leads-from-facebook-ads-to-sales) shows how fbc and fbp are stored. Contact details are hashed before they leave. Nask AI hashes email, phone, names and customer id with SHA-256, the algorithm defined in the [NIST secure hash standard](https://csrc.nist.gov/pubs/fips/180-4/upd1/final), and sends the click identifier and browser identifier as they are.

Meta requires every event to carry at least one of these. Nask AI keeps an event with none home, with the reason `no_identity`.

The identifiers also have to survive the trip from the form to the later stages. Nask AI matches a booking or a payment to its lead by email first, then by phone, customer id and visitor id. So whatever system records a later stage must keep the email from the form. A payment under a different email falls back on weaker identifiers, and a stage that cannot be matched is still sent, but with only the details you sent on that event, so no click identifier unless you sent one.

## Deduplication: one event, counted once

If the pixel and the server both report the same lead, Meta has to know it is the same lead. It does that by looking at two fields: the event name and the event id. When both match and the copies arrive within 48 hours of each other, Meta keeps one copy and drops the other. When the id is missing or different, Meta may count two leads.

> **Figure (animated on the web version):** Two envelopes slide toward one tray labeled Meta. The top envelope comes from the browser and the bottom one from the server. Both are stamped Lead, event id lead_8841. They land on top of each other and merge into one. The counter beside the tray reads 1 lead counted, with a note that a second copy was dropped.
>
> The browser copy and the server copy carry the same name and id. **Meta keeps one** and drops the duplicate.

Double counting is quiet: nothing errors, and lead numbers look good while Meta optimizes on events that never happened twice.

Two rules:

- **The id belongs to the event, not to the send.** Generate it once, when the event happens, and reuse that exact value on every copy.
- **For server-only stages, use an id your system will produce again.** There is no browser copy to match, so the id's job is to make a retry safe. An invoice id or a CRM deal-stage id works. Nask AI stores an `event_id` it has seen before once and sends it at most once, so a resend after a timeout comes back as `duplicate` and nothing doubles.

Nask AI also claims each event before sending it, so replays and retries never reach Meta twice. For the browser half, nsk.js hands the page's Meta call the same id it stores, or keeps the id the page already set.

## Three ways to set it up: partner, gateway or your own server

Which route fits depends on where your important events start.

**A partner integration.** Many website builders, form tools and CRMs ship a built-in connection that sends events to Meta for you. It is the least work, and its limit is the platform's own view: it sends what that platform saw.

**Meta's Conversions API Gateway.** Meta offers a hosted option you run in a cloud account, which mirrors your pixel events to the server side without you writing the server. It fits a site with a working pixel that wants server copies of the same page events. Check Meta's current documentation for what it covers.

**Your own server.** Your code or your tools send each event over HTTPS to Meta, with the pixel id and an access token, as a list of events. It is the most flexible route and the only one with full control over what data leaves, and it needs a developer or a tool that can make web requests. If you already run a tag manager, [Google's server-side tagging docs](https://developers.google.com/tag-platform/tag-manager/server-side) describe server-side tagging as a way to instrument your tags to measure user activity wherever it happens, which is one common way to build it.

| Route | Good for | Needs a developer | Sees CRM and payment stages |
|---|---|---|---|
| Partner integration | Page events from a supported platform | Rarely | Only if that platform records them |
| Meta's Conversions API Gateway | Server copies of existing pixel events | Sometimes | No, not by itself |
| Your own server, or a tool that does it for you | Every stage, from any system | Often | Yes |

For a lead funnel the last column decides: if the events you care about live in a CRM or a payment tool, you need a route that accepts them from there.

## How to set it up in Nask AI, in order

Nask AI is the third route. It receives events from any system that can make a web request, matches each one to its lead, adds what it already knows about that person, and sends the event to Meta.

1. **Install the pixel and map the stages.** Follow the [pixel setup guide](https://nask.ai/nask-ai-pixel-setup-guide) so form, booking and page stages are caught on your site.
2. **Open the section.** **Brands**, the brand, the **Growth** tab, then **Conversions API**. The **Last 30 days** card at the top reads "Nothing received yet" until the first event arrives.
3. **Create a secret.** In **Endpoint and secret**, copy the endpoint (POST), then click **Create secret**. The secret is shown once, so copy it now. Send it as `Authorization: Bearer <secret>`. **Rotate secret** replaces it, and the current one stops working at once.
4. **Send the later stages from your CRM or payment tool.** Each event needs an `event_id`, an `event_name` and `occurred_at`, plus whatever identifies the person:

```bash
curl -X POST "YOUR_ENDPOINT_URL" \
  -H "Authorization: Bearer YOUR_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"event_id":"test_deal_4471_won","event_name":"Purchase","occurred_at":"2026-10-30T14:03:00Z","email":"lead@example.com","value":1500,"currency":"USD","source":"crm","send_to_meta":false}'
```

5. **Pick the value and the Send switch.** In **Events and values**, set the Value and Predicted LTV for each stage and leave **Send** on for the ones Meta should see.
6. **Stay in dry run first.** Every brand starts on **Sending to Meta: Dry run**, where Nask AI "matches every conversion and builds the exact event it would send, and sends nothing." Send a few real stages and read the results (next section).
7. **Go live.** The workspace owner clicks **Go live**, then **Send to Meta** on the confirmation, which says new matched conversions will be sent to the brand's Meta pixel. **Going live sends new conversions only**, so nothing from the dry run is replayed. On Live, matched conversions go to Meta "within a minute of arriving, each one once."

The example above sets `send_to_meta` to false, which stores the event and shows it in reports without sending it. The `test_` prefix on the `event_id` only marks it as a test. Set `occurred_at` to when the event happened, not when you sent it, with a time zone. Make and Zapier both have a web request step for a CRM with no native connection. See [sending CRM stages back to Meta](https://nask.ai/send-crm-stages-back-to-meta).

The **Defaults and alerts** card holds the default country and currency, and **Email the owner if silent for (hours)**, 72 by default, so a source that stops sending gets noticed.

## How do you check Meta received the event?

A script that runs without an error proves nothing. Nask AI gives you three places to look, in the order an event travels.

> **Figure (animated on the web version):** A transcript of five lines. Sending to Meta: Dry run. A Schedule event, Match: Matched, Test mode, not sent to Meta. Go live, then Send to Meta. Sending to Meta: Live. Then a Schedule event, Match: Matched, Received by Meta (1), highlighted in green with a check mark. Only the last line counts as proof.
>
> A dry run shows what would be sent. **Only Received by Meta, with a count**, shows that it was.

**The Last 30 days card.** It counts Received (events stored), Matched (tied to a lead of this brand, or a lead itself), Held (more than one person fits, or the match is weak), No lead (no lead of this brand fits), and Would send on a dry run or Sent on live. A high Held count usually means your later stages lack the email from the form. The last tile reads Not sent for events that are reports only, switched off, too old, or have nothing to identify the person. It turns into Failed, in red, when Meta refused events, and the workspace owner is emailed.

**The Meta line in a stage test.** In the pixel test panel each caught event shows "Received by Meta" with a count, or "Refused by Meta". On a dry run it reads "Test mode, not sent to Meta". Nask AI shows a count only when Meta's own reply counted the events, and says "Sent, Meta did not confirm" when it did not. The panel keeps reading these statuses for 10 minutes because they land after the event.

**The connection check.** Under the brand's Meta pixel, the **Conversions API** row has a **Verify** button. When it passes, the row reads "Connected, verified" followed by the time. Read the note under it: it "confirms events reach Meta" but "cannot confirm Meta counts them."

Meta also has a test events tab in its events tool, where an event sent with a test code shows up on Meta's side.

## When the Conversions API will not fix your numbers

The API fixes missing and unmatched events. It does not fix everything.

- **Events that are too old.** Nask AI stores but does not send events past the limit. Events posted through the ingest API get under 7 days, or under 62 days when they carry "action_source": "offline" (accepted by the endpoint, though the API reference does not list it yet). Nask AI's pixel funnel settings say "Attio changes arrive as offline stages, accepted up to 62 days after the click." The 62 days count from when the stage happened, not from the click. See [offline conversions for booked calls](https://nask.ai/facebook-offline-conversions-for-booked-calls).
- **A restricted category.** Some categories, such as health and wellness, restrict how Meta uses your events, and no connection check can report that. A passing Verify with missing conversions is the sign. Check your category in Meta's events tool.
- **Counts that differ.** Meta counts a lead when its event fires and applies its own attribution. A CRM counts a record when it is created. Decide which is the truth, usually the CRM.
- **Weak identifiers.** An event with no email, phone or click identifier is rarely matched. If the form never asked for an email, no setup can add one.
- **Consent.** Identifiers are personal data. The [EU's data protection rules](https://commission.europa.eu/law/law-topic/data-protection_en) apply when your visitors are in the EU, and the [California privacy law](https://oag.ca.gov/privacy/ccpa) applies to many businesses with California customers. Say in your privacy notice what you collect and where it goes, and ask for consent where the law requires it. Going server-side does not remove that duty.

Nask AI holds the whole path in one place: the pixel on your pages, the funnel stages, the endpoint for your CRM and payments, the dry run, and the live send to Meta. Book a demo and watch your first stage reach Meta.

- [Book a demo](https://cal.com/rodrigo.nask/60min)

## Frequently Asked Questions

### Do I still need the Meta pixel if I use the Conversions API?

Usually yes. The browser pixel sees on-page behavior and sets the browser identifier, and the server sends events the browser misses, such as a booking confirmed later or a sale recorded in your CRM. Send the same event name and event id from both, and Meta keeps one copy instead of counting the event twice.

### What is event match quality?

It is Meta's rating of how well the identifiers on your events let it find the person who saw the ad. An email, a phone number, the click identifier from the ad link and the browser identifier all raise it. An event with none of them is counted but rarely matched, so it does little for optimization.

### Can I send offline events like a closed deal?

Yes. A server event can describe something that happened anywhere, as long as it carries identifiers from the original lead and is recent enough. Web events must be under 7 days old. In Nask AI, events posted through the ingest API get under 7 days, or under 62 days when action_source is set to offline. Closed deals and held calls are the usual examples.

### How do I avoid counting a lead twice?

Give the browser event and the server event the same event name and the same event id. Meta keeps one copy and drops the other when both arrive within 48 hours of each other. Without a shared id Meta may count two, inflating lead counts so it optimizes on numbers that are not real, a common setup error in lead funnels.

### Do I need a developer to set this up?

Not always. Partner integrations and Meta's Conversions API Gateway avoid code for common platforms, and a tool that runs its own pixel sends server events for you. In Nask AI, a no-code tool such as Make or Zapier can post events from your CRM. You need a developer when events come from a custom backend or when you want to control exactly which data leaves your systems.
