Event contract
Map the actions, standard or custom event names, essential parameters and the precise point at which a lead or purchase is confirmed.
Meta event measurement
Build Meta browser and server events that work together.
Set up the events Meta should receive from your website, test browser and server delivery where appropriate, and check that one action does not become two reported events.
Signals that need a closer look
The point is an event you can explain and test, within the limits of consent, browsers and available site data.
- A browser event exists but critical purchase or lead details are missing.
- Pixel and server events both arrive, yet deduplication cannot be confirmed.
- The same event fires on a button click and again after a confirmed action.
- Changes to checkout, consent or an integration leave Meta Events Manager diagnostics unresolved.
What the integration includes when appropriate
We select the delivery route that fits your site and the agreed events. CAPI is not required merely because a Pixel exists.
Browser event
Review or configure the Meta Pixel path and its triggers, values and consent handling for the scoped journeys.
Server event
Implement Conversions API through an appropriate supported integration or server path when the site and permissions allow it. Identify hosting and developer dependencies.
Matching and deduplication
Use the corresponding event name and event ID across browser and server copies of one action. Check that retries and distinct purchases use the correct IDs.
How a paired event is validated
This is a test contract, not a sample client event. Fields and user data depend on the chosen integration and consent state.
- event_name
- The same named business action in both delivery paths.
- event_id
- A shared ID for the same action; a distinct action needs its own ID.
- Parameters
- Scoped value, currency or content fields checked against the confirmed action.
- Diagnostics
- Test Events and Events Manager checks for delivery, matching and deduplication.
QA beyond the successful test event
- Trigger one scoped lead or purchase and inspect browser and server payloads in the test tools.
- Check shared event_name and event_id, retries, duplicate triggers and different actions.
- Inspect available Events Manager diagnostics and record unresolved warnings or missing parameters.
- Test relevant consent choices and verify that the implementation respects the site's privacy rules.
Implementation and handoff
- 01
Decide
Select the events and whether Pixel alone or a browser/server pair fits the site and scope.
- 02
Connect
Configure the selected Pixel and CAPI routes with agreed parameters and event ID handling.
- 03
Verify
Run confirmed and failed user paths, inspect test events and review duplicate and matching diagnostics.
- 04
Transfer
Document integration ownership, consent boundaries, evidence, dependencies and future test steps.
What you receive
Event mapping
A scoped list of actions, trigger points, parameters and delivery routes.
Configured Meta signals
Pixel and, where justified, Conversions API implementation with paired event ID handling.
Test record
Reproducible test journeys, Test Events observations and diagnostics, including any unresolved limits.
Handoff
Notes on ownership, consent, retesting and dependencies on a third-party integration or server.
Access and prerequisites
Work takes place in accounts you control and depends on a testable site journey.
- Meta Business and Events Manager access for the relevant dataset and Pixel, plus access to the existing integration.
- GTM or website access and developer support if browser events or server requests require site changes.
- A test lead or purchase path, the applicable consent implementation and approval for any production changes.
What this work does not promise
CAPI cannot guarantee complete attribution, recover every blocked event or bypass privacy restrictions. Ad campaign, audience and creative audits, a general server-side tracking architecture and ongoing platform management are separate projects.
Use the documented test journey after site changes and monitor diagnostics. If multiple platforms or a broader data model need server infrastructure, scope that architecture separately.
- Define core GA4 and GTM events Establish the website measurement contract
- Plan cross-system Analytics Infrastructure Connect more than Meta events
- Design a broader server tracking layer Route events beyond Meta with explicit ownership
- Validate Shopify purchase events Check store events before Meta delivery
- Diagnose Meta campaigns and creative When ad performance needs a wider review than event delivery
Questions about Pixel and CAPI
What is the difference between Pixel and Conversions API?
Pixel sends browser-side events. CAPI sends events through a server integration. Either route needs a defined business action and validation; using both requires a reliable pairing strategy.
Does every site need both?
No. The choice depends on existing collection, site capabilities, privacy requirements and the outcomes being measured. We agree on the delivery path before implementing it.
What does event_id do?
It identifies one action across browser and server copies. Together with the event name, it supports deduplication; a new action needs a new ID.
Which parameters and matching data are needed?
Parameters follow the event and what the site can reliably supply. Additional matching data is considered only when available, appropriate and permitted by consent and privacy requirements.
How will you know deduplication works?
We reproduce the action, inspect browser and server test events, compare IDs and names, and review Events Manager diagnostics. Any unresolved warning stays in the handoff.
Does CAPI fix attribution or require a server-side GTM project?
It does not make attribution perfect. A suitable existing integration may be enough; broader server-side infrastructure is scoped separately if the site and multiple destinations require it.
Start with the event
Make Meta event delivery testable
Tell me which leads or purchases matter, how events are currently sent and what Events Manager reports. We can choose a fitting Pixel and CAPI scope.