How to Set Up Facebook Ads Conversion API (CAPI)

What is Facebook Conversion API?

Facebook Conversion API (CAPI) is a server-side tracking solution that allows you to send conversion data directly from your server to Facebook's systems, bypassing browser-based limitations. Unlike the traditional Facebook Pixel which runs in the user's browser, CAPI creates a direct connection between your backend infrastructure and Meta's advertising platform.

• Server-to-server communication - Data flows directly from your server to Facebook without relying on cookies or browser tracking
• Privacy-resilient tracking - Works independently of browser privacy settings, ad blockers, and iOS ATT restrictions
• Better data quality - You control exactly what data is sent and when, with access to customer information browsers can't see
• Redundancy and reliability - Combined with Pixel, creates multiple data pathways for complete conversion tracking

Think of it this way: the Facebook Pixel is like having security cameras at your store entrance (they only see what comes through the front door), while CAPI is like having a complete inventory management system that tracks everything happening in your business, regardless of whether customers are visible or not.

Industry Insight: According to Meta's internal data, advertisers using both Pixel and CAPI see an average of 13% more conversions attributed compared to Pixel-only implementations, with some industries seeing improvements of 20-30%.

Why You Need CAPI in 2025

The digital advertising landscape has fundamentally changed over the past few years, making CAPI less of an optional enhancement and more of a critical necessity. Here's why implementation is no longer optional:

The iOS 14.5+ Impact

When Apple introduced App Tracking Transparency (ATT), it created a massive tracking gap. Current opt-in rates hover around 15-25% globally, meaning 75-85% of iOS users are invisible to browser-based tracking. For businesses where iPhone users represent a significant customer segment, this is catastrophic.

CAPI doesn't completely solve iOS tracking challenges, but it significantly reduces the impact by:

• Capturing conversion events at the server level before users leave your site
• Using first-party data you already have (email, phone, user ID) for better event matching
• Providing Facebook with signals even when the Pixel is blocked or restricted

Third-Party Cookie Deprecation

Google has repeatedly delayed third-party cookie deprecation, but the writing is on the wall. Firefox and Safari already block them by default. When Chrome finally makes the switch, browser-based tracking will face even more limitations.

Ad Blocker Proliferation

Current estimates suggest that 30-40% of desktop users and 15-20% of mobile users employ ad blockers. These tools routinely block Facebook Pixel scripts. CAPI runs on your server where ad blockers can't reach it.

Improved Campaign Performance

Beyond just solving tracking problems, CAPI actively improves campaign results through:

• Better optimization - More complete data means Facebook's algorithm can find better customers
• Higher event match quality - Combining browser and server data creates stronger customer matching
• Faster learning - Campaigns exit learning phase quicker with more reliable conversion data
• Lower CPAs - Better targeting and optimization typically reduce cost per acquisition by 10-25%

If you're investing significant budget in Facebook advertising, CAPI implementation should be a top priority. The good news? It's more accessible than ever, even for non-technical marketers.

Prerequisites and Setup Requirements

Before diving into implementation, ensure you have the necessary access, tools, and understanding of your technical environment. CAPI setup is significantly easier if you prepare these elements in advance.

Required Access and Permissions

You'll need the following permissions in Facebook Business Manager:

• Admin or Developer access to your Facebook Business Manager account
• Admin access to the relevant Ad Account where you want to track conversions
• Admin access to the Facebook Pixel associated with your campaigns

If you don't have these permissions, coordinate with your business manager administrator before proceeding.

Technical Requirements

The technical implementation requirements depend on your platform:

• Server-side capability (Node.js, PHP, Python, Ruby, Java, or similar)
• Ability to make HTTP POST requests from your server
• Access to deploy code to your production environment
• Basic understanding of APIs and server-side programming

• Many platforms (Shopify, WooCommerce, BigCommerce) offer CAPI plugins or native integrations
• Check your platform's app marketplace for official Meta or verified third-party CAPI apps
• These typically require minimal technical knowledge but still need proper configuration

• A server-side GTM container (requires separate hosting)
• Understanding of GTM server-side tagging concepts
• Ability to configure clients and tags in GTM

Data Preparation

CAPI's effectiveness depends heavily on the quality of customer data you can send. Prepare to collect and transmit:

• Email addresses (hashed)
• Phone numbers (hashed)
• First and last names (hashed)
• City, state, zip code, country
• User agent and IP address (for automatic hashing)

Privacy Note: All personally identifiable information (PII) must be hashed using SHA-256 before sending to Facebook. Never send raw email addresses, phone numbers, or names. Meta's CAPI libraries handle this automatically, but verify your implementation follows best practices.

What You'll Generate During Setup

During implementation, you'll create several key components:

Have a secure place to store these credentials. Never commit access tokens to public code repositories or expose them in client-side code.

Step-by-Step Implementation Guide

Let's walk through the complete CAPI implementation process. This guide covers the manual setup approach, which gives you the most control and understanding of how CAPI works.

Step 1: Generate Your Conversion API Access Token

Step 2: Get Your Pixel ID

Still in Events Manager:

Step 3: Install the CAPI SDK (Node.js Example)

If you're using Node.js, Meta provides an official SDK that simplifies implementation:

npm install facebook-nodejs-business-sdk

For other languages:

• PHP: composer require facebook/php-business-sdk
• Python: pip install facebook-business
• Java/Ruby: Official SDKs also available

Step 4: Configure Your Server Endpoint

Create a server-side function that sends conversion events to Facebook. Here's a conceptual Node.js example:

const bizSdk = require('facebook-nodejs-business-sdk');
// Initialize with your credentials (use environment variables)
const access_token = process.env.FB_CAPI_ACCESS_TOKEN;
const pixel_id = process.env.FB_PIXEL_ID;
const Content = bizSdk.Content;
const CustomData = bizSdk.CustomData;
const EventRequest = bizSdk.EventRequest;
const UserData = bizSdk.UserData;
const ServerEvent = bizSdk.ServerEvent;
// Function to send a purchase event
async function sendPurchaseEvent(orderData) {
  const userData = (new UserData())
    .setEmails([orderData.email])
    .setPhones([orderData.phone])
    .setClientIpAddress(orderData.ipAddress)
    .setClientUserAgent(orderData.userAgent)
    .setFbc(orderData.fbc) // Facebook click ID from URL
    .setFbp(orderData.fbp); // Facebook browser ID from cookie
  const customData = (new CustomData())
    .setCurrency('USD')
    .setValue(orderData.value)
    .setContents([new Content().setId(orderData.productId).setQuantity(orderData.quantity)]);
  const serverEvent = (new ServerEvent())
    .setEventName('Purchase')
    .setEventTime(Math.floor(Date.now() / 1000))
    .setUserData(userData)
    .setCustomData(customData)
    .setEventSourceUrl(orderData.sourceUrl)
    .setActionSource('website');
  const eventsData = [serverEvent];
  const eventRequest = (new EventRequest(access_token, pixel_id))
    .setEvents(eventsData);
  try {
    const response = await eventRequest.execute();
    console.log('Event sent successfully:', response);
  } catch (error) {
    console.error('Error sending event:', error);
  }
}

• UserData: Collects customer identifiers for event matching
• CustomData: Contains conversion-specific data like purchase value
• EventTime: Unix timestamp of when the event occurred
• ActionSource: Set to 'website' for web conversions
• fbc and fbp: Facebook tracking parameters that dramatically improve event matching

Step 5: Capture Facebook Click and Browser IDs

To maximize event matching quality, you need to capture two critical parameters from the client side:

Capture these client-side and pass them to your server:

// Client-side code to capture and send to server
function getCookie(name) {
  const value = ; ${document.cookie};
  const parts = value.split(; ${name}=);
  if (parts.length === 2) return parts.pop().split(';').shift();
}
const fbp = getCookie('_fbp');
const urlParams = new URLSearchParams(window.location.search);
const fbclid = urlParams.get('fbclid');
const fbc = fbclid ? fb.1.${Date.now()}.${fbclid} : null;
// Send these to your server with the conversion data

Step 6: Implement Event Deduplication

When using both Pixel and CAPI, you need deduplication to prevent double-counting events. Use the event_id parameter:

// Generate a unique event ID client-side
const eventId = 'unique_' + Date.now() + '_' + Math.random();
// Send with Pixel
fbq('track', 'Purchase', {value: 99.99, currency: 'USD'}, {eventID: eventId});
// Send same event ID with CAPI
const serverEvent = (new ServerEvent())
  .setEventName('Purchase')
  .setEventId(eventId)  // Same ID as Pixel
  // ... rest of event data

Facebook's system automatically deduplicates events with matching event_name and event_id within a 48-hour window.

Step 7: Choose Which Events to Track

Not all events need server-side tracking. Prioritize these:

• Purchase
• Lead
• CompleteRegistration
• Subscribe

• AddToCart
• InitiateCheckout
• AddPaymentInfo

• ViewContent
• PageView
• Search

Focus on conversion events where accurate tracking directly impacts campaign optimization and business results.

Testing and Verification

Before going live, thorough testing ensures your CAPI implementation works correctly and sends high-quality data.

Use the Test Events Tool

Facebook provides a Test Events tool specifically for CAPI verification:

const eventRequest = (new EventRequest(access_token, pixel_id))
  .setEvents(eventsData)
  .setTestEventCode('TEST12345'); // Your generated test code

• Events appear within seconds
• Event names match exactly (case-sensitive)
• Parameters are populated correctly
• No error messages appear

Check Event Match Quality

After sending live events (or test events), check your Event Match Quality score:

• Good: 6.0+ out of 10
• Excellent: 8.0+ out of 10

If your score is below 6.0, you're likely missing critical customer information parameters (email, phone, fbp, fbc).

Verify Deduplication

To confirm Pixel and CAPI deduplication works:

If you see duplicate events, verify your event_id implementation matches on both client and server side.

Monitor for Errors

Check the Diagnostics tab in Events Manager regularly:

• Events Manager > Your Pixel > Diagnostics
• Look for error messages, warnings, or rejected events
• Common issues include invalid parameters, malformed data, or authentication problems

Set up notifications to alert you when error rates increase.

Best Practices and Optimization

Once your basic implementation works, optimize for maximum effectiveness and long-term reliability.

Data Quality Best Practices

• Email (most important for B2C)
• Phone (especially valuable in certain markets)
• First name, last name
• City, state, zip, country
• External ID (your internal customer ID)

Each additional parameter improves event matching quality. Aim to send at least 4-5 parameters per event.

• Lowercase and trim whitespace before hashing
• Use SHA-256 algorithm
• Hash on the server, not client-side (for security)
• The CAPI SDKs handle this automatically

Technical Implementation Best Practices

try {
  await eventRequest.execute();
} catch (error) {
  // Log error for debugging
  console.error('CAPI Error:', error);
  // Don't let CAPI failures break your checkout process
  // Consider implementing retry logic or async queue
}

Monitoring and Maintenance

Set up ongoing monitoring to catch issues before they impact campaigns:

• Event Match Quality score (watch for sudden drops)
• Event volume trends (detect implementation breaks)
• Diagnostics tab for new errors

• Compare CAPI event volume to Pixel event volume
• Review which events have best match quality
• Identify opportunities to add more customer parameters

• Review which events drive best campaign performance
• Consider adding additional event types
• Update implementation to leverage new CAPI features

Pro Tip: Create a dashboard that monitors your Event Match Quality score and event volume. Set up alerts when either drops below acceptable thresholds. This early warning system prevents campaign performance degradation.

Platform-Specific Considerations

Compliance and Privacy

CAPI doesn't exempt you from privacy regulations. Follow these guidelines:

• Collect consent for tracking before sending data to Facebook
• Implement consent management platform (CMP) if needed for GDPR/CCPA
• Respect user privacy choices

• Update your privacy policy to mention server-side tracking
• Explain how customer data is used for advertising purposes

• Only send data you actually need for advertising
• Don't send sensitive information like SSNs, financial details, or health data
• Consider implementing data retention policies

Getting Help

If you encounter issues during implementation:

For more advanced tracking strategies, check out our guide on Google Ads conversion tracking best practices or learn about attribution modeling fundamentals to make sense of your cross-channel conversion data.