CAPI Troubleshooting: Fixing Conversions API Matching Problems

Key Takeaways

• A conversions API is only as good as its match quality — how well the platform can match your server-sent conversion data to the users who saw your ads.
• When CAPI underperforms, the cause is almost always poor match quality, so troubleshooting CAPI means diagnosing and fixing what degrades matching.
• The main causes of poor matching: insufficient or low-quality customer data, formatting and hashing errors, deduplication problems, and implementation issues.
• Sending more and better customer identifiers (properly formatted and hashed) improves matching, because the platform matches using customer information.
• Deduplication (shared event IDs between browser and server events) prevents the double-counting that undermines a browser-plus-CAPI setup.
• Diagnose by checking your match quality metric, identifying the cause, and fixing the specific data, deduplication, or implementation issue.

Why Match Quality Is the Metric That Matters

A conversions API sends your conversion data server-to-server from your systems to the ad platform, which improves signal resilience — but the value of that data depends entirely on the platform being able to match it to the users who saw your ads, because a conversion the platform cannot match to an ad interaction cannot be attributed and cannot inform optimization well. This is why match quality — how well the platform can match the conversion data you send to the users and ad interactions it knows about — is the metric that matters most for CAPI: a conversions API with poor match quality is sending data the platform cannot fully use, so it delivers only a fraction of its potential benefit, while a conversions API with good match quality is sending data the platform can match and use, delivering the complete, well-attributed signal that makes CAPI worth implementing.

The reason matching is necessary is that the platform needs to connect the conversion you report (server-side, from your systems) to the user who saw or clicked your ad (which the platform knows about from the ad interaction), and it does this matching using the data you send with the conversion — customer information (in hashed, privacy-safe form) and other signals that let it identify which user and ad interaction the conversion corresponds to. So the conversion data you send server-side is only useful for attribution and optimization to the extent the platform can match it to an ad interaction, which depends on the matching data you provide being sufficient and correct. Match quality measures how well this matching is working, which is why it is the key CAPI metric.

This means that troubleshooting a underperforming CAPI is fundamentally about diagnosing and improving match quality, because when CAPI is not delivering its expected benefit, the cause is almost always that the match quality is poor — the platform cannot match enough of the conversion data you are sending. A conversions API that is technically sending data but has poor match quality is failing at its core job (delivering matchable conversion signal), so the troubleshooting focus should be on why the matching is poor and how to improve it, rather than on other aspects of the setup. The platforms provide match-quality metrics precisely because this is the key indicator of whether your CAPI is working, so checking and improving match quality is the center of CAPI troubleshooting. Understanding that match quality is the metric that matters — that CAPI's value depends on the platform being able to match the data you send — is the foundation for troubleshooting it, because it directs your attention to the matching, which is where CAPI problems almost always live.

The Main Causes of Poor Matching

Poor CAPI match quality has a handful of common causes, and knowing them lets you diagnose which is degrading your matching so you can fix it. The first and most common is insufficient or low-quality customer data sent with events — because the platform matches using customer information, sending too little or poor-quality identifying data limits how well it can match. If you send only minimal customer data (or data that is often missing or low-quality), the platform has less to match on, so match quality suffers; sending more identifiers, of higher quality, more consistently, gives the platform more to match on and improves match quality. This is often the biggest lever, because match quality depends directly on the quantity and quality of the matching data you provide, so insufficient or poor customer data is a frequent and fixable cause of poor matching.

The second common cause is formatting and hashing errors — the customer data must be sent in the correct format and hashed correctly (in the privacy-safe way the platform requires), or the platform cannot match it even if the data itself is good. If the data is incorrectly formatted (wrong format, malformed) or incorrectly hashed (wrong hashing, or not matching how the platform expects), the matching fails despite the underlying data being present and correct, because the platform cannot process the improperly-formatted or improperly-hashed data for matching. This is a technical implementation issue that can silently undermine match quality — the data is being sent, but in a form the platform cannot match — so correct formatting and hashing is essential, and errors in it are a common cause of poor matching that a data-quality check would not catch.

The third common cause is deduplication problems, which in a browser-plus-CAPI setup cause double-counting that corrupts your signal, and the fourth is implementation issues where events do not fire correctly or are missing data. Deduplication problems arise when you run both browser tracking and CAPI (as most do, for resilience) but do not properly deduplicate them with shared event IDs, so the same conversion is counted twice — which, while distinct from match quality per se, is a core CAPI problem that corrupts the signal and must be fixed alongside matching (through proper event-ID deduplication). Implementation issues — events not firing when they should, firing incorrectly, or missing the data needed for matching — directly degrade both the completeness and the matchability of your signal. These four causes — insufficient/low-quality customer data, formatting and hashing errors, deduplication problems, and implementation issues — are the main things that undermine CAPI, so troubleshooting means identifying which of them is degrading your setup and fixing it, which the following sections cover.

Diagnosing Match-Quality Problems

Diagnosing CAPI problems starts with checking your match quality metric, because the platforms provide a match-quality indicator that tells you how well your matching is working and is the primary signal that you have a problem to fix. If your match quality is low, you have a matching problem to diagnose and fix; if it is high, your matching is working well and any CAPI underperformance may be due to other factors. So the first diagnostic step is to check the match quality metric the platform provides, which tells you whether matching is the problem and gives you a baseline to improve against. A low match-quality score is the signal that your CAPI is not matching well and that the troubleshooting should focus on the matching.

Once you know match quality is poor, the next step is identifying which of the causes is responsible, which involves examining your CAPI setup against the common causes. Check the customer data you are sending: are you sending enough identifiers, of good quality, consistently? Insufficient or low-quality data is often the culprit, so examining what data you send (and how complete and high-quality it is) is a key diagnostic. Check the formatting and hashing: is the customer data being sent in the correct format and hashed correctly? Formatting and hashing errors silently break matching, so verifying that the data is correctly formatted and hashed (against the platform's requirements) is essential. Check the deduplication: if you run browser and CAPI, are they properly deduplicated with shared event IDs? And check the implementation: are events firing correctly and completely?

The diagnosis should be systematic, checking each potential cause against the platform's requirements and tools, because the causes can combine and the fix depends on the actual cause, so a thorough diagnosis that identifies what specifically is degrading your match quality is what enables an effective fix. The platforms provide diagnostic tools and guidance (match-quality metrics, event-testing tools, documentation on requirements) that help you check your setup against the requirements and identify problems, so using these to systematically examine your customer data, formatting/hashing, deduplication, and implementation is how you find the cause. A diagnosis that identifies the specific cause (or causes) of your poor match quality — insufficient data, formatting/hashing errors, deduplication problems, or implementation issues — is what lets you apply the right fix, rather than guessing. So the diagnostic process is: check the match quality metric to confirm a problem, then systematically examine your setup against the common causes to identify what is degrading the matching, using the platform's tools and requirements as your guide — which is the foundation for fixing the problem effectively.

Fixing the Data and Formatting Issues

The most common and highest-impact CAPI fixes address the customer data and its formatting, because insufficient/low-quality data and formatting/hashing errors are the most frequent causes of poor match quality, so fixing them often produces the biggest improvement. To fix insufficient or low-quality customer data, send more and better identifying data with your conversion events — more of the identifiers the platform can match on, of higher quality (accurate, complete, consistent), so the platform has more and better data to match on. This might mean capturing and sending additional customer identifiers, improving the quality and completeness of the data you capture, or ensuring the data is sent consistently rather than being frequently missing — all of which give the platform more to match on and improve match quality. Because match quality depends directly on the matching data you provide, enriching that data is often the most effective single improvement.

To fix formatting and hashing errors, ensure the customer data is sent in the exact format and hashed in the exact way the platform requires, verifying against the platform's specifications, because even good data cannot be matched if it is improperly formatted or hashed. This means checking your implementation against the platform's requirements for how the customer data must be formatted and hashed, and correcting any discrepancies — ensuring the data is normalized and formatted correctly before hashing, hashed with the correct algorithm and process, and sent in the form the platform expects. Because formatting and hashing errors silently break matching (the data is present but unmatchable), fixing them can produce a large improvement in match quality by making previously-unmatchable data matchable, and it is a common fix because these errors are easy to make and not obvious without checking against the requirements.

The discipline in fixing data and formatting issues is to verify against the platform's specifications and to confirm the fix improves match quality, because the requirements are specific and the fixes must meet them exactly to work. The platforms provide detailed specifications for what customer data to send and how to format and hash it, so fixing these issues means implementing according to those specifications precisely, and then confirming (via the match quality metric) that the fix improved the matching. Getting the data richer and better-quality, and the formatting and hashing exactly correct, addresses the two most common causes of poor match quality, so these fixes are often where the biggest CAPI improvements come from — a conversions API that sends rich, high-quality, correctly-formatted, correctly-hashed customer data matches far better than one sending sparse, low-quality, or improperly-formatted data. Fixing the data and formatting issues is thus the highest-leverage part of CAPI troubleshooting for most setups, and it is where the troubleshooting should focus first, because it addresses the most common causes of the poor match quality that undermines CAPI.

Fixing Deduplication and Implementation Issues

Beyond the data and formatting fixes, the other core CAPI issues to fix are deduplication problems and implementation issues, both of which corrupt or degrade the signal in ways that undermine CAPI even when the matching data is good. Deduplication is essential in a browser-plus-CAPI setup because, without it, the same conversion reported by both the browser and the server is counted twice, so fixing deduplication means implementing shared, unique event IDs between the browser and server reports of each conversion, so the platform recognizes them as the same event and counts it once. This is the standard fix for the double-counting that a browser-plus-CAPI setup causes, and it is essential because running both browser and CAPI (as most do for resilience) without deduplication produces duplicate conversions that corrupt both reporting and optimization. So implementing proper deduplication is a core part of getting a browser-plus-CAPI setup right, alongside the matching improvements.

Implementation issues — events not firing correctly, firing incompletely, or missing data — degrade CAPI by making the conversion signal incomplete or unmatchable, so fixing them means correcting the implementation so events fire correctly and completely with the data needed for matching. This means ensuring your CAPI implementation fires the conversion events when it should (not missing conversions), fires them correctly (not malformed), and includes the necessary data (the customer identifiers and other required fields) for matching — correcting whatever implementation errors are causing events to be missing, malformed, or incomplete. Because these implementation issues directly reduce the completeness and matchability of your signal, fixing them restores the signal that the errors were degrading, which improves both the completeness of your conversion data and its match quality.

The overall approach to fixing CAPI is to address each identified cause with its appropriate fix and verify the improvement, so that the conversions API delivers the complete, well-matched, deduplicated signal that makes it valuable. For poor match quality, fix the data (send more and better identifiers) and the formatting/hashing (correct to the platform's specifications); for double-counting, implement proper deduplication (shared event IDs); for incomplete or unmatchable signal, fix the implementation (events firing correctly and completely with the needed data). Then verify, via the match quality metric and by confirming the signal is complete and deduplicated, that the fixes worked. A conversions API troubleshot this way — rich, correctly-formatted, correctly-hashed customer data for good matching; proper deduplication to prevent double-counting; and correct implementation for complete, matchable events — delivers the resilient, complete, well-attributed conversion signal that CAPI is supposed to provide, which is what makes it worth implementing. Troubleshooting CAPI is fundamentally about restoring good match quality and clean, complete signal, and these fixes — addressing the data, formatting, deduplication, and implementation — are how you do it, turning an underperforming conversions API into one that delivers its full value. This measurement rigor is foundational to serious performance marketing.

Keeping CAPI Healthy Over Time

CAPI match quality and signal health are not set-once-and-forget but require ongoing attention, because tracking setups change, data capture can degrade, and new issues can arise, so keeping CAPI healthy over time is part of getting lasting value from it. The match quality metric should be monitored over time, not just checked once, because it can degrade if the data you capture changes, if formatting or implementation drifts, or if other issues emerge — so monitoring match quality as an ongoing health indicator lets you catch degradation early and fix it before it substantially undermines your measurement. A CAPI setup that had good match quality when implemented can degrade over time if not monitored, so ongoing monitoring is what keeps it healthy.

Maintaining the data quality that drives match quality is an ongoing discipline, because the customer data you capture and send can degrade (data capture issues, changes in what you collect, quality problems creeping in), and match quality depends on that data, so keeping the data rich, high-quality, and correctly-formatted over time maintains the match quality. This means periodically verifying that you are still capturing and sending good customer data, that the formatting and hashing remain correct, and that the data quality has not degraded — maintaining the data foundation that good matching depends on, rather than assuming it stays good after the initial setup. Data quality tends to degrade without attention, so maintaining it is an ongoing part of CAPI health.

The overall discipline is to treat CAPI as an ongoing measurement system to maintain, not a one-time implementation, monitoring match quality and signal health and addressing issues as they arise, so that CAPI keeps delivering its full value over time. This means monitoring the match quality metric, maintaining the data quality and correct formatting, keeping the deduplication working as the setup evolves, and correcting new implementation issues that emerge — an ongoing maintenance discipline that keeps the conversions API healthy. Because CAPI is a foundational part of modern measurement (delivering the resilient, complete conversion signal that browser tracking increasingly cannot), keeping it healthy is important, and the ongoing discipline of monitoring and maintaining match quality and signal health is what ensures it keeps delivering rather than degrading. Troubleshooting CAPI, then, is both a matter of fixing problems when they arise (diagnosing and fixing poor match quality and signal issues) and of maintaining health over time (monitoring and maintaining the match quality and data that CAPI depends on) — and doing both well is what keeps your conversions API delivering the complete, well-matched signal that makes it a valuable foundation of your measurement rather than an underperforming setup that quietly degrades.

Methodology & Fairness

A note on how to read this. This is an educational guide published by Fluxsy, a performance marketing partner, so weigh our perspective accordingly. Platform mechanics and privacy rules change frequently; verify the specifics described here against the current official documentation before you implement. Where we name tools, platforms or companies we describe them by their genuine public positioning, not as endorsements. We have avoided inventing statistics, benchmarks or results — the durable value here is the framework and the reasoning, which hold even as the specific implementation details move. Measure against your own data before concluding, because your results depend on your stack, your market and your configuration.