How to Integrate Meta Conversions API (CAPI) Events: A Step-by-Step Guide

Quick answer: To integrate Meta Conversions API events: pick an integration method, get a dataset (Pixel) ID and access token, plan your events, build a payload with hashed user_data, send it to the Graph API, deduplicate with the Pixel using a shared event_id, add CRM lead stages, test with test_event_code, then monitor Event Match Quality and Diagnostics.

If you run ads on Facebook or Instagram, the Meta Pixel alone no longer tells the full story. Browsers block scripts, pages fail to load, and the most valuable moments (a qualified lead, a booked call, a closed sale) often happen far away from your website.

The Meta Conversions API, usually called CAPI, fixes that gap. It lets your server or CRM send events straight to Meta.

This guide walks you through the whole process, from choosing an integration method to sending your first event, testing it, and keeping it healthy. Everything here is checked against Meta's official developer docs and Business Help Center as of 4 November 2026. The current Graph API version at the time of writing is v26.0 (released 29 July 2026).

Related read: If you want a hands-on, low-code build using a spreadsheet, see our Meta Conversions API + Google Sheets tutorial. This article is the general guide and does not repeat that tutorial.

What is the Meta Conversions API?

Meta describes the Conversions API as a way to create a connection between your marketing data (website, app, offline, CRM and messaging events) and Meta's systems. Those systems use the data to optimise ad targeting, lower cost per result and measure outcomes.

In a direct integration, your server sends an HTTP POST request to Meta's /events endpoint. Each request contains one or more events, such as Lead or Purchase, plus customer information that helps Meta match the event to a person.

The key idea is simple: you decide which events to send and when, and they travel server to server, not through the visitor's browser.

Pixel vs Conversions API

The Meta Pixel is JavaScript that runs in the browser. The Conversions API runs on your server. They are not rivals. Meta recommends using both together in what it calls a redundant setup.

Meta's best practices say the Conversions API helps you share website events the Pixel may lose because of network issues or page loading errors. It can also share events that happen offline or later, which the Pixel cannot capture.

Step 1: Choose your integration method

Meta offers several ways to connect. They differ in effort, cost and flexibility.

1. Conversions API with Meta (one click in Events Manager). If you already have a Pixel and only need website events, Meta's Gateway docs note that you can turn this on in Events Manager without hosting or maintaining anything.

2. Conversions API Gateway. A self-serve option configured in Events Manager. It runs on a server instance in your own cloud account (Meta lists AWS EKS, AWS ECS Express and GCP). It receives Pixel events and forwards them to the Conversions API, and it generates the event_id for deduplication automatically. The only cost is your cloud resources or partner fees.

3. Partner integrations. Many platforms, CRMs and tools have built-in Conversions API connections. You pick the partner in Events Manager and follow its instructions. For lead-ad CRM events, Meta's guide lists Zapier, a Salesforce app and other partners as no-code paths.

4. Direct integration (the API itself). Your developers send events to the Graph API. This gives you full control over which events, fields and timing you use. Meta's developer documentation focuses on this method.

Quick rule of thumb:

• Only website events, little dev time: one-click setup or the Gateway.
• Your platform already has a connector: use the partner integration.
• Custom funnels, CRM stages, offline sales or several systems: go direct.

If you run Meta lead ads and want CRM-stage events without code, a tool like LeadSmart, which I built as a verified Meta Tech Provider, lets you map your own lead-quality labels (for example "Qualified" or "Site visit booked") to Conversions API events. The rest of this guide shows what happens under the hood either way.

Step 2: Complete the prerequisites

You need three things before you send a single event.

1. A Meta business portfolio (Business Manager)

Meta's docs now call it Meta Business Suite (many people still say Business Manager). Your Pixel, ad accounts and system users live here. If you do not have one, create it first through the Business Help Center.

2. A dataset or Pixel ID

The Conversions API sends events to a Pixel ID (Meta also calls this a dataset). If you already have a Pixel on your website, use the same Pixel ID for browser and server events. You can find it in Events Manager under your data source.

For lead-ad CRM events, Meta suggests creating a separate CRM dataset (Events Manager > Connect Data Sources > CRM), so CRM events do not mix with web events.

3. An access token

Meta lists two ways to get one:

• Events Manager (recommended): Choose your Pixel, open Settings, find the Conversions API section and click Generate access token under "Set up manually". This link only appears for users with developer privileges for the business. Meta then creates a Conversions API app and system user for you. No App Review or permission requests are needed.
• Your own app: In Business Settings, assign the Pixel to a system user and click Generate Token.

Meta notes that tokens created this way (from v12.0 onward) can be used with all available Graph API versions.

Keep the token secret. Store it in an environment variable or secrets manager, never in front-end code.

Step 3: Plan your events

Good planning saves weeks of clean-up. Write down every event, where it fires, and who owns it.

Standard events

Meta's standard events have fixed names. Use them exactly as written (they are case sensitive). Common ones for lead and service businesses:

Other standard events include ViewContent, Search, AddToCart, InitiateCheckout, AddPaymentInfo, StartTrial and Subscribe.

Custom events

If no standard event fits, you can send a custom event name (for example QuoteSent). The event_name field accepts either a standard or a custom event name. Keep names short, consistent and documented.

Lead-ad CRM stages

If you use Facebook or Instagram Instant Forms, your real goal is usually a qualified lead, not just any form fill. With the Conversions API for CRM, event_name is a free-form field that holds your CRM stage. Meta's example funnel is:

1. Initial Lead from Facebook
2. Marketing Qualified Lead
3. Sales Opportunity
4. Converted

Meta asks you to send all stages as they change, including the raw lead stage. Plan at least two stages, and three or more if you can. We cover this flow in Step 7.

A simple event plan

Step 4: Build the event payload

Every request has a data array of event objects. Here are the fields you will use most, as defined in Meta's Server Event Parameters (updated 15 October 2026) and Customer Information Parameters (updated 9 January 2026).

Server event parameters

• event_name (required): A standard or custom event name. Also used for deduplication.
• event_time (required): Unix timestamp in seconds, in GMT, for when the event actually happened. It can be up to 7 days before you send it.
• action_source (required): Where the conversion happened. Allowed values: website, app, email, phone_call, chat, physical_store, system_generated, business_messaging, other. By using the API, you agree this value is accurate.
• event_source_url: The browser URL where the event happened. Required for website events. It should match your verified domain.
• user_data (required): Customer information for matching (see below).
• custom_data (optional): Business data such as value, currency, content_ids or contents.
• event_id (optional but recommended): A unique string you choose. Used with event_name for deduplication. An order number or transaction ID works well.

Other optional fields include opt_out, referrer_url, data_processing_options and customer_segmentation.

Customer information (user_data)

You must send at least one valid user_data field. Some must be hashed with SHA-256, and some must never be hashed.

A few details from Meta's docs that people often miss:

• The IP address and user agent are added automatically to browser events, but you must add them yourself on server events.
• If there is no _fbc cookie, you can build fbc from the fbclid URL parameter. Do not change the case of the fbclid value.
• fbp and fbc values change over time, so refresh them rather than reusing old ones.
• Meta treats some weak combinations as invalid, for example only fn + ge, or only db + client_user_agent.

Step 5: Send your first event

The endpoint is:

POST https://graph.facebook.com/{API_VERSION}/{PIXEL_ID}/events?access_token={TOKEN}

Meta's Conversions API follows the Graph API release cycle, so each version is supported for at least two years. Pin a version (v26.0 today) and upgrade on a schedule.

Sample curl request

# Send one website Lead event to the Conversions API (Graph API v26.0).
# Replace PIXEL_ID and ACCESS_TOKEN. Keep the token on your server only.
curl -X POST "https://graph.facebook.com/v26.0/PIXEL_ID/events" \
  -F 'data=[
    {
      "event_name": "Lead",
      "event_time": 1793800000,
      "event_id": "lead_7f3a9c21",
      "action_source": "website",
      "event_source_url": "https://www.example.com/contact/thank-you",
      "user_data": {
        "em": ["62a14e44f765419d10fea99367361a727c12365e2520f32218d505ed9aa0f62f"],
        "client_ip_address": "203.0.113.10",
        "client_user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "fbp": "fb.1.1596403881668.1116446470",
        "fbc": "fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890"
      },
      "custom_data": {
        "currency": "INR",
        "value": 500
      }
    }
  ]' \
  -F 'access_token=ACCESS_TOKEN'
# Note: event_time must be the real time of the lead in Unix seconds and
# no more than 7 days old when you send it. The em value above is the
# SHA-256 of "john_smith@gmail.com", the example Meta uses in its docs.

Node.js example (Node 18+, no SDK)

// capi-send.js: send a hashed Lead event to Meta's Conversions API.
// Run with: PIXEL_ID=... CAPI_TOKEN=... node capi-send.js
const crypto = require("crypto");

const API_VERSION = "v26.0";              // current Graph API version (Nov 2026)
const PIXEL_ID = process.env.PIXEL_ID;     // your dataset / Pixel ID
const TOKEN = process.env.CAPI_TOKEN;      // keep secret, never ship to the browser

// Hash a value with SHA-256 after normalising it, as Meta requires.
const sha256 = (value) =>
  crypto.createHash("sha256").update(value).digest("hex");

const normaliseEmail = (email) => email.trim().toLowerCase();
// Keep digits only and drop leading zeros. The number must already
// include the country code, for example 919812345678 for India.
const normalisePhone = (phone) => phone.replace(/\D/g, "").replace(/^0+/, "");

async function sendLead({ email, phone, ip, userAgent, fbp, fbc, url, eventId }) {
  const payload = {
    data: [
      {
        event_name: "Lead",
        event_time: Math.floor(Date.now() / 1000), // seconds, not milliseconds
        event_id: eventId,                          // same value as the Pixel's eventID
        action_source: "website",
        event_source_url: url,                      // required for website events
        user_data: {
          em: [sha256(normaliseEmail(email))],      // hashed
          ph: [sha256(normalisePhone(phone))],      // hashed
          client_ip_address: ip,                    // not hashed
          client_user_agent: userAgent,             // not hashed, required for web
          fbp,                                      // not hashed
          fbc,                                      // not hashed
        },
      },
    ],
    // test_event_code: "TEST12345",              // uncomment only while testing
  };

  const res = await fetch(
    `https://graph.facebook.com/${API_VERSION}/${PIXEL_ID}/events?access_token=${TOKEN}`,
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(payload),
    }
  );

  const body = await res.json();
  if (!res.ok) {
    // Log the full error object, including fbtrace_id, for debugging.
    console.error("CAPI error:", JSON.stringify(body.error));
    throw new Error(body.error?.message || "Conversions API request failed");
  }
  console.log("CAPI response:", body); // includes events_received on success
  return body;
}

// Example call with placeholder values.
sendLead({
  email: " Priya.Sharma@Example.com ",
  phone: "+91 98123 45678",
  ip: "203.0.113.10",
  userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
  fbp: "fb.1.1596403881668.1116446470",
  fbc: undefined, // send only when you have a real _fbc cookie or fbclid
  url: "https://www.example.com/contact/thank-you",
  eventId: "lead_7f3a9c21",
}).catch(console.error);

Python example (requests)

# capi_send.py: send a hashed Purchase event to Meta's Conversions API.
import hashlib
import os
import time

import requests

API_VERSION = "v26.0"                     # current Graph API version (Nov 2026)
PIXEL_ID = os.environ["PIXEL_ID"]
TOKEN = os.environ["CAPI_TOKEN"]          # store securely, never in client code


def sha256(value: str) -> str:
    """Return the SHA-256 hex digest of an already normalised value."""
    return hashlib.sha256(value.encode("utf-8")).hexdigest()


event = {
    "event_name": "Purchase",
    "event_time": int(time.time()),       # Unix seconds, GMT
    "event_id": "order_123",              # use your order ID for dedup
    "action_source": "website",
    "event_source_url": "https://www.example.com/checkout/success",
    "user_data": {
        "em": [sha256("priya.sharma@example.com")],  # trimmed + lowercased
        "ph": [sha256("919812345678")],              # digits with country code
        "external_id": [sha256("crm-000981")],       # hashing recommended
        "client_ip_address": "203.0.113.10",         # never hash
        "client_user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    },
    "custom_data": {
        "currency": "INR",                # required for Purchase
        "value": 2499.00,                 # required for Purchase
    },
}

resp = requests.post(
    f"https://graph.facebook.com/{API_VERSION}/{PIXEL_ID}/events",
    params={"access_token": TOKEN},
    json={"data": [event]},               # add "test_event_code" here only when testing
    timeout=10,
)
print(resp.status_code, resp.json())      # check for an "error" object on failure

Prefer an SDK? Meta's Business SDK is available for PHP, Node.js, Java, Python and Ruby, and it hashes user data for you.

Step 6: Deduplicate with the browser Pixel

If the Pixel and the Conversions API both send the same event, Meta needs to know they are one action, not two. Meta's recommended method uses event_id plus event_name.

The rule: the Pixel's eventID must match the server's event_id, and the Pixel's event name must match the server's event_name.

// Browser side: pass eventID as the 4th argument to fbq('track').
// Generate the ID once per action and send the same value to your server.
const eventId = "lead_" + crypto.randomUUID();

fbq("track", "Lead", {}, { eventID: eventId });

// Then include eventId in your form submission so the server can
// send it as event_id in the Conversions API event.

How Meta handles it, per its deduplication docs (updated 28 June 2026):

• If it sees the same event_id + event_name pair from browser and server for the same Pixel within 48 hours, it discards the later copies.
• If both copies arrive about the same time (within 5 minutes), the server event reference says Meta favours the browser event.
• A second method uses fbp and/or external_id with the same event_name, but it mainly works when the browser event arrives first.

Meta's best practices also recommend sending external_id and event_id with all events. And if an event is server only (for example a CRM stage), you do not need deduplication for it.

Step 7: Send lead-ad CRM stages (Conversions API for CRM)

This is where lead-ad businesses get the most value. Instead of telling Meta "a form was filled", you tell Meta which leads turned into real opportunities. That data powers the Conversion Leads performance goal for Instant Forms.

Meta calls this a separate integration from your web setup because the required fields differ.

Is your business a good fit?

Meta's guidelines (updated 27 October 2026):

• You use Facebook or Instagram Lead Ads (Instant Forms).
• You store the 15 to 17 digit Meta lead ID in your CRM.
• You generate at least 200 leads per month.
• You can upload data at least once per day.
• The stage you optimise for happens within 28 days of the lead.
• That stage converts at between 1% and 40%.

Where to find the lead ID

If you receive leads through a Webhook, the ID is in the leadgen_id field. In the Graph API bulk read, it is the id of the lead. In a manual CSV download, it is the first column labelled id. Map it to a field in your CRM before anything else.

The CRM payload

{
  "data": [
    {
      "event_name": "Qualified Lead",
      "event_time": 1793800000,
      "action_source": "system_generated",
      "user_data": {
        "lead_id": 1234567890123456
      },
      "custom_data": {
        "lead_event_source": "Your CRM name",
        "event_source": "crm"
      }
    }
  ]
}

What each field means here:

• event_name: your CRM stage, free form. Send every stage, including the initial lead.
• event_time: when the stage changed in your CRM, in Unix seconds. It must be after the lead was created, or the event may be discarded.
• action_source: always system_generated for Conversion Leads events.
• user_data.lead_id: the highest-priority match key. Not hashed. It must be valid, or Meta rejects the event. If you lack it, send hashed email or phone instead.
• custom_data.lead_event_source: the name of your CRM or tool (for example HubSpot or "In-house CRM").
• custom_data.event_source: always crm.

If an event in Events Manager is missing lead_event_source or event_source, Meta says it will not register as a Conversion Leads event.

CRM tips from Meta's docs

• Upload in real time if you can, or batch hourly or daily.
• When batching, send the history of changes. If a lead changed status 3 times, Meta expects 3 events.
• Do not fake event_time to backfill more than 7 days. Meta warns this can get your backfill discarded.
• Do not switch Pixels after the integration is complete. That restarts training.
• Expect about 1 to 2 days of data validation, then a training period. Meta's timeline shows 2 to 4 weeks, while its FAQ mentions 1 to 2 months before the integration joins the production model.

Step 8: Test with test_event_code

Never debug in production blind. Use the Test Events tool.

1. Go to Events Manager > Data sources > your dataset > Test events.
2. Copy the test code shown (for example TEST12345).
3. Add it as test_event_code at the top level of your request, next to data.
4. Send the event and watch it appear in the Test Events window.

{
  "data": [
    {
      "event_name": "Lead",
      "event_time": 1793800000,
      "event_id": "lead_test_001",
      "action_source": "website",
      "event_source_url": "https://www.example.com/contact",
      "user_data": {
        "client_ip_address": "203.0.113.10",
        "client_user_agent": "Mozilla/5.0 (test)"
      }
    }
  ],
  "test_event_code": "TEST12345"
}

Two important notes from Meta:

• Remove test_event_code before going live.
• Test events are not dropped. They flow into Events Manager and are used for targeting and measurement, so test with your own details and not fake customers.

Meta's Payload Helper tool is also handy. It shows how your payload should look and flags errors before you write any code. For CRM events, the Test Events tool has a CRM channel option where you pick the connected Page and Instant Form.

After going live, events normally show up in Events Manager within about 20 minutes (CRM events within about an hour).

Step 9: Check and improve Event Match Quality

Event Match Quality (EMQ) is a score from 1 to 10 in Events Manager. It shows how well your customer information can match server events to Meta accounts. Meta recommends aiming for 6.0 or higher where possible, and says a higher score can help lower your cost per action.

Where to find it: open your dataset in Events Manager, go to Overview, pick an event, and click its EMQ score for details and tips. Meta notes EMQ is currently available only for web events. Agencies managing many Pixels can pull it with the Dataset Quality API.

How to improve it:

1. Send more match keys. Meta names email, IP address, name and phone as high-quality examples.
2. Always send client_ip_address and client_user_agent on web events. The real visitor IP, not your server's IP.
3. Pass fbp and fbc. Read the cookies at the moment of the event, and build fbc from fbclid when there is no cookie.
4. Normalise before hashing. Lowercase and trim emails. Add the country code to every phone number.
5. Add external_id and use the same format as on the Pixel.
6. Avoid weak combinations that Meta treats as invalid, like gender plus first name only.

Step 10: Monitor in Diagnostics

The Diagnostics tab in Events Manager lists problems with your web, app or offline events.

1. Go to Events Manager and click Data sources.
2. Select your dataset. A red icon means there are critical issues.
3. Open Diagnostics and review active issues.
4. Click Learn how to fix this issue and follow the steps.

If Meta does not detect an issue the next day, it moves it to "Previously detected".

Also check these views on a schedule:

• Overview: events received and the connection method (browser, server).
• Event Freshness: average delay between event_time and upload, from real time to weekly.
• Event Deduplication: what share of events were deduplicated.
• EMQ: match quality per event.

Rules and limits to remember

These come straight from Meta's docs:

• 7-day rule: event_time can be up to 7 days before you send the event. If any event in data is older than 7 days, Meta returns an error for the whole request and processes none of it.
• Physical store exception: for action_source = physical_store, upload within 62 days of the conversion.
• Seconds, GMT: event_time is a Unix timestamp in seconds, in GMT.
• Batch size: up to 1,000 events per request. Meta still recommends sending events as they happen, ideally within an hour.
• No separate rate limit: Conversions API calls count as Marketing API calls. The 1,000 events per request cap is the stated limit.
• Website events need action_source, event_source_url and client_user_agent. Non-web events need only action_source.
• Hashing: contact information must be hashed. Meta's systems are designed not to accept it unhashed. Never hash IP, user agent, fbp, fbc or lead_id.
• Phone numbers must include the country code, even if all your customers are in one country.
• Purchase needs currency and value.
• Retries: send event_id with every event so a retried batch does not double count.
• Accuracy: by using the API, you agree that action_source is accurate to the best of your knowledge.

Privacy and consent

Server-side does not mean "outside the rules". Treat CAPI data with the same care as Pixel data.

• Collect with consent. Only send data you are allowed to share under your privacy policy and local law. In India, that means following the Digital Personal Data Protection Act, 2023. In the EU, GDPR applies.
• Respect opt-outs. If a person has not consented to marketing tracking, do not send their event. Meta also offers an opt_out flag that limits an event to attribution only.
• Hash personal data before it leaves your server, and use HTTPS only.
• Limited Data Use (LDU): for US state privacy laws, Meta supports data_processing_options: ["LDU"] with data_processing_options_country and data_processing_options_state (use 0 and 0 to let Meta geolocate).
• Send only what you need. Do not put sensitive details (health, finances, religion) in custom event names or custom_data.
• Read Meta's terms. The Meta Business Tools Terms and the Privacy and Data Use Guide explain how Meta uses this data.

This is general guidance, not legal advice. Check with your legal team for your market.

Common errors and fixes

Graph API errors come back as an error object with message, code, error_subcode and fbtrace_id. Always log the whole object. Include the fbtrace_id if you contact Meta support.

FAQ

Conclusion

Integrating the Meta Conversions API comes down to a clear order of work:

1. Pick the right method (one-click, Gateway, partner or direct).
2. Get your business portfolio, Pixel ID and access token ready.
3. Plan your events and CRM stages.
4. Build clean payloads with the right hashing.
5. Deduplicate with event_id and event_name.
6. Test with test_event_code, then go live.
7. Keep an eye on EMQ, freshness and Diagnostics.

Start small. Get one event (like Lead) working end to end with good match quality, then add more. For lead-ad businesses, sending CRM stages back to Meta is often the single biggest upgrade, because it teaches the system what a good lead actually looks like for you.

Related read: our Meta Conversions API + Google Sheets tutorial

Sources

All accessed 4 November 2026. "Updated" dates are as shown on each page.

1. Meta for Developers, Graph API Changelog (latest version v26.0, released 29 July 2026): https://developers.facebook.com/docs/graph-api/changelog
2. Meta for Developers, Conversions API: Get Started (updated 28 June 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/get-started
3. Meta for Developers, Using the Conversions API (updated 17 July 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/using-the-api
4. Meta for Developers, Server Event Parameters (updated 15 October 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/parameters/server-event
5. Meta for Developers, Conversions API Parameters (updated 15 October 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/parameters
6. Meta for Developers, Customer Information Parameters (updated 9 January 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/parameters/customer-information-parameters
7. Meta for Developers, fbp and fbc Parameters (updated 9 January 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/parameters/fbp-and-fbc
8. Meta for Developers, Deduplicate Pixel and Server Events (updated 28 June 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/deduplicate-pixel-and-server-events
9. Meta for Developers, Conversions API Best Practices (updated 28 June 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/best-practices
10. Meta for Developers, Verifying Your Setup (updated 24 November 2025): https://developers.facebook.com/docs/marketing-api/conversions-api/verifying-setup
11. Meta for Developers, Conversions API for CRM Integration (updated 27 October 2026): https://developers.facebook.com/docs/marketing-api/conversions-api/conversion-leads-integration
12. Meta for Developers, Conversion Leads Payload Specification: https://developers.facebook.com/documentation/ads-commerce/conversions-api/conversion-leads-integration/payload-specification
13. Meta for Developers, CRM Integration Step 2: Getting Started: https://developers.facebook.com/documentation/ads-commerce/conversions-api/conversion-leads-integration/crm-integration/2-getting-started-with-integration
14. Meta for Developers, CRM Integration Step 3: Developer Implementation: https://developers.facebook.com/documentation/ads-commerce/conversions-api/conversion-leads-integration/crm-integration/3-implementing-the-crm-integration
15. Meta for Developers, How to Find the Meta Lead ID: https://developers.facebook.com/documentation/ads-commerce/conversions-api/conversion-leads-integration/how-to-find-the-lead-id
16. Meta for Developers, Conversion Leads FAQ: https://developers.facebook.com/documentation/ads-commerce/conversions-api/conversion-leads-integration/faq
17. Meta for Developers, Conversions API Gateway: https://developers.facebook.com/documentation/ads-commerce/gateway-products/conversions-api-gateway
18. Meta for Developers, Dataset Quality API: https://developers.facebook.com/documentation/ads-commerce/conversions-api/dataset-quality-api
19. Meta for Developers, Meta Pixel Standard Events reference (updated 16 July 2024): https://developers.facebook.com/docs/meta-pixel/reference
20. Meta for Developers, Graph API: Handling Errors: https://developers.facebook.com/docs/graph-api/guides/error-handling
21. Meta Business Help Center, View Diagnostics in Events Manager: https://www.facebook.com/business/help/440960283805830
22. Meta Business Help Center, Test Your Server Events Using the Test Events Tool: https://www.facebook.com/business/help/ServerTestEventsTool
23. Meta Business Help Center, Monitor and Improve Your Conversions API Setup: https://www.facebook.com/business/help/586304118741779
24. Meta Business Help Center, Implement Conversions API Using Personalized Instructions: https://www.facebook.com/business/help/232481544843294