

Send the platforms data they can act on.
data they can act on
We do conversion API setup properly: server-side events, clean parameters, correct deduplication against the pixel, consent handled, and identifier coverage verified before we call it done. The result is an ad platform optimising on the conversions that really happened, which is what makes paid social and paid search spend efficient again.
Tell us a little about your brand and we'll be in touch within 24 hours to lock in a time.

THE FOUR LAYERS
Events, identity, deduplication, proof.
deduplication, proof
A conversions API integration is an engineering job with a marketing outcome, and it fails in predictable places: the wrong events, too few match parameters, double counting against the pixel, and nobody checking the result. We build it in that order and validate each layer before moving up.
Server-side events
Identity & match quality
Deduplication & accuracy
Consent & governance
Send the events that mean money.
The starting question is not how to send events but which ones deserve to be sent. We map your funnel to a small set of events the ad platform can optimise toward — a purchase, a qualified lead, a booked appointment, a subscription start — each with its real value, currency and identifiers attached. Micro-events stay separate so they never get optimised as if they were revenue.
Then we send them from a server rather than a browser, which is the whole point of the conversions API: as Meta's developer documentation describes it, the API connects marketing data from your server, website platform, app or CRM directly to the systems that optimise delivery and decrease cost per result. Browser tags are blocked, cleared and lost; a server call is not.
Where the truth lives in your CRM rather than the website — a lead that later qualified, a deal that closed, an order that was refunded — we send that back too. That is the change that stops a lead-gen account buying cheap forms and starts it buying customers.
- Funnel mapped to a small set of optimisable events
- Real values, currency and identifiers on every event
- Micro-events kept separate from revenue events
- Server-side delivery from your platform, server or CRM
- Qualified and closed outcomes sent back from the sales system
13%
lower cost per action for advertisers who added the Conversions API
17.8%
lower cost per result reported by Meta for web CAPI setups
Identifier coverage is the score that moves cost.
An event only helps if the platform can match it to a person. Meta scores that as Event Match Quality, and its best-practice documentation is explicit that the EMQ score reflects how effective your server event's customer information is at matching. Most weak integrations send an email hash and stop; a strong one sends every parameter you are lawfully holding — hashed email and phone, name, city, region, postcode, country, external ID, plus the click identifiers and the browser ID.
Getting those parameters is usually a product problem rather than a tracking problem: a checkout that captures a phone number, a form that normalises country codes, a CRM that stores a consistent customer ID. We work through that list with your developers, then verify the improvement in Events Manager instead of assuming it.
Meta also exposes Additional Conversions Reported through the Dataset Quality API, which quantifies how much your business benefits from running the Conversions API alongside the pixel. We read that number before and after, so the value of the work is measured rather than argued.
- Every lawful match parameter identified and normalised
- Click identifiers and browser IDs passed through correctly
- Hashing done to spec, with raw data never leaving your systems
- Scores measured before and after in Events Manager
1-10
the Event Match Quality scale we tune your setup against
Redundant by design, never double counted.
The correct architecture is deliberately redundant: the browser pixel and the server both send the same conversion, and the platform keeps one. That only works if every event carries a stable event ID and a consistent event name, which is exactly where one-click installers and half-finished integrations fall over. The symptom is a reported conversion count that looks wonderful and a bidding system quietly learning from fiction.
So we test rather than trust. Events are validated in the platform's own test tools, deduplication is confirmed on live traffic, totals are reconciled against your order or CRM data for a full week, and refunds and cancellations are handled so a cancelled order does not stay in the optimisation set forever. Any gap between the platform's number and yours is documented as a known quantity rather than discovered in a quarterly review.
The same discipline extends beyond one platform. Google's equivalent work is enhanced conversions, where Google reports an average 8% incremental ROAS on Search for advertisers bidding to value, across 99 conversion lift studies run between April 2024 and April 2025. We implement both from one clean event layer instead of two competing ones.
- Stable event IDs and consistent naming across pixel and server
- Deduplication verified on live traffic, not assumed
- Totals reconciled against orders or CRM for a full week
- Refunds and cancellations fed back into the data
- Google enhanced conversions built from the same event layer
8%
incremental ROAS Google reports for enhanced conversions on Search
Compliant by construction, not by hope.
Server-side tracking is not a way around consent, and any agency presenting it that way is selling you a liability. We implement consent properly: signals respected on the server as well as in the browser, restricted data categories excluded, data processing options set where regional rules require them, and health-related or otherwise sensitive parameters never sent. Everything is documented so your legal team can read what is happening rather than take our word for it.
Governance matters because integrations rot. Platforms deprecate API versions, a checkout release drops a field, a plugin update changes an event name, and a silent failure can burn a month of budget. We monitor event volume, scores and error rates continuously, alert on drops, and keep the integration on a supported API version.
You own all of it. The code, the container, the server infrastructure and the documentation sit in your accounts, and the setup is conventional enough that another engineer can pick it up without us.
- Consent respected server-side, not bypassed
- Sensitive and restricted parameters excluded by design
- Data processing options configured for regional rules
- Alerting on event volume, error rate and score drops
- Everything documented and owned by you
Yours
Code, infrastructure and documentation stay in your accounts
Scores and deduplication checked in the platform, not assumed
You own the code, infrastructure and documentation
Weekly working session with your developers
Long-term lock-ins
We made the difference for those brands
01 — The challenge
The platform reports conversions your finance team cannot find.
Ad spend is up, the reported conversions look healthy, and the sales system knows nothing about most of them. Or the reverse: the business is growing while the platform claims almost nothing worked, so bidding has no idea what to optimise toward.
“Our pixel says one thing, our orders say another, and we are bidding on whichever one shouts loudest.”
Both symptoms come from the same cause: an event layer nobody engineered. A pixel blocked by browsers and privacy tooling, a one-click integration double counting purchases, three match parameters where twelve were available, no closed-won signal coming back from the CRM. The fix is measurable rather than theoretical — Meta reports that advertisers with the pixel who set up the Conversions API saw on average 13% lower cost per action, and its April 2026 figures, reported by PPC Land, put web CAPI setups at 17.8% lower cost per result than accounts without one. That gain comes from doing the integration properly, not from switching it on.
02 — Our approach
Engineer the event layer, then prove it works.
We audit what you send today: which events fire, from where, with what parameters, and how far the platform's totals sit from your orders or CRM. Then we design a small event set that maps to money, with real values, currency and identifiers, and keep micro-events out of the optimisation. Delivery moves server-side from your platform, server or CRM, running redundantly with the pixel and deduplicated on a stable event ID. We add every match parameter you lawfully hold, normalise and hash it to spec, and tune until the score is verified in the platform rather than assumed. Consent is respected server-side and sensitive parameters are excluded by design. Finally we reconcile a full week against your source of truth, wire alerting on volume, errors and match quality, document everything in your accounts, and re-measure the cost per result the work was supposed to improve.
03 — What we did
Four phases from audit to proven lift.
Audit, build, tune and prove — with your developers in the loop and a written before-and-after on the score, reported conversions and cost per result.
Week 1 / Audit
Measure the gap before touching anything
Current events, parameters and scores documented, then platform totals reconciled against your orders or CRM so the size of the problem is a number.

Weeks 2-3 / Build
Server-side events, deduplicated by design
A small optimisable event set delivered server-side with real values, running redundantly with the pixel on stable event IDs and consistent naming.

Weeks 3-4 / Tune
Raise the score parameter by parameter
Every lawful identifier added, normalised and hashed to spec, with consent respected server-side and the score verified in the platform after each change.

Ongoing / Prove
Reconcile, alert, then re-measure cost
A full week reconciled against your source of truth, alerting on volume and errors, and a written before-and-after on reported conversions and cost per result.

WHAT YOU GET
Deliverables your developers will approve.
developers will approve
Built in your own accounts and infrastructure, documented as we go, conventional enough for any engineer to maintain, and yours to keep.
Tracking and event audit
Every current event, parameter and integration documented, with the gap between platform totals and your own data quantified.
Server-side event delivery
Conversions sent from your platform, server or CRM with real values and currency, built to survive browser and privacy restrictions.
Identifier coverage tuning
Every lawful identifier added, normalised and hashed to spec, then tuned until the platform's own score confirms the improvement.
Deduplication and reconciliation
Stable event IDs across pixel and server, deduplication proven on live traffic, and totals reconciled against your source of truth.
Consent and compliance setup
Consent respected server-side, restricted parameters excluded by design, and data processing options configured for your regions.
Monitoring and before-after report
Alerting on event volume, errors and scores, plus a written before-and-after on conversions and cost per result.
HOW WE WORK
Operating standards, not promises.
Operating standards

Built on trust. Proven by results.
We partner with SMBs and Fortune 500 companies to deliver more than reach — we bring clarity, execution, and measurable outcomes. Every successful partnership starts with a strong culture fit and a shared drive to grow.








CASE STUDIES
Case studies
Video Ads
Static Ads






FAQ
What teams ask us first.
What is the Conversions API and why does the setup matter so much?
It is the server-to-server route for sending conversions to an ad platform, instead of relying on a browser tag that can be blocked, cleared or simply never fire. Meta's documentation describes it as connecting your server, website platform, app or CRM data to the systems that optimise delivery and decrease cost per result. The setup matters because the API rewards precision: the right events, the maximum lawful match parameters, correct deduplication with the pixel, and consent handled properly. Done well it is one of the highest-return pieces of engineering in a paid account; done casually it feeds the bidding system double-counted noise.
How much improvement should we actually expect?
We prefer published numbers to promises. Meta reports that advertisers running the pixel who added the Conversions API saw on average 13% lower cost per action, and its April 2026 figures — reported by PPC Land — put accounts with a web CAPI setup at 17.8% lower cost per result than accounts without one. On the Google side, enhanced conversions is credited with 8% incremental ROAS on Search for value bidders across 99 lift studies. Your own gain depends on how much signal you are currently losing, which is exactly what the audit measures before we quote the work.
Is the one-click or plugin integration good enough?
It is a reasonable floor and a poor ceiling, and we will happily tell you when it is all you need. Automatic integrations typically send a thin set of events with a handful of match parameters, name events inconsistently with your pixel, and leave deduplication to chance — which is how reported conversions end up inflated. They also know nothing about what happened after the form: the qualified lead, the closed deal, the refund. The work worth paying for is the part a plugin cannot do, so we usually keep the simple integration running while we build the proper one, then switch cleanly with deduplication verified.
What is Event Match Quality and what is a good score?
It is Meta's 1-10 rating of how well your server events can be matched to real accounts, and its best-practice guidance is explicit that the score reflects how effective your customer information is at matching. Below about 6 the platform is guessing; above 8 it has what it needs. Improving it is mechanical rather than mysterious: send every identifier you lawfully hold, normalise formats, hash to spec, and pass the click and browser identifiers through correctly. Meta also exposes Additional Conversions Reported, so the benefit of the integration can be read as a number rather than debated.
Will server-side tracking let us ignore consent or privacy rules?
No, and we would not build it that way. Server-side delivery changes where an event is sent from, not whether you were allowed to send it. Our setups respect consent signals on the server as well as in the browser, exclude restricted and sensitive categories by design, and configure data processing options where regional rules require them. Raw customer data stays in your systems; only hashed identifiers leave. We document the whole flow so your legal or privacy team can review exactly what is sent and on what basis, which is a much better position than discovering it during an audit.
Will this double count our conversions?
Not when it is engineered correctly, and this is the most common failure we are called in to fix. The intended architecture is redundant on purpose: the browser and the server both send the conversion, and the platform keeps one because both carry the same stable event ID and event name. We verify deduplication on live traffic rather than trusting the setup, then reconcile a full week of platform totals against your orders or CRM so any remaining difference is a known, explained quantity. Refunds and cancellations are fed back too, so cancelled revenue does not keep teaching the bidding system.
Can you send offline conversions and CRM outcomes as well?
Yes, and for lead-generation accounts it is usually the single highest-value part of the project. Sending the qualified lead, the booked appointment or the closed deal back to the platform lets bidding optimise toward customers instead of cheap form fills, which is a different account within a month or two. We map the stages that genuinely predict revenue, assign values to them, and automate the feed from your CRM rather than relying on manual uploads. Where the reporting side also needs rebuilding, our analytics team handles that in the same engagement.
How does this fit with GA4, Google Ads and other platforms?
One event layer, many destinations. We define the conversions once, with one set of definitions and values, then feed Meta's Conversions API, Google enhanced conversions and offline imports, TikTok's Events API, LinkedIn, Microsoft and whichever others you buy — plus GA4 for analysis. That is how you avoid the common mess of four platforms counting four different numbers with no shared definition. It also means adding a new channel later is a configuration task rather than another integration project.
What happens if the integration breaks later?
You find out from an alert rather than from a bad month. Integrations do degrade: platforms deprecate API versions, a checkout release drops a parameter, a plugin update renames an event. We monitor event volume, error rate and scores continuously and alert on meaningful drops, keep the integration on a supported API version, and review it whenever your site or CRM changes materially. Because everything is documented and conventional, your own developers can also diagnose it — we build so that you are never dependent on us to keep measuring.
What do you need from us to set up the Conversions API?
Less than most teams expect, and we keep the list short on purpose. Partner access to the ad account and the Facebook Business Manager or Google Ads account; the dataset or pixel we will be sending to, plus permission to create an access token for it; access to your tag manager container; and a short session with whoever owns the website, app or CRM so we can agree how events will be sent. If you already run a server-side container we will use it. We create the tokens inside your own business settings rather than ours, so nothing we build depends on a Web Tonic account, and we send a written access checklist before the first call so nobody has to hunt for it live.
Can our own team follow the steps and do this in-house?
Yes, for a straightforward setup, and we are happy to help you get there — a lot of our work is training an in-house team rather than replacing it. The broad steps are: open Events Manager, create or select the dataset, generate an access token, decide which events to send and with which parameters, add the server integration, set a stable event ID so the browser and server copies deduplicate, then verify in the test tools before trusting anything. Meta's own best-practice documentation is a good reference for that path. Where teams typically want help is the harder half: identifier coverage, CRM feedback, consent handling and reconciliation against real orders.
Do you also run the campaigns that use this data?
We can, and the loop closes faster when the team reading the signal is the team spending the budget — our paid social and paid search teams work from the same event definitions. It is equally fine to buy the measurement engineering on its own while another agency buys your media; we hand over the documentation, brief their team, and report honestly on the performance the cleaner signal produces. Good measurement should be useful to whoever is running the account.









































.webp)
.webp)


