Technical Deep-Dive · 14 min read

Server-Side Conversion API Setup: Meta CAPI + TikTok Events API in One Hour

Meta's Conversions API and TikTok's Events API recover signal that iOS link stripping, Safari ITP and ad blockers suppress in the browser. This playbook walks the one-hour setup in Admaxxer (forwarding to Google Ads is not available yet): connect your ad accounts, pick your Pixel, send a test event, verify deduplication by event_id, then run a daily parity check by hand.

~60 min
Setup time
Meta, TikTok and Klaviyo
Purchase
Server-side event
Other events come from your browser pixel
Order ID
Dedup key
Sent as event_id

The dual-feed concept — pixel and CAPI firing the same conversion

A modern DTC conversion fires twice. First, the pixel posts the event from the browser when the thank-you page loads — Meta's edge gets a cookie-rich, fingerprinted, browser-native signal. Second, the server posts the same event to Meta's Graph API endpoint from your backend — Meta's edge gets a signal that survives ad blockers, iOS link-tracking protection, and Safari intelligent tracking prevention.

Both feeds are valuable, and together they form a redundant pair. The pixel fires with high trust (Meta likes the browser fingerprint) but loses 15–25% of conversions to client-side suppression. The server fires unconditionally (no browser, no blockers) but with lower trust per event because the server cannot supply a fresh browser fingerprint. Together they recover the suppressed conversions without sacrificing the pixel's trust signal.

The contract that holds the dual feed together is event_id. Every conversion ships from both sides with the same event_id — typically the platform's order ID. Meta dedupes events with matching event_name + event_id within a rolling 48-hour window. If the pixel arrives first, it counts. If only the CAPI arrives (pixel was blocked), the CAPI counts. If both arrive, they merge. Without a shared event_id the same conversion counts twice and your ROAS inflates 2x.

In Admaxxer, the server half of the dual feed comes from the accounts you connect on /integrations: pick your Meta Pixel (or TikTok Pixel), turn server-side sending on, and Admaxxer sends each order as a purchase event with the order ID as event_id. Klaviyo can receive a Placed Order event the same way. The browser half is your own platform pixel, which must send the same order ID. Meta, TikTok and Klaviyo are supported; forwarding to Google Ads is not available yet, and Pinterest is not connectable yet.

What Meta's Conversions API actually is

Meta's Conversions API (CAPI) is a server-to-server POST to the Graph API event-ingest endpoint at /<PIXEL_ID>/events. The pixel does the same conceptual thing from the browser; CAPI does it from your backend. Same event schema, same custom_data shape, same standard event vocabulary — just a different physical sender.

The shape of a Purchase event is the same as what fbq('track', 'Purchase', ...) produces on the client, with one critical addition: the user_data block. Because the server does not have a browser, it cannot pull the visitor's cookies or fingerprint automatically. You have to supply Meta with the identifiers Meta needs to match the event back to a person: hashed email, hashed phone, fbc (the fbclid-derived cookie), fbp (the first-party tracking cookie), client IP, and user-agent.

Here is the canonical Purchase event shape — every field is documented at the Meta Marketing API v25 reference:

POST https://graph.facebook.com/v25.0/<PIXEL_ID>/events
  ?access_token=<CAPI_ACCESS_TOKEN>
Content-Type: application/json

{
  "data": [
    {
      "event_name": "Purchase",
      "event_time": 1747526400,
      "event_id": "shopify-order-1029384756",
      "action_source": "website",
      "event_source_url": "https://acme-skincare.com/checkout/thank_you",
      "user_data": {
        "em":   ["e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"],
        "ph":   ["83a3e7cf02d4b76cd60ba89eb6c2c19acb3a1a1f7f1d8b1d1cb1c0e3f1e1f7c6"],
        "fbc":  "fb.1.1747526380.IwAR1234567890abcdefREDACTED_fbclid_value",
        "fbp":  "fb.1.1747526380.0123456789",
        "client_ip_address": "203.0.113.42",
        "client_user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_4) ...",
        "fb_login_id": null
      },
      "custom_data": {
        "currency":      "USD",
        "value":         54.99,
        "content_ids":   ["sku_serum_1oz"],
        "content_type":  "product",
        "num_items":     1,
        "order_id":      "1029384756"
      }
    }
  ],
  "test_event_code": null
}

Field-by-field: event_name is one of Meta's nine standard events plus your custom-named events. event_time is a Unix timestamp in seconds. event_id is your dedup key — make it the Shopify order ID. action_source is 'website' for browser conversions, 'app' for in-app, 'physical_store' for offline, 'email' for email-driven conversions. event_source_url is the thank-you page URL.

The user_data block is where the recovery work happens. em (email) and ph (phone) are SHA-256 hashes of the lowercased trimmed input — Meta requires this hashing because they never accept plaintext PII. fbp is the first-party cookie Meta's Pixel sets; fbc carries the ad click. Admaxxer's pixel reads Meta's own _fbc and _fbp cookies (or builds fbc from the fbclid when no cookie exists) and sends them with the server event. client_ip_address and client_user_agent are the visitor's IP and browser UA, captured by the pixel and forwarded server-side.

custom_data carries the business payload: currency, value, content_ids, num_items, order_id. These power Meta's optimization and bid algorithms — the more complete this block, the better Meta's auction targeting on your campaigns.

Why CAPI matters more now than it did pre-iOS-17

Pixels worked fine in 2020. They worked acceptably in 2022. They are systematically lossy in 2026 because three independent forces have closed in on the browser pixel from different angles.

iOS 17 Link Tracking Protection (Sept 2023) strips fbclid, gclid, and 15 other click identifiers from URLs opened in Mail, Messages, and Private Safari before the destination page loads. The pixel still fires, but it fires with no fbclid — Meta cannot match the conversion back to an ad click. The conversion is reported as organic. Spend is misallocated.

Safari ITP — Intelligent Tracking Prevention — caps the lifetime of any cookie set in third-party context to 7 days, and any cookie set via document.cookie from JS to 1 day. Repeat-visit attribution windows collapse from 28 days to 1 day on a sizeable fraction of your iOS Safari traffic.

Privacy-first browsers — Brave, Firefox with Enhanced Tracking Protection, DuckDuckGo, the latest Edge — block Meta's pixel script outright. The user clicks an ad, lands on your page, converts, and Meta never receives a single signal. The conversion is invisible to the auction.

Aggregated across a typical DTC traffic mix, these three forces suppress 15–25% of pixel-side conversions before they reach Meta. CAPI recovers most of them because it fires from your server, which has none of these constraints. The recovered ROAS is real — it represents conversions that were happening anyway but were being misattributed to organic/direct.

Google has the same problem with the gclid + GA4 client-side feed. TikTok and Pinterest have the same problem with their pixel. The server-side recovery pattern is the same across networks. Admaxxer sends server-side purchases to Meta and TikTok (and Klaviyo) today; forwarding to Google Ads and Pinterest is not available yet.

Meta CAPI setup — the 30-minute walkthrough

In Admaxxer, Meta server-side sending uses the ad account you connect on /integrations and the Pixel you pick. The token on that connection must have access to the Pixel; the test-event button tells you straight away if it does not.

The step-by-step:

  1. Admaxxer → /integrations → Meta Ads → connect your ad account.
  2. On that connection, open Server-side conversions. Admaxxer lists the Pixels in your Business Manager — pick the one your storefront fires (Events Manager → Data Sources → your Pixel shows the ID).
  3. Turn sending on, then click 'Send test event to Meta'. It appears in Events Manager → your Pixel → Test Events and does not count toward your stats.
  4. Make sure your browser Meta Pixel sends the order ID as eventID on the thank-you page, so Meta can match it with the server event.
  5. Place a real test order (refund it afterwards) and confirm in Events Manager that the Purchase arrived from both browser and server, deduplicated.

Teams that send their own server events outside Admaxxer can check auth and payload shape with Meta's test_event_code, as below. In Admaxxer, the 'Send test event to Meta' button does the same check for you.

# Verify CAPI before going live. Visit Events Manager → Test Events,
# copy the TEST<...> code, then run this curl against your pixel.
curl -X POST "https://graph.facebook.com/v25.0/<PIXEL_ID>/events?access_token=<CAPI_ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "data": [{
      "event_name": "Purchase",
      "event_time": '"$(date +%s)"',
      "event_id": "smoke-test-001",
      "action_source": "website",
      "user_data": { "em": ["test-hash-here"] },
      "custom_data": { "currency": "USD", "value": 1.00 }
    }],
    "test_event_code": "TEST12345"
  }'

# Successful response: {"events_received":1,"messages":[],"fbtrace_id":"..."}
# If you see "messages": [...], the payload was rejected — read the message
# carefully (typically a missing user_data field or unhashed email).

Google Enhanced Conversions — set it up in Google Ads for now

Google's equivalent of Meta CAPI is Enhanced Conversions: hashed email and phone (plus the gclid when there is one) sent with a conversion, so Google can match it when the browser signal is missing. Performance Max campaigns lean on it most, because they rely heavily on first-party signals.

Admaxxer does not forward purchases to Google Ads yet. You may see a Google Ads panel in the connection drawer, but no conversions are sent to Google from it. If you use Enhanced Conversions today, set it up in Google's own tools:

  1. In your Google Ads account, turn on enhanced conversions for the conversion action you use for purchases.
  2. Choose how Google receives the customer data: the Google tag, Google Tag Manager, or your store platform's Google integration.
  3. Send your order ID as the transaction ID, so Google can drop a duplicate upload of the same order.
  4. After a few days, check the conversion action's diagnostics in Google Ads.

For reference, here is the shape of an Enhanced Conversions upload (values are made up; Admaxxer does not send this yet):

# Example only: a Google Enhanced Conversions upload. Admaxxer does not send this yet.
POST https://googleads.googleapis.com/v17/customers/<CUSTOMER_ID>:uploadClickConversions
Authorization: Bearer <OAUTH_ACCESS_TOKEN>
developer-token: <DEVELOPER_TOKEN>
Content-Type: application/json

{
  "conversions": [
    {
      "gclid": "EAIaIQobChMI1234567890_gclid_value",
      "conversion_action": "customers/<CUSTOMER_ID>/conversionActions/<ACTION_ID>",
      "conversion_date_time": "2026-05-18 14:30:00+00:00",
      "conversion_value": 54.99,
      "currency_code": "USD",
      "order_id": "1029384756",
      "user_identifiers": [
        {
          "hashed_email": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
          "user_identifier_source": "FIRST_PARTY"
        },
        {
          "hashed_phone_number": "83a3e7cf02d4b76cd60ba89eb6c2c19acb3a1a1f7f1d8b1d1cb1c0e3f1e1f7c6",
          "user_identifier_source": "FIRST_PARTY"
        }
      ]
    }
  ],
  "partial_failure": true
}

user_identifier_source='FIRST_PARTY' tells Google these identifiers came from your own customer data, not an in-Google form fill — required for the conversion to be eligible for Enhanced Conversion matching.

TikTok Events API (Pinterest not available yet)

TikTok Events API: connect TikTok Ads on /integrations, open Server-side conversions on that connection and pick your TikTok Pixel ID (Admaxxer lists the pixels in your TikTok Ads Manager). Turn sending on and click 'Send test event to TikTok' — it shows in TikTok Events Manager → your Pixel → Test Event.

Pinterest Conversions API: not available yet. The Pinterest Ads connection in Admaxxer is still coming soon, so server-side Pinterest conversions cannot be turned on today. Use Pinterest's own Conversions API setup in the meantime.

TikTok runs on the same dual-feed contract as Meta. The pixel fires client-side; the server fires server-side; both ship a matching event_id; the platform dedupes on event_name + event_id. The recovered ROAS lift is typically smaller than on Meta because TikTok's client-side pixel was less cookie-dependent to begin with.

TikTok Shop: orders placed inside TikTok Shop are attributed by TikTok itself. Admaxxer's server-side sending covers orders from your own store, so check that the same order is not also counted through a TikTok Shop integration.

event_id deduplication — the contract that makes the dual feed work

Without deduplication, the dual feed double-counts every conversion. With deduplication, the dual feed recovers suppressed conversions at no double-count cost. The mechanism is simple, and the implementation discipline is non-negotiable.

Meta deduplicates events on the tuple (event_name, event_id) within a rolling 48-hour window per pixel. If your pixel fires a 'Purchase' event with event_id='1029384756' at 10:00 UTC, and your CAPI fires a 'Purchase' event with event_id='1029384756' at 10:00:02 UTC, Meta keeps one. If your CAPI fires the same Purchase 24 hours later because the pixel was blocked and the server retry queue kicked in, Meta still keeps one.

The canonical event_id for an ecommerce conversion is the Shopify order ID. Every other identifier (Stripe payment intent, Recharge charge ID, custom-checkout order number) works equally well as long as it is stable and unique per conversion. The pixel and the server must both supply the same id, in the same case, with no decoration.

// Pixel side (browser) — Shopify thank-you page snippet.
fbq('track', 'Purchase', {
  value: 54.99,
  currency: 'USD',
  content_ids: ['sku_serum_1oz']
}, {
  eventID: '1029384756'  // <-- Shopify order ID, lowercased to "eventID" per fbq spec
});

// Server side (CAPI) — sent by Admaxxer when the order lands.
{
  "event_name": "Purchase",
  "event_id": "1029384756",   // <-- SAME id as the pixel-side eventID
  "event_time": 1747526400,
  "event_source_url": "https://acme-skincare.com/checkout/thank_you",
  ...
}

// Meta dedupes events with matching event_name + event_id within a 48-hour
// rolling window. Without a shared event_id, the same purchase counts twice
// in your Ads Manager reports — inflating ROAS by 2x and corrupting the
// bidding algorithm's learned conversion rate.

Two ways the contract breaks. First, mismatched casing: 'A1B2C3' on the pixel side, 'a1b2c3' on the server side — Meta treats those as different ids. Make sure your browser pixel sends the order ID exactly as your store reports it. Second, event_id reuse across event_names: using order ID '1029384756' as the event_id for both a Purchase event AND a CompleteRegistration event is fine (Meta dedupes on the tuple), but using order ID '1029384756' for two separate Purchase events is a bug.

The same contract applies to the TikTok Events API (event_id). Admaxxer sets the server event's event_id to the order's ID; your browser pixel has to send the same value. Check the pair in each platform's event tools after setup. Google Enhanced Conversions dedupes on order_id too, but forwarding to Google Ads is not available in Admaxxer yet, and neither is Pinterest.

The nine Meta standard events — what fires when

Meta's nine standard events (per the v25 reference) are the canonical event vocabulary across pixel + CAPI. Admaxxer's server-side sending covers Purchase only; the other events come from your browser pixel, and there is no event-mapping screen in Admaxxer.

Standard eventWhen it fires
PageViewAny page load.
ViewContentProduct detail page view.
AddToCartCart line added.
InitiateCheckoutCheckout started.
AddPaymentInfoPayment step reached.
PurchaseOrder completed. Sent by your browser pixel on the thank-you page and by Admaxxer from the server.
LeadLead form submission (newsletter, contact, demo).
SubscribeRecurring subscription started.
CompleteRegistrationAccount created.

Standard events benefit from Meta's optimization layer in a way that custom events do not — Meta's bid algorithms have prior beliefs about how each standard event correlates with downstream value, and they exploit those priors during the learning phase. Custom events work, but they put the optimization layer into a longer learning phase. Use standard events whenever the conceptual mapping is clean.

The mapping that catches the most operators out: AddToCart fires whenever a line is added, including when the customer is browsing pre-purchase. Some merchants want AddToCart to fire only when the cart has crossed a value threshold; that is a custom event, not AddToCart. Keep the standard event semantics aligned with Meta's documented definitions or the bid algorithm will mismatch your data.

Post-deploy parity check — a daily check by hand

Once both feeds are live, compare browser events, server events and store orders every day for the first week. Admaxxer does not run this three-way check or alert on it for you; the numbers come from your store and each platform's event tools.

Rough tolerances:

  • Server events within 2% of your order count: green.
  • Between 2% and 5%: yellow. Investigate within 24 hours — typically missing customer data on orders or a Pixel mismatch.
  • Above 5%: red. Check the token, the Pixel ID and a fresh test event.

The pixel-vs-orders gap is normal — browser pixel events are suppressed by ad blockers / iOS link tracking / Safari ITP and will run ~15-25% below orders. The server-vs-orders gap should be near-zero. The pixel-vs-server gap is the interesting number: it measures the suppression rate you are recovering with CAPI.

Daily parity check — do it by hand for the first week.

For yesterday, write down three numbers:
  truth   = paid orders in your store (or payment provider)
  pixel   = Purchase events your browser Meta Pixel sent
            (Meta Events Manager → your Pixel → Overview, Browser)
  server  = Purchase events received from the server
            (Meta Events Manager → your Pixel → Overview, Server)

Then:
  pixel_gap  = (truth - pixel)  / truth
  server_gap = (truth - server) / truth

Rules of thumb:
  server_gap near 0         server feed healthy
  pixel_gap 15-25%          normal: blockers, iOS link stripping, Safari ITP
  server_gap above 5%       investigate: token, Pixel ID, or orders
                            arriving without customer data

Repeat in TikTok Events Manager if you send TikTok events.

Inside Admaxxer, the Tracking Health badge on Sources & Attribution compares your pixel with each ad platform per channel — see tracking health for what each state means.

Top five misfire causes operators hit in the first week

Five misfire patterns come up most often in the first week. Operators see them as 'CAPI is broken' but each one is a fixable payload issue.

  1. Missing phone hash. The user_data block carries em (email) but no ph (phone). Meta's match rate on email-only is lower than email+phone. Fix: ensure your checkout collects phone; Admaxxer forwards a SHA-256 hash of it when the order includes one.
  2. fbc / fbp not set. The visitor clicked an ad in an iOS Mail environment that stripped the fbclid; the pixel had nothing to write into fbc. Meta's _fbp cookie may still be there, but a missing fbc lowers match rate. Fix: nothing on the operator side — this is the iOS 17 ATP gap that the iOS 17 attribution recovery playbook addresses upstream.
  3. event_id collision. A custom checkout reuses the same order ID for cart abandonment and final purchase. The Purchase event with event_id='X' dedupes against the InitiateCheckout event with event_id='X' (Meta dedupes on event_name + event_id, so technically the tuple is unique, but operator error often produces actual Purchase-vs-Purchase collisions). Fix: prefix the event_id with a per-event-type tag in your custom-checkout glue code.
  4. Consent banner blocking the pixel. If your consent banner holds back the pixels until a visitor opts in, visitors who never opt in leave no click ID or browser cookie behind, so server events for their orders carry less match data. That is expected; decide with your legal advice how your banner should treat advertising pixels. Admaxxer does not gate server-side sends on consent today.
  5. Account-level Meta de-prioritization. After a sudden 30%+ event-volume spike (typical of a fresh CAPI rollout), Meta's quality scoring may temporarily de-prioritize your pixel. Fix: turn server-side sending on during a quiet week, not right before a sale. Admaxxer has no gradual ramp control; sending starts in full once you enable it.

CAPI rate-limiting — queueing, retries, and failures

Ad platforms rate-limit conversion APIs, and a store that fires one unqueued server call per order can hit those limits on a busy day. Admaxxer handles this in two ways.

First, a queue, not direct calls. Each order becomes one server event in a job queue. The queue is rate-capped per workspace, so a burst of orders waits its turn instead of flooding the platform's API.

Second, retries. A failed send is retried automatically a few times, with the wait doubling between attempts, so a brief platform outage or rate-limit response does not lose the event.

What it does not do yet: Admaxxer has no screen that lists failed or given-up sends. If the server count in Meta or TikTok Events Manager falls behind your orders, re-run the test event and check the token and Pixel.

Operator checklist — 1-hour walkthrough end-to-end

  1. (00:00) Admaxxer → /integrations → connect Meta Ads.
  2. (00:05) Meta connection → Server-side conversions → pick your Pixel → turn sending on → 'Send test event to Meta'.
  3. (00:10) Meta Events Manager → Test Events → confirm the test event arrived.
  4. (00:15) Check your browser Meta Pixel sends the order ID as eventID on the thank-you page.
  5. (00:25) Optional: Klaviyo connection → Server-side conversions → turn on Enable Klaviyo Server-Side Track Events → send a test event.
  6. (00:30) Google Ads: forwarding isn't available in Admaxxer yet. If you use Enhanced Conversions, set it up in Google Ads itself.
  7. (00:40) Admaxxer → /integrations → connect TikTok Ads → Server-side conversions → pick your TikTok Pixel → turn on → send a test event.
  8. (00:50) Place a real test order on your storefront (refund it afterwards).
  9. (00:55) Confirm the order in Admaxxer's Sources & Attribution page, and as a deduplicated browser + server Purchase in Meta Events Manager.
  10. (01:00) Done. Run the daily parity check by hand for the first week.

After the 1-hour setup, allow 7 days for Meta's bid algorithm to re-baseline on the new conversion volume. Reported ROAS will rise during this period — that is the recovery showing up, not a phantom lift.

Frequently asked questions

What is Meta CAPI and how does it differ from the Meta Pixel?
The Meta Pixel fires from the browser: JavaScript that sends page-view, add-to-cart and purchase events to Meta. The Conversions API (CAPI) sends events from a server to Meta's /events endpoint. Server events survive ad blockers, iOS link stripping and Safari ITP; browser events carry cookie context. Together they form a dual feed, deduplicated by event_id so one order counts once. Admaxxer's pixel does not fire Meta tags in the browser: keep your Meta Pixel for the browser side, and Admaxxer sends Purchase events from the server.
Why does Meta require deduplication via event_id?
Because one purchase reaches Meta twice: from the browser pixel and from the server. Without a shared event_id, Meta would count it twice, inflating reported results and confusing bidding. Admaxxer sets the server event's event_id to the order or payment ID; your browser Meta Pixel must send the same value on the thank-you page. Check the pair in Meta Events Manager after setup. Admaxxer does not run an automatic dedup or parity check; the daily check in this playbook is done by hand.
What's Google Enhanced Conversions and do I need it?
Google Enhanced Conversions sends hashed customer data with a conversion so Google can match it when browser-side signal is missing. It matters most for campaigns such as Performance Max that lean on first-party signals. Admaxxer does not forward purchases to Google Ads yet, so today you set up Enhanced Conversions in Google Ads itself, with your order ID as the transaction ID so duplicates are dropped.
Does Admaxxer support TikTok Events API and Pinterest Conversions API?
TikTok, yes: connect TikTok Ads on /integrations, pick your TikTok Pixel under Server-side conversions, turn sending on and send a test event. It uses the same event_id dedup contract as Meta. Pinterest, not yet: the Pinterest Ads connection is still coming soon, so server-side Pinterest conversions cannot be turned on today. Orders placed inside TikTok Shop are attributed by TikTok itself; Admaxxer's server-side sending covers orders from your own store.
How do I verify CAPI is working end-to-end?
Three checks. (1) Click the send-test-event button on the connection; it shows whether the platform accepted the event. (2) Place a real test order (refund it afterwards) and confirm in Meta Events Manager that the Purchase arrived from both browser and server, deduplicated. (3) For the first week, compare store orders, browser events and server events by hand each day; the server count should sit close to your orders. Inside Admaxxer, the Tracking Health badge on Sources & Attribution flags channels where the pixel and the ad platform disagree by more than 10% or 30%.

Run this playbook in your own dashboard

Admaxxer ships the pixel + server-side purchases to Meta, TikTok and Klaviyo + Maxxer AI agent + cohort analytics out of the box. The playbook above becomes a live surface in your account after a 5-minute setup.

Start a 7-day trial See pricing