Conversions API Implementation Guide: How to Deploy Meta CAPI, Google EC, and Microsoft CAPI in 2026

What This Conversions API Implementation Guide Covers

This guide focuses on parallel server-side and browser-side event sending — the model where your server fires conversion data directly to each platform's API while your browser tags continue to run, with deduplication preventing double-counting. This approach delivers the highest signal fidelity because it captures conversions that ad blockers, browser restrictions, and network timeouts would otherwise drop.

For a broader foundation before diving into platform-specific steps, read our guide on server-side conversion tracking — it covers first-party data architecture, cookie strategies, and why the server-side model outperforms pixel-only measurement in nearly every measured scenario.

"An e-commerce client recorded 8,841 conversions with server-side cookies versus 7,466 with client-side cookies — an 18.26% increase in tracked conversions." — Stape.io retail case study

That gap represents real purchase signals your campaigns would otherwise never see. Multiply that across three ad platforms and the cumulative impact on bidding quality and ROAS is significant. The three APIs covered here — Meta CAPI, Google Enhanced Conversions (EC), and Microsoft CAPI — each have distinct authentication methods, payload structures, and deduplication mechanisms, which is why a unified implementation plan matters.

Prerequisites: What to Have Ready Before You Start

Attempting to implement all three APIs without the right access and data pipeline in place leads to partial deployments that create more reporting confusion than they solve. Before writing a single line of server-side code, confirm you have the following:

• A server-side tag management container — Google Tag Manager Server-Side (sGTM), Stape, or a custom Node/Python endpoint. This is where your server events will originate.
• First-party user data collection — hashed email addresses (SHA-256), hashed phone numbers, and client IDs collected at checkout or lead submission. All three APIs require at least one match key for identity resolution.
• Event IDs generated on the browser — a unique string (UUID or similar) created client-side and passed to your server with each event. This is essential for deduplication.
• Platform access credentials — Meta System User token with ads_management permissions, Google Ads conversion action IDs with Enhanced Conversions enabled, and Microsoft Ads UET tag ID with CAPI access approved.
• A staging environment — test events should never touch production conversion windows before QA is complete.

Deploy Meta CAPI Alongside Your Pixel

Meta's Conversions API is the most mature of the three and has the richest documentation, but the payload structure trips up many implementers. The goal is redundant event firing: your Pixel fires from the browser, your server fires from your backend, and Meta's deduplication engine merges them into a single counted event.

For a detailed walkthrough tailored to Shopify and DTC brands, see our Meta CAPI setup for ecommerce guide. The steps below cover the core implementation applicable to any stack:

• Create a System User in Meta Business Manager under Business Settings → System Users. Generate an access token with ads_management and ads_read permissions.
• Configure your server-side endpoint to POST to https://graph.facebook.com/v19.0/{pixel_id}/events with your access token as a query parameter.
• Build the event payload — include event_name, event_time (Unix timestamp), event_id (matching what your Pixel sent), event_source_url, and the user_data object containing SHA-256 hashed em, ph, and client_ip_address.
• Pass server event data (fbp and fbc cookie values) from your browser to your server on each conversion — this dramatically improves match rates.
• Test with the Events Manager Test Events tool before pushing to production. Confirm that matched events show "Received" status and that the event match quality score is above 6.0.
• Enable the Aggregated Event Measurement configuration and verify your domain is verified in Meta Business Manager.

Implement Google Enhanced Conversions via Server-Side GTM

Google Enhanced Conversions (EC) works differently from Meta CAPI — it enriches existing conversion tags with hashed first-party data rather than replacing them. The server-side GTM approach gives you the cleanest implementation because your sGTM container handles hashing, data normalization, and the API call in one place.

Our dedicated guide on server-side tracking for Google Ads goes deep on the OAuth setup and conversion action configuration. For this unified implementation, follow these steps:

• Enable Enhanced Conversions for Web in your Google Ads account under Goals → Conversions → Settings → Enhanced conversions for web. Select the "Google tag or Google Tag Manager" option.
• Deploy a Google Ads Conversion Tracking tag in your sGTM container, mapping it to your existing conversion action.
• Add the Enhanced Conversions fields to the tag: map email from your data layer — sGTM will hash it automatically using SHA-256 before sending.
• Pass the transaction_id (order ID) in every purchase event. This is Google's primary deduplication mechanism between browser and server hits.
• Use the Tag Assistant in sGTM to preview server-side requests and confirm the enhanced_conversions object is populated in the outbound payload to Google's servers.
• Monitor the Diagnostics tab in Google Ads conversion settings for the first 7 days — look for "Enhanced conversions" coverage above 80% of total conversions as a health benchmark.

Set Up Microsoft CAPI for UET Signal Enrichment

Microsoft's Conversions API reached general availability in 2026 and follows a structure deliberately similar to Meta CAPI, which makes it the fastest of the three to implement once the other two are running. It sends offline and online conversion data directly to Microsoft Ads without relying on the UET browser tag alone.

For a full walkthrough of the Microsoft-specific setup steps including partner integrations, read our Microsoft CAPI setup guide. The core deployment steps are:

• Generate an OAuth 2.0 access token via the Microsoft Advertising developer portal. Use the client credentials flow for server-to-server calls.
• Identify your UET tag ID from Microsoft Ads under Tools → UET Tags. You'll reference this in every API payload as the TagId.
• Structure your POST request to https://api.ads.microsoft.com/v13/customers/{customerId}/conversiongoals/uploadconversions with the Authorization: Bearer {token} header.
• Include hashed user data: SHA-256 hashed email and phone in the HashedEmailAddress and HashedPhoneNumber fields respectively.
• Set the MicrosoftClickId (msclkid) wherever available — it's captured from URL parameters when users click a Microsoft Ads link and significantly improves attribution accuracy.
• Validate via the Conversion Goals diagnostic view in Microsoft Ads — check that server-sent conversions appear within 6 hours of the test event firing.

Configure Deduplication Logic Across All Three APIs

Deduplication is where most multi-API implementations break down. Without it, a single purchase event fires from the browser and the server, and both get counted — inflating your reported conversions and corrupting your bidding signals. Each platform handles deduplication differently, but the underlying principle is the same: match browser events to server events using a shared unique identifier.

For a deep technical reference, read our article on event deduplication server-side tracking. The implementation checklist for all three platforms:

• Generate a UUID event ID client-side on every conversion event — in JavaScript using crypto.randomUUID() — and store it in your data layer.
• Pass the event ID to your server via a first-party cookie or a POST body parameter within the same conversion request that triggers your server-side tag.
• For Meta: send the same event_id string in both the Pixel fbq('track', 'Purchase', {eventID: 'uuid'}) call and the CAPI payload's event_id field.
• For Google: pass the same transaction_id (order ID) in both the browser-side gtag conversion tag and the sGTM server-side conversion tag. Google uses this field — not a separate event ID — for deduplication.
• For Microsoft: include the same event_id or order ID in both the UET browser tag's eventId parameter and the CAPI payload.
• Run a 48-hour parallel test in each platform's test/debug environment — confirm that duplicate events collapse to single events rather than appearing as two separate conversions.

Common Mistakes to Avoid

These are the errors that show up most frequently when teams implement multiple APIs simultaneously — and each one can silently corrupt your data for weeks before anyone notices.

• Hashing data inconsistently — all three platforms require lowercase, whitespace-trimmed email addresses before SHA-256 hashing. Hashing User@Example.com instead of user@example.com produces a different hash and kills your match rate.
• Using different event IDs on browser and server — regenerating a new UUID server-side instead of passing the browser-generated one breaks deduplication entirely, causing every event to be counted twice.
• Omitting fbp and fbc from Meta payloads — these Meta-managed cookies carry click and session data that Meta uses for attribution. Sending CAPI events without them drops event match quality significantly.
• Sending server events before the browser fires — if your server fires a CAPI event faster than the Pixel can fire from the browser, some platforms may process the server event as primary and then treat the browser event as a duplicate — but only if your event IDs match. If they don't match, you get double-counting instead of deduplication.
• Not normalizing phone numbers — all platforms require E.164 format (+12125551234) before hashing. Raw phone numbers in varying formats produce zero matches.
• Skipping the QA stage for Microsoft CAPI — because Microsoft CAPI is newer, teams often test Meta and Google thoroughly but push Microsoft straight to production. The diagnostic reporting lag (up to 6 hours) makes errors harder to catch without a structured QA window.

Expected Results and Timeline

Implementing all three APIs correctly takes between one and three weeks for most teams, depending on stack complexity and whether a server-side GTM container is already in place. Here's what to expect at each phase:

Industry practitioners commonly report a 15–25% increase in attributable conversions within the first 30 days of a clean multi-API deployment — driven primarily by capturing events that browser-only tracking was missing. The bidding quality improvement typically follows 4–6 weeks later as algorithms accumulate enough enriched conversion data to materially shift optimization decisions.

Frequently Asked Questions