Meta Conversions API: Send Clean Signals Before You Trust Meta's AI
Meta's AI optimizes toward your events. If the events are missing, double counted, or unmatched, the AI learns the wrong lesson.

Meta's Delivery System Optimizes Toward the Events You Send
Meta's automated delivery system is built on events. When you run Advantage+ campaigns or optimize for conversions, Meta's AI learns from the signals you send: who viewed a product, who started checkout, who booked a call, who completed a purchase. The system adjusts bids, selects audiences, and chooses placements based on those signals. If the events are missing, double reported, unmatched to Meta accounts, or mislabeled, the AI optimizes toward a distorted picture. It learns the wrong lesson.
The browser pixel alone can miss events. Browser loading errors, connectivity issues, and ad blockers can prevent the pixel from firing. A user closes the tab before the pixel loads. A form submits but the confirmation page never renders. The event never reaches Meta, and the conversion that just happened is invisible to the delivery system.
The Meta Conversions API is the plumbing that makes the signal reliable. It is not a growth hack. It is data infrastructure. When your server, website platform, app, or CRM sends events directly to Meta, those events are less affected by the browser environment. Used alongside the pixel, the Conversions API creates a more reliable connection that can help the delivery system decrease cost per result. Meta's own documentation uses hedged language: the API can help, it may improve matching, it is designed to work with the pixel to create redundancy. It does not guarantee lower costs or better results on its own.
The Conversions API is also not designed to bypass data-sharing policies such as iOS App Tracking Transparency or European privacy rules like the ePrivacy Directive. Consent, lawful basis, and compliance with the Meta Business Tools Terms are the advertiser's responsibility. Work with your own legal counsel. This post does not provide legal advice.
What follows is a practical implementation guide. We will cover what the Conversions API is, how to plan your events, which setup path fits your business, how to deduplicate pixel and server events, which parameters are required, how to hash customer information, how Event Match Quality works, how to test and verify, and how to keep the system reliable after launch. We will also cover where AI tools fit on the operator side, what campaign hygiene looks like once signals are clean, and how the CRM connects to the event stream.
What the Conversions API Is in Plain Language
The Conversions API creates a connection between your marketing data and Meta's systems. Your server, website platform, mobile app, or CRM sends events to Meta. Those events are linked to a dataset ID and processed like Meta Pixel events. Website events sent via the Conversions API can be used for the same optimization types as pixel events: maximize number of conversions, maximize value. They appear in Ads Manager and Events Manager alongside pixel data.
The API handles four types of events: website events, app events, business messaging events, and offline conversions. Website events are actions that happen on your site. App events are actions inside a mobile app. Messaging events are actions in Messenger, Instagram, or WhatsApp business chats. Offline conversions are actions that happen in a physical store, over the phone, or in a CRM after the initial lead capture.
Meta states that data from the Conversions API is less impacted than the pixel by browser loading errors, connectivity issues, and ad blockers. When you use the API alongside the pixel, it creates a more reliable connection that helps the delivery system decrease cost per result. The API also lets you optimize for later customer journey actions: post-purchase events like subscriptions, in-store actions, or customer scores.
The benefits are real but conditional. The API can help improve matching and attribution. It may reduce the cost per result. It does not work in isolation. The quality of the events you send, the customer information parameters you include, and the deduplication logic you implement all determine whether the API improves your results or simply adds complexity.
One important note: the Offline Conversions API was discontinued in May 2025. If you were using it, you now use datasets and the standard Conversions API instead.
Build an Event Map Before You Touch Settings
Before you configure anything in Events Manager or install a partner integration, build an event map. An event map is a signal plan. It lists which business moments matter, which standard event names fit those moments, which event is the optimization event, where each event fires (browser, server, or both), what value and currency travel with it, and who owns the source of truth for each conversion.
Start with the business moments. Picture a med spa that books consultations online. The moments that matter might be: someone lands on the site, someone views a service page, someone clicks the booking button, someone fills out the contact form, someone completes the booking, someone shows up for the appointment, someone pays for a treatment package. Each of those moments is a candidate for an event.
Next, map those moments to Meta's standard event names where they fit. PageView for the landing. ViewContent for the service page. InitiateCheckout or Lead for the booking button click, depending on whether the user enters a checkout flow or a lead form. Contact or Lead for the form submission. Schedule or Purchase for the completed booking, depending on whether money changes hands immediately. Purchase again for the treatment package payment.
Decide which event is your optimization event. If you optimize for leads, the Lead event is the optimization event. If you optimize for bookings, Schedule or Purchase is the optimization event. The optimization event is the one you tell Meta to maximize in your campaign settings. It should represent the business outcome you care about most, not the earliest signal in the funnel.
Decide where each event fires. PageView and ViewContent typically fire in the browser via the pixel. Lead or Contact might fire in the browser when the form submits and also fire from the server when the form data is processed. Schedule or Purchase should fire from the server when the booking system confirms the appointment, and may also fire in the browser on the confirmation page. Firing the same event from both browser and server creates redundancy, which we will cover in the deduplication section.
Decide what value and currency travel with each event. Value and currency should come from the source of truth when a real amount exists. If the booking has a deposit amount, send that as the value parameter with the currency set to USD or the appropriate code. If the service has a known price, send that. Leads without a transaction can be sent without a value.
Name the source of truth for each conversion. The source of truth is the system that definitively knows whether the event happened. For a form submission, the source of truth might be the form processor on your website. For a completed booking, the source of truth is the booking system or CRM. For a purchase, the source of truth is the checkout system or payment processor. The source of truth is where you will send the server event from.
Here is a hypothetical event map for an online home services company that takes deposits through a checkout page:
- PageView: fires in browser via pixel; no value; source of truth is the website.
- ViewContent: fires in browser via pixel when someone views a service detail page; no value; source of truth is the website.
- InitiateCheckout: fires in browser via pixel when someone clicks the booking button and lands on the checkout page; no value; source of truth is the website.
- Lead: fires in browser via pixel and from server via Conversions API when someone submits the contact form; no value; source of truth is the form processor or CRM.
- Purchase: fires in browser via pixel on the confirmation page and from server via Conversions API when the payment processor confirms the deposit; value is the deposit amount in USD; source of truth is the payment processor; this is the optimization event.
Your event map will differ based on your business model, your checkout flow, and your CRM. The exercise is the same: list the moments, map the event names, choose the optimization event, decide where each fires, assign value and currency, and name the source of truth. Do this in a spreadsheet or a document before you open Events Manager.

Choose Your Setup Path
Meta offers three setup paths for the Conversions API: Meta-enabled Conversions API, direct integration using code, and partner integrations. The right path depends on your technical resources, your event sources, and how much control you need over which events and parameters are sent.
Meta-enabled Conversions API is the simplest option. It is available for website events only. You enable it with one click in Events Manager. It requires that you already have a Meta Pixel installed. Once enabled, the events and parameters shared through the pixel are automatically shared via the Conversions API as well, and the events are automatically deduplicated. There is no cost, no code, and no configuration. The action source is limited to web events. If your entire conversion funnel happens on your website and you trust the pixel to capture all the events and parameters you need, this option works. If you need to send app events, offline events, CRM events, or messaging events, this option does not cover those.
Partner integrations are the middle ground. Commerce platforms like Shopify, WooCommerce, Wix, and BigCommerce offer Conversions API integrations that you can enable in a few clicks with no additional cost. Website partner platforms like Google Tag Manager, Adobe, and Tealium also offer integrations. The time and cost depend on the partner. If you run your store on Shopify or manage tags through Google Tag Manager, check whether a partner integration exists before you build a direct integration.
Direct integration using code gives you the most control. You or your developer write the code that sends events to Meta. You choose which events to send, which parameters to include, and when to send them. You can send website events, app events, offline events, CRM events, and business messaging events. Meta lists the time to implement as two to four weeks for a new integration, or one to two weeks if you already send website events and are adding app, offline, or messaging events. Direct integration requires infrastructure to send events in real time or in batches close to real time. You can create personalized setup instructions in Events Manager and send them to your developer.
If you need to send app events or physical store events through the Conversions API, direct integration is the only option at this time.
Here is a decision rule list for which path fits which business:
- Use Meta-enabled Conversions API if: all your conversions happen on your website, you already have the pixel installed and firing the events you need, you want the fastest setup with no developer work, and you do not need to send app, offline, CRM, or messaging events.
- Use a commerce or website partner integration if: you run your store or manage tags on a platform that offers a Conversions API integration, you want more control than the one-click option but less complexity than a direct integration, and the partner integration supports the events and parameters you need.
- Use direct integration if: you need to send app events, offline events, CRM events, or messaging events; you need full control over which events and parameters are sent; you have developer resources or budget to hire a developer; or your website, checkout, or CRM is custom-built and does not integrate with a partner platform.
You can review Meta's comparison of Conversions API setup options in the Help Center for additional detail on each path.

Redundant Setup and Deduplication
Meta recommends implementing the Conversions API alongside the pixel and sharing the same events with both. This is called a redundant setup. For example, if you share Purchase, InitiateCheckout, and Contact via the pixel, you should also share those events from the server via the Conversions API. Redundancy improves reliability. If the browser pixel fails to fire, the server event still reaches Meta. If the server event is delayed, the browser event may arrive first.
Redundant setup requires deduplication. Without deduplication, redundant events can be double reported, which distorts the signal. If you do not send the same event via both browser and server, no deduplication is needed for those events. Deduplication only matters when the same event is sent from multiple sources.
The recommended deduplication method is event_id plus event name. The pixel eventID parameter must match the Conversions API event_id parameter. The pixel event name must match the Conversions API event_name parameter. In the pixel code, eventID is the fourth argument in the fbq track call. When Meta receives a browser event and a server event with the same event_id and event_name, and the events do not differ meaningfully in content, Meta generally prefers the one received first and deduplicates the second.
Events are deduplicated only if received within 48 hours of the first event with a given event_id. If the server event arrives more than 48 hours after the browser event, the late duplicate will not be deduplicated against the earlier one.
An alternative deduplication method is to use fbp and external_id along with a consistent event_name across browser and server. This method has limitations. It generally only works when the browser event is sent first and the server event is sent second. It does not deduplicate when both events come from the same source. For example, if two consecutive browser events are sent with the same fbp and event_name, both are kept. If two consecutive server events are sent with the same external_id and event_name, both are kept. The fbp and fbc parameters are first-party cookie values set by the pixel. They are subject to change, so if you send them via the Conversions API, refresh them regularly.
Best practice is to include both event_id and external_id for all events. Include identical event_name across browser and server. This gives Meta multiple signals to deduplicate correctly.
You can read Meta's guide to deduplicating pixel and server events for the technical details and code examples.
Common Double-Counting Traps
Here are the most common mistakes that cause double counting:
- The browser pixel fires a Purchase event on the confirmation page, and the server fires a Purchase event when the payment processor webhook is received, but no event_id is passed to link them. Result: redundant events that are not deduplicated can be double reported.
- The event_id is generated on the server and sent with the server event, but the same event_id is not passed back to the browser to include in the pixel event. Result: two different event_id values, no deduplication.
- The event_name on the browser is "Purchase" but the event_name on the server is "purchase" (lowercase). Result: event names do not match, no deduplication.
- The server event is delayed by more than 48 hours due to a batch processing job. Result: events are deduplicated only if received within 48 hours of the first event with a given event_id; a late duplicate will not be deduplicated against the earlier one.
- The developer uses fbp for deduplication but sends the server event before the browser event. Result: the fbp method does not deduplicate when server comes first.
Test your deduplication logic in the Test Events tool before you launch. Send a browser event and a server event with the same event_id and event_name, and verify that Meta processes one and deduplicates the other.
Required and Recommended Parameters
The Conversions API requires certain parameters for all events and additional parameters for website events. By using the Conversions API, you agree that the action_source parameter is accurate to the best of your knowledge.
The action_source parameter is required for all events. It tells Meta where the event happened. Valid values include email, website, app, phone_call, chat, physical_store, system_generated, business_messaging, and other. email means the conversion happened over email. system_generated means the conversion happened automatically, for example a subscription renewal set to auto-pay. business_messaging means the event came from ads that click to Messenger, Instagram, or WhatsApp. Use the value that accurately describes the source. If the event is a form submission on your website, action_source is website. If the event is a purchase in your mobile app, action_source is app. If the event is a phone call tracked by your call tracking system, action_source is phone_call.
For all website events, two additional parameters are required: event_source_url and client_user_agent. Both are required for website events.
Meta recommends including external_id and event_id for all events. The external_id is a unique identifier for the user in your own system, such as a customer ID or account ID. The event_id is a unique identifier for the specific event instance, used for deduplication. Including both improves matching and deduplication reliability.
Only matched events can be used for ads attribution and delivery optimization. Unmatched events are still usable for basic measurement, but they do not help the delivery system learn who to target. Matching requires customer information parameters, which we will cover in the next section.
Meta considers events with only broad combinations like city, country, state, zip, gender, and user agent, or only date of birth and user agent, or only first name and gender, or only last name and gender invalid. Include high-quality identifiers like email, phone, or IP address to improve the chance of matching.
Customer Information and Hashing
Customer information parameters are the identifiers that let Meta match your events to specific Meta accounts. High-quality identifiers include email (em), IP address (client_ip_address), name (fn for first name, ln for last name), and phone (ph). The more high-quality identifiers you include, the more likely the event is to match.
All contact information must be hashed using SHA256 after normalization. Normalization means trimming whitespace and converting to lowercase for email addresses. For phone numbers, normalization means removing all symbols and spaces, keeping only digits, and including the country code. US phone numbers start with 1. Do not include leading zeros.
If you use Meta's Business SDK, hashing happens automatically. If you build a direct integration without the SDK, you must hash the values yourself before sending them. Meta's systems are designed not to accept unhashed contact information, except where noted in the documentation.
Apply the same set of customer information parameters on the browser side and the server side. If you send email, phone, and IP address with the server event, send the same parameters with the browser event. Consistency improves matching and deduplication.
The fbp and fbc parameters are first-party cookie values set by the pixel. The fbp cookie identifies the browser. The fbc cookie captures the click ID from a Facebook ad click. Both parameters help match events to Meta accounts. If you send fbp and fbc via the Conversions API, refresh the values regularly, because they are subject to change.
For offline events, the action_source parameter should be set to an appropriate value that is not website. For example, if the event is a phone call, set action_source to phone_call. If the event is an in-store purchase, set action_source to physical_store.
If you are an agency sending events on behalf of an advertiser, include a partner_agent string in your events to identify your agency.
The Meta Business Tools Terms require that you have lawful rights to collect, use, and share the data you send. You must hash contact information. Do not share sensitive information, and check Meta's list of prohibited information. Obtain proper permissions and consents from your users. Work with your own legal counsel to ensure compliance.
Event Match Quality
Event Match Quality is a score from 0 to 10 that measures the quality of customer information in your events and the share of event instances that are matched to Meta accounts. The score is available for website events sent through the Conversions API with action_source set to Website. It uses the last 48 hours of data, so you need to send events regularly for the score to be accurate. Event Match Quality is available for both standard and custom web events.
A higher Event Match Quality score means your events are more likely to match to Meta accounts. Matched events help attribution and delivery. When Meta can match an event to a user, the delivery system can optimize to show ads to people more likely to convert. When an event cannot be matched, it still counts in basic measurement, but it does not help the delivery system learn.
Meta ranks customer information parameters by priority in its Business Help Center article on Event Match Quality. High-priority parameters are email and click ID. Medium-priority parameters are Facebook Login ID, birthdate, country, phone, external ID, and browser ID. Low-priority parameters are lead, first name, last name, city, and zip.
Events Manager shows recommended actions to improve your Event Match Quality score. Follow them.
Event Match Quality is currently available for web events only. For offline events, app events, conversion leads, and other event types, contact your Meta representative if you need guidance on matching quality.
This guide does not set a target score. The goal is to include as many high-quality customer information parameters as you can collect lawfully and with proper consent. Do not invent data or send data you do not have. Send what you have, hashed and normalized correctly.
Testing and Verification
The Test Events tool in Events Manager lets you check that server events arrive and are formed correctly. Open Events Manager, navigate to Data sources (or Datasets), select your dataset, and open the Test events tab. In the server events section, you can check that the event_name is correct, the action_source is accurate, the customer information parameters are included and hashed, and the event_id is present for deduplication. Test event information stays in the tool for 24 hours or until you clear the activity manually.
If you are testing CRM events, generate a test lead from an Instant Form and change the lead status in your CRM to trigger the CRM event. Verify that the event appears in the Test Events tool.
Developers should use their own customer information for test events. Test events with fake or random email addresses may be discarded if they cannot be matched. Use a real email address that you control, send a test event, and verify that it appears in the tool.
The Payload Helper tool shows the structure of the event payload. Use it to confirm that all required parameters are included and formatted correctly.
To verify deduplication, send a browser event and a server event with the same event_id and event_name. In the Test Events tool, check which events were processed and which were deduplicated. If both events are processed and neither is deduplicated, your deduplication logic is not working.
Pre-Launch QA Checklist
Before you launch Conversions API events to production, run through this checklist:
- Verify that all required parameters are included: action_source for all events, event_source_url and client_user_agent for website events.
- Verify that customer information parameters are normalized and hashed correctly: email trimmed and lowercase before hashing, phone digits only with country code before hashing.
- Verify that event_id is included for all events that are also sent via the pixel, and that the event_id matches between browser and server.
- Verify that event_name is identical between browser and server for redundant events.
- Send a test event via browser and server with the same event_id and event_name, and confirm that one is processed and the other is deduplicated.
- Once live events have flowed for at least 48 hours, check Event Match Quality score in Events Manager and review recommended actions.
- Verify that the optimization event appears in Ads Manager and can be selected as the conversion event in a campaign.
- Verify that the value and currency parameters are correct for Purchase and other value events.
- Verify that the action_source is accurate for each event type.
Do not skip testing. A misconfigured Conversions API can send double-counted events, unmatched events, or events with incorrect values. The delivery system will optimize toward the bad signal, and your campaigns can suffer.
Timing and Reliability
Sharing events when they happen can help campaigns achieve the best results. Send events in real time or in batches close to real time.
Monitor for drops in event volume after site changes, checkout or form changes, theme or plugin updates, or tag manager edits. A sudden drop in server events may indicate that a code change broke the integration. A sudden spike in events may indicate that deduplication stopped working and events are being double counted.
Implement a change-control rule: any change to the website, checkout flow, form processor, CRM, or tag manager must be followed by a verification check in the Test Events tool and a review of event volume in Events Manager. Do not assume that a change is safe because it does not touch the Conversions API code directly. A theme update that changes the confirmation page URL can break the event_source_url parameter. A form plugin update that changes the field names can break the customer information parameters.
Set up a weekly or monthly review of Events Manager diagnostics. Review Events Manager and copy weekly event counts into a simple sheet. Flag weeks where counts swing sharply versus the prior week, using a threshold you set. Look for anomalies: weeks where server events drop to zero, days where Purchase events double, sudden changes in Event Match Quality score. Investigate and fix issues before they compound.
Where AI Fits on the Operator Side
AI tools can help you manage the Conversions API and keep signals clean, but they do not replace human judgment. Use AI assistants or AI agents to draft the event map, review weekly Events Manager diagnostics for anomalies, compare server event counts to browser event counts, and write the change log. A human should approve any change to tracking before it goes live.
For example, you can review Events Manager and copy the last seven days of event data into a simple sheet, upload it to an AI assistant, and ask it to flag any days where the Purchase event count swings sharply versus the prior week. The AI can identify the anomaly. You investigate the root cause and decide whether to fix the integration or adjust the campaign.
You can also use an AI assistant to draft the event map. Describe your business model, your checkout flow, and your CRM in plain language. Ask the assistant to suggest which Meta standard events fit each moment, where each event should fire, and what customer information parameters you can collect. Review the output, correct any mistakes, and finalize the map yourself.
Do not use AI to write production Conversions API code without a developer reviewing it. Do not use AI to make live changes to your Events Manager settings. Do not trust AI to interpret Meta's documentation without verifying the claims against the official source. AI is a drafting and analysis tool, not an autonomous operator.
Campaign-Side Hygiene Once Signals Are Clean
Once your Conversions API is sending clean, deduplicated, matched events, follow Meta's campaign-side best practices to let the delivery system learn. These practices come from Meta's own documentation on Conversions API best practices.
Respect the learning phase. When you launch a new campaign or ad set, or when you make a significant edit to an existing one, the delivery system enters a learning phase. During this phase, Meta is gathering data on which audiences and placements perform best. Avoid making additional significant edits during the learning phase. Let the system stabilize.
Minimize auction overlap. If multiple ad sets target the same audience and optimize for the same event, overlapping ad sets compete with each other in the auction. Consolidate audiences where possible, or use campaign budget optimization to let Meta allocate budget across ad sets automatically.
Use automatic placements and campaign budget optimization. Automatic placements let Meta show your ads based on where they perform best. Campaign budget optimization lets Meta allocate budget across ad sets based on performance. Both features give the delivery system more flexibility to optimize.
Choose the bid strategy that matches your goal, such as lowest cost, cost cap, or a ROAS goal. Do not change bid strategies frequently.
Measure the impact properly. After you implement the Conversions API, do not assume that any change in performance is due to the API alone. Run a Conversion Lift Study or a split test to understand the incremental impact of the API compared to using the pixel alone. Meta's documentation recommends this approach. Do not eyeball the results and declare success.
Where the CRM Fits
The booking system or CRM is often the source of truth for later events in the customer journey. Picture a hypothetical flow: a lead submits a form on your website. The browser pixel fires a Lead event. The form data is sent to your CRM. The lead books an appointment. The CRM fires a Schedule event via the Conversions API. The lead shows up. The CRM fires a custom event for "showed." The lead pays for a service package. The CRM fires a Purchase event.
Platforms like GoHighLevel or Sumo AI CRM hold that record. Sumo AI CRM is an AI-first CRM where AI agents do the CRM work, including an AI receptionist. It is positioned as the best GoHighLevel alternative. Confirm for your own stack whether those events reach Meta natively, through a partner integration, or through a direct integration your developer builds.
The quality of CRM events depends on the quality of the lead data captured at the start. If the form does not collect an email address, the CRM cannot send an email parameter with the event. If the form collects a phone number but does not normalize it, the CRM sends a malformed phone parameter. If the form collects an email address but the user enters a fake one, the event cannot be matched. You can read more about how to capture clean lead data from your forms in our guide to form design and validation.
Common Mistakes and Fixes
Sending Unhashed Customer Information
Mistake: The developer sends email addresses or phone numbers in plain text without hashing them first. Meta's systems are designed not to accept unhashed contact information, and the events may not be matched.
Fix: Normalize and hash all contact information using SHA256 before sending it via the Conversions API. If you use Meta's Business SDK, hashing happens automatically. If you build a custom integration, implement the hashing logic yourself. Test with the Payload Helper tool to confirm that the hashed values are correct.
Inconsistent Event Names Between Browser and Server
Mistake: The browser pixel fires an event called "Purchase" and the server fires an event called "purchase" (lowercase). The event names do not match, so deduplication fails and both events are counted.
Fix: Use the exact same string on both sides and do not rely on Meta treating variants as the same. If the browser uses "Purchase," the server must use "Purchase." If you use a custom event name, use the exact same string on both sides.
Missing event_id for Redundant Events
Mistake: The browser pixel fires a Purchase event and the server fires a Purchase event, but no event_id is included. Meta has no way to know that these are the same event, so both are counted.
Fix: Generate a unique event_id when the event happens, and pass that event_id to both the browser pixel and the server Conversions API call. The event_id must be identical on both sides. Store the event_id in a hidden form field, a session variable, or a database record so that both the browser and the server can access it.
Sending Events More Than 48 Hours Late
Mistake: The server processes events in a nightly batch job, and some events are sent to Meta 72 hours after they occurred. Events are deduplicated only if received within 48 hours of the first event with a given event_id; a late duplicate will not be deduplicated against the earlier one.
Fix: Send events in real time or in batches close to real time. If an event is delayed beyond 48 hours, it may still be useful for measurement, but it will not be deduplicated.
Using the Wrong action_source
Mistake: The developer sets action_source to "website" for an event that actually happened over the phone or in a CRM. By using the Conversions API, you agree that the value is accurate, and website events carry extra required fields such as event_source_url and client_user_agent, which are not available for phone or CRM events.
Fix: Choose the value that describes where the conversion actually happened. If the event is a phone call, use "phone_call." If the sale closed on a call, use "phone_call." If the conversion happened in person, use "physical_store." If none fit, use "other." Do not use "website" unless the event actually happened on a website.
Not Refreshing fbp and fbc Values
Mistake: The developer captures the fbp cookie value when the user first visits the site and stores it in the database. Weeks later, the user makes a purchase, and the server sends the old fbp value with the Purchase event. The fbp value has changed in the meantime, so the event cannot be matched correctly.
Fix: Refresh fbp and fbc values regularly if you send them via the Conversions API. Capture the current values from the cookie at the time of the event, not from a stored value. If you cannot access the current cookie value, consider using external_id instead of fbp for matching.
Sending Invalid Parameter Combinations
Mistake: The developer sends only city, state, zip, and gender with an event, assuming that is enough to match the user. Meta considers events with only those broad combinations invalid, and the event is not matched.
Fix: Include at least one high-quality identifier such as email, phone, or IP address to improve the chance of matching. Review the parameter priority ranking in Meta's Business Help Center article on Event Match Quality and include as many high-priority and medium-priority parameters as you can collect lawfully and with proper consent.
A 30-Day Rollout Plan
Here is a week-by-week plan to implement the Conversions API and verify that signals are clean:
- Week 1: Build the event map. List all business moments that matter, map them to Meta standard event names, choose the optimization event, decide where each event fires, assign value and currency, and name the source of truth for each conversion. Document the map in a spreadsheet. Share it with your developer, your CRM administrator, and anyone else who will implement or maintain the integration.
- Week 2: Choose the setup path and configure the integration. If you use Meta-enabled Conversions API, enable it in Events Manager. If you use a partner integration, install and configure the partner app or plugin. If you use a direct integration, create personalized setup instructions in Events Manager, send them to your developer, and have the developer build the integration in a staging or test environment. Do not launch to production yet.
- Week 3: Test and verify. Use the Test Events tool to send test events and confirm that all required parameters are included, customer information is hashed correctly, and event_id is present. Send redundant events from browser and server with the same event_id and event_name, and verify that one is processed and the other is deduplicated. Fix any issues before launching to production.
- Week 4: Launch to production and monitor. Enable the Conversions API integration in production. Monitor event volume in Events Manager daily for the first week. Compare server event counts to browser event counts. Check for drops, spikes, or anomalies. Once live events have flowed for at least 48 hours, check Event Match Quality score and follow the recommended actions in Events Manager. Verify that the optimization event appears in Ads Manager and can be selected in campaigns. Do not make significant campaign changes during this week. Let the delivery system stabilize with the new signals.
After the first 30 days, implement a weekly or monthly review cadence. Review Events Manager and copy weekly event counts into a simple sheet, compare server and browser event counts, check Event Match Quality, and investigate any anomalies. Treat the Conversions API as ongoing infrastructure, not a one-time project.
How SumoGrowth Labs Helps
SumoGrowth Labs is an AI implementation and consulting agency. We handle the setup, the testing, and the ongoing maintenance of the Conversions API so your signals stay clean and your campaigns have accurate data to optimize against.
We start with a signal audit. We review your current pixel setup, your Events Manager data, your Event Match Quality scores, and your campaign structure. We identify gaps: missing events, unmatched events, double-counted events, incorrect action_source values, missing customer information parameters. We document what is broken and what needs to be built.
We build the event map with you. We interview you about your business model, your checkout flow, your CRM, and your conversion goals. We map your business moments to Meta standard events, choose the optimization event, decide where each event fires, and assign value and currency. We document the map and get your approval before we implement anything.
We implement the Conversions API. We choose the setup path that fits your technical resources and your event sources. We configure Meta-enabled Conversions API, partner integrations, or direct integrations. We write the code, set up the deduplication logic, hash the customer information parameters, and test everything in the Test Events tool before we launch to production.
We improve Event Match Quality. We add missing customer information parameters, fix hashing errors, refresh fbp and fbc values, and send events in real time. We monitor the Event Match Quality score and follow Meta's recommended actions until the score stabilizes.
We run QA before launch and after every change. We verify that all required parameters are included, that deduplication is working, that events are matched, and that the optimization event appears in Ads Manager. We do not launch broken integrations.
We keep your CRM, your site, and your ad account aligned. When you update your checkout flow, change your form fields, or add a new CRM workflow, we update the Conversions API integration to match. We implement the change-control rule so that tracking does not break when other systems change.
If you want clean signals before you trust Meta's AI to optimize your campaigns, we can help. We implement the plumbing so the delivery system has accurate data to learn from.
by Darius Gaynor

