Quick answer: Connect PostHog’s Meta Ads Conversions destination to your Meta dataset. Map the events you want Meta to measure, and use the same event name and ID in PostHog and the Meta Pixel to avoid duplicates. Add matching data such as email, phone, fbc, and fbp when available and permitted. (+ / +)
The destination works alongside the Pixel: Meta recommends sending the same conversions through both, then deduplicating them with a shared event name and ID. Use the customer information you already hold in PostHog to help Meta match each conversion to a person. (+) For website events, Meta recommends an Event Match Quality score of 6.0 or higher (+); the score is unavailable for other action sources. (+)
Test with a Test Event Code before opening the destination to ordinary traffic. Meta keeps events sent with a test code and uses them for targeting and measurement. (+)
For the prerequisites shared by the six platforms and the differences between them, see our overview of PostHog’s ad destinations.
Requirements
You need PostHog already tracking the conversions you intend to send to Meta Ads. If you have not installed it, follow our installation guide for Shopify, WordPress or ClickFunnels. Use our event tracking plan guide to decide which recorded action represents the conversion. That event should record the completed action: a confirmation-page view can fire on a reload or before payment settles, and a browser-captured event reaches PostHog only when the browser loads and sends it.
Put the customer’s email or phone on the person before the conversion is processed, or include it on the conversion event and map that event property. A destination reads person properties at processing time; an identify() call that arrives afterward cannot add matching data to that earlier event. (+)
You also need a Meta dataset (Pixel), access to it in Events Manager, and developer privileges for the business. The Generate access token link is visible only to users with those privileges. (+)
Before adding Purchase, check what already sends it to that dataset. Shopify’s Facebook & Instagram app sends Purchase through the Conversions API at both Enhanced and Maximum data-sharing levels. (+) Meta’s one-click Conversions API setup is another possible server source. (+)
Two server reports of a purchase are deduplicated only when their event_name and event_id match. The PostHog template does not know an existing integration’s IDs. Leave Purchase with that source, or switch it off there and coordinate the ID with the Pixel before enabling the PostHog mapping. (+)
Configure the Meta Ads Conversions destination
In PostHog, open Destinations and click New destination. Search for Meta Ads Conversions and click + Create. (+ / +)
In Meta Events Manager, go to Data sources → your dataset → Settings. Copy the Dataset ID into PostHog’s Pixel ID field. Use the same ID as the browser Pixel. Under Conversions API → Set up manually, choose Generate access token and put it in PostHog’s Access token field. (+)
The destination is marked Experimental. Its template can change, and PostHog does not offer official support for unexpected issues with it; verify the requests and Meta’s responses yourself before enabling ordinary traffic. (+)
A new destination includes eight mappings, all enabled by default. Each has its own source-event filter, Meta event name and custom-data fields: (+)
| PostHog mapping / source event | Meta event |
|---|---|
Page Viewed / $pageview | PageView |
| Product Viewed | ViewContent |
| Products Searched | Search |
| Product Added | AddToCart |
| Checkout Started | InitiateCheckout |
| Order Completed | Purchase |
| Lead Generated | Lead |
| Signed Up | CompleteRegistration |
Set each mapping’s filter to the event or action you actually record. For example, in the Order Completed mapping, select your source event or action and keep Purchase as the Meta event name, spelled exactly as Meta lists it. (+)
Delete mappings you do not use, starting with Page Viewed if the Pixel already sends PageView. Its default sends every $pageview with the PostHog event UUID; a separately generated Pixel PageView does not share that ID. Keep only the conversions you intend to send.
Configure internal and test-user rules and turn on Filter out internal and test users. The global filters run before each mapping’s own filters. (+) Build those rules from person properties: a cohort with behavioural filters, or none, makes destinations error. (+)
A browser SDK opt-out stops that browser’s event capture; it does not stop your backend or a billing webhook from sending events. Have your consent tool record permission to share the conversion with Meta, then require that permission in a mapping filter. For example, if your application records a boolean ads_consent, require ads_consent = true; that is an illustrative property you supply, not a PostHog default. (+ / +)

Review an existing destination’s saved configuration; a newly retrieved template does not prove that an older instance has the same behavior. A destination with one Event name at the top, rather than mappings, predates per-event mappings (added in August 2026): it needs a separate destination per Meta event unless you rebuild it with mappings. (+)
A saved fbc expression that builds the click from the current time, or a destination without an fbp input, predates PostHog’s September 2026 click changes. Replace that saved click expression with the current one below, add the browser ID, and inspect the saved code for the click-age guard. Older code may also post to /v21.0/; check the API version before its support ends. (+)
After filters and triggers, review the event parameters. Some fields are shared across mappings; Event name and Custom data belong to each mapping. The defaults to change first are the Event ID when the Pixel also reports the conversion, and any currency fallback that does not describe the order. Before enabling, exclude events missing their business ID or valid matching data; website conversions also need their conversion URL and browser user agent. For Purchase, require a valid amount and currency.
Common fields
Event data
These fields describe the conversion and the dataset receiving it. Access token, Pixel ID, Event ID, Event source URL, Event time, Action source and User data are shared destination inputs; Event name and Custom data are per mapping in a new destination. (+)

Access token: It’s your authentication token. Enter the token generated in Events Manager in the destination’s secret field.
Pixel ID: Specifies which dataset receives the event. Use the browser Pixel’s ID when both report the same conversion.
Event name: The Meta event name, spelled exactly as Meta lists it. Set it in each mapping; your PostHog event or action can have a different name.
Event ID: It connects the browser and server reports of the same conversion, so it decides whether Meta can deduplicate them. For a Purchase event, use the Order ID; for bookings, use the Booking ID, or another value generated only once per conversion. Retain it on retries and give each new conversion a different ID.
Replace the default {event.uuid} with {event.properties.order_id} for a purchase carrying that property. Send that same order ID as the Pixel’s eventID, the fourth argument of the fbq purchase call. Both copies must also use the same event name and reach the same Pixel ID within 48 hours of the first copy. Meta keeps the first copy, favouring the browser event when both arrive within five minutes. (+ / +)
For an existing Pixel integration, the purchase call looks like this. Here, order is your confirmed order, its ID is a string, and that same value is captured as order_id on the PostHog conversion. Run it only after the purchase succeeds and the required advertising permission is present:
fbq('track', 'Purchase', {
value: order.value,
currency: order.currency,
}, { eventID: order.id });The ID belongs to the conversion, not the customer: a customer can buy twice. If one destination sends purchases and leads, make its shared Event ID expression read the appropriate business ID for each event. Filter out events missing that ID. Use our conversion tracking audit to check for other paths reporting the same action.
Event source URL: The URL of the page where the event occurred. PostHog prefills {event.properties.$current_url} and omits it when empty. Website events require the actual conversion URL, including purchases captured by your backend. Pass that URL with the backend event; it does not acquire a browser URL by itself. (+)
Event time: The time when the event happened, in Unix seconds. Keep the default {toInt(toUnixTimestamp(event.timestamp))} when the PostHog timestamp is correct. Meta rejects the whole request if any event is more than seven days old. Replacing it with upload time changes the meaning of a delayed conversion. (+) Seven days is the limit, not a target: Meta recommends sending events as close to real time as possible. (+)
Action source: Where the conversion occurred. The default is website; the other choices are email, app, phone_call, chat, physical_store, system_generated, business_messaging and other. An automatic subscription renewal belongs under system_generated. Choose by where the action happened, even when a server sends it. Separate website purchases and renewals into destinations with the appropriate shared Action source. (+)
Graph API version: As of October 2026, the template posts to v25.0. (+) Meta supports it until 29 July 2028, and v26.0 is the latest; Conversions API follows the Graph API support schedule. (+ / +) If your saved code still posts to /v21.0/, update it before 21 January 2027, then retest.
User data
User data gives Meta the information it uses to match the conversion to a person. Add the identifiers you actually hold and are permitted to share.
The default User data includes em, fn and ln, lowercased and SHA-256-hashed inside their input expressions, plus fbc, fbp and client_user_agent. It does not include ph, external_id or client_ip_address. The destination code forwards the configured values without another hashing step; add or edit the expressions yourself. (+)

Fields that require hashing:
Normalise each field before hashing it with SHA-256. The formatting differs by field; a hash of the wrong representation will not match the correctly formatted value. Omit missing data, and do not hash a value again if your source already supplies its SHA-256 digest. (+)
em: Email address, trimmed and lowercased. The default lowercases it but does not trim. Use {sha256Hex(lower(trim(person.properties.email)))} when populated; this version also omits an absent or whitespace-only email:
{not empty(trim(person.properties.email ?? '')) ? sha256Hex(lower(trim(person.properties.email))) : null}ph: Phone number, digits only with its country code and no international-dialling prefix such as 00. Store a validated E.164 number upstream. This expression accepts that number with a leading + and removes it before hashing; it cannot add a missing country code or repair a local number:
{match(person.properties.phone ?? '', '^[+][1-9][0-9]{1,14}$') ? sha256Hex(replaceAll(person.properties.phone, '+', '')) : null}fn and ln: First and last name, lowercase with no punctuation. Remove punctuation upstream; these expressions then trim, lowercase and hash the names, leaving missing values out. UTF-8 letters can remain.
{not empty(trim(person.properties.first_name ?? '')) ? sha256Hex(lower(trim(person.properties.first_name))) : null}{not empty(trim(person.properties.last_name ?? '')) ? sha256Hex(lower(trim(person.properties.last_name))) : null}ge: Gender, if collected and permitted: lowercase f or m, hashed. {lower(person.properties.gender ?? '') in ['f', 'm'] ? sha256Hex(lower(person.properties.gender)) : null}. Never set one constant gender for every person.
db: Date of birth, if collected and permitted, in YYYYMMDD form before hashing. For a valid date stored upstream as YYYY-MM-DD, use {match(person.properties.date_of_birth ?? '', '^[0-9]{4}-[0-9]{2}-[0-9]{2}$') ? sha256Hex(replaceAll(person.properties.date_of_birth, '-', '')) : null}. The expression checks the shape; validate the calendar date at collection.
The following GeoIP fields are optional. They describe the network’s location, which can differ from the customer’s address. Meta ranks city and postal code as low-priority keys, and an event identified only by location fields, gender and user agent is invalid. Do not use these fields as a substitute for email, phone or another supported identifier. (+ / +)
PostHog supplies GeoIP city, subdivision, postal and country properties. The examples below omit city or state names containing punctuation or letters outside ASCII; normalise those upstream if you choose to send them. Check the saved person properties before using a GeoIP fallback. (+)
ct: City, lowercase without punctuation or spaces. This guarded version removes spaces from an ASCII GeoIP city name:
{match(person.properties.$geoip_city_name ?? '', '^[A-Za-z]+( [A-Za-z]+)*$') ? sha256Hex(replaceAll(lower(trim(person.properties.$geoip_city_name)), ' ', '')) : null}st: State. In the US, use the two-letter state code, not the full state name; elsewhere, use the lowercase state name without punctuation or spaces. This uses PostHog’s subdivision code for US locations and its subdivision name elsewhere:
{lower(person.properties.$geoip_country_code ?? '') == 'us' ? (match(person.properties.$geoip_subdivision_1_code ?? '', '^[A-Za-z]{2}$') ? sha256Hex(lower(person.properties.$geoip_subdivision_1_code)) : null) : (match(person.properties.$geoip_subdivision_1_name ?? '', '^[A-Za-z]+( [A-Za-z]+)*$') ? sha256Hex(replaceAll(lower(trim(person.properties.$geoip_subdivision_1_name)), ' ', '')) : null)}zp: Postal code, lowercase without spaces or dashes; use only the first five digits for US ZIP codes. Check the country-specific format before sending it:
{lower(person.properties.$geoip_country_code ?? '') == 'us' ? (match(person.properties.$geoip_postal_code ?? '', '^[0-9]{5}(-[0-9]{4})?$') ? sha256Hex(substring(person.properties.$geoip_postal_code, 1, 5)) : null) : (match(person.properties.$geoip_postal_code ?? '', '^[A-Za-z0-9]+([ -][A-Za-z0-9]+)*$') ? sha256Hex(replaceAll(replaceAll(lower(person.properties.$geoip_postal_code), ' ', ''), '-', '')) : null)}country: Lowercase, two-letter ISO 3166-1 alpha-2 country code. {match(person.properties.$geoip_country_code ?? '', '^[A-Za-z]{2}$') ? sha256Hex(lower(person.properties.$geoip_country_code)) : null}.
external_id: Your own stable customer or account ID. Meta recommends hashing it and including it on every event. Keep the same representation across the Pixel and Conversions API. In a subscription integration carrying a string app_user_id, {not empty(event.properties.app_user_id) ? sha256Hex(event.properties.app_user_id) : null} hashes that ID once. It identifies the customer; it does not replace the per-conversion Event ID. (+)
Fields that do not require hashing:
client_ip_address: The visitor’s real IPv4 or IPv6 address, sent without hashing. For a browser event it is usually {event.properties.$ip}. Server events must supply the visitor’s IP explicitly; a backend or billing webhook’s own IP does not describe the customer. (+)
For a backend event that completes a website conversion, such as a purchase your payment provider confirms, read the visitor’s IP saved on the person. Leave the old visitor IP and user agent out of automatic renewals, which you send as system_generated. In our RevenueCat setup we used {person.properties.$ip ?? event.properties.subscriber_attributes.$ip} to fall back to the integration’s subscriber attribute. Inspect your event before using that fallback: it must hold the visitor’s IP as a string. Use our visitor IP and user-agent guide to save browser context without overwriting it with server context.
Check the project’s IP capture setting. New projects in PostHog EU organisations inherit a default that discards client IPs; existing projects retain their settings. (+)
client_user_agent: The visitor’s browser user agent, required for website events and sent without hashing. The default is {event.properties.$raw_user_agent}. For a backend conversion, use the browser user agent the transformation in our visitor IP guide saves, {person.properties.visitor_user_agent}: PostHog’s automatic $raw_user_agent person property can be replaced by the server’s. The PostHog Node SDK does not add the visitor’s browser user agent for you. (+ / + / +)
fbc: It is Meta’s way of preserving ad click context once a user lands on your website. It is derived from the fbclid query parameter Meta appends when someone clicks an ad. It helps Meta connect a later Purchase or Lead to that click. Send it without hashing or changing its case. Its format is fb.<domain index>.<creation time in milliseconds>.<fbclid>: the time is when the cookie was saved, or when you first observed that click ID, not when the customer later converted. (+)
Since posthog-js 1.426.0, PostHog stores $fbc when it first sees a new fbclid. Since 1.433.0, it can read the Pixel’s _fbc cookie and prefer its original timestamp for the same or a newer click. That version also reads _fbp into $fbp. (+)
Replace the old click expression that used the current time with the current default:
{person.properties.fbc ?? person.properties.$fbc ?? (not empty(event.properties.fbclid) ? f'fb.1.{toUnixTimestampMilli(event.timestamp)}.{event.properties.fbclid}' : '')}It reads the person’s fbc, then $fbc, then an fbclid on the event. That last fallback uses the event timestamp, so it represents the first observation only when the event actually first observed the click. With none of these values available, no fbc is sent. (+)
The template drops a malformed fbc, one at least 90 days older than the event, or one stamped more than five minutes after it. Those cutoffs remove only the click field; the destination still sends the rest of the event. A stored empty or stale fbc takes precedence over $fbc and the event’s click ID, so repair that stored value rather than stamping the old click with a new time.
Person properties can reflect a later visit. For a delayed conversion, that can be a newer click from another visit, which the template then sends, or drops as stamped after the conversion. To keep the conversion’s own click, read the permitted _fbc and _fbp cookies at checkout, store them with the order, and send them as fbc and fbp properties on the conversion event. Then map the event’s value first, leaving the property out rather than empty when there is none. A conversion without its own value then falls back to the person’s current click, which may be later than the conversion; map {event.properties.fbc} alone to send only the order’s own click: (+)
{event.properties.fbc ?? person.properties.fbc ?? person.properties.$fbc ?? (not empty(event.properties.fbclid) ? f'fb.1.{toUnixTimestampMilli(event.timestamp)}.{event.properties.fbclid}' : '')}fbp: The browser identifier from the Pixel’s _fbp cookie, sent without hashing. Use the current default {person.properties.fbp ?? person.properties.$fbp ?? ''}, or {event.properties.fbp ?? person.properties.fbp ?? person.properties.$fbp ?? ''} when the conversion carries its own value, or {event.properties.fbp} alone. PostHog cannot derive this identifier from fbclid.
PostHog attaches the SDK-derived $fbc and $fbp only to events that create or update a person profile. With person_profiles: 'identified_only', create the person profile before the conversion needs these values, for example with an earlier identify() call. Cookie reads also stop with save_campaign_params: false or cookieless mode. (+)
With mask_personal_data_properties on, the URL’s fbclid is masked, so PostHog cannot build a usable $fbc from it; the cookie path still works and is not masked. Review which identifiers you intend to share. See our ad URL and click-ID guide for capturing the click at landing. (+)
If you don’t see a field defined by default, add it with Add entry. Leave unavailable optional values out.
Event-specific fields:
Set these fields under each mapping’s Custom data, which becomes Meta’s custom_data. Choose the parameters that describe that event; the event lists below cover the standard events that use them. (+ / +)

value: The monetary value associated with the event. Required for Purchase and events using value optimisation; also supported with AddPaymentInfo, AddToCart, AddToWishlist, CompleteRegistration, InitiateCheckout, Lead, Search, StartTrial, Subscribe and ViewContent. Map the actual order total for Purchase, in the currency’s main unit: 49.99 for €49.99, not 4999 cents.
The template chooses value, then revenue, then price, and converts it to a number. A product’s unit price can therefore become the reported order value. If your source’s revenue is the order total, set {toFloat(event.properties.revenue)} explicitly after validating it; use your own total property otherwise. (+)
currency: The actual ISO 4217 currency of that value, mapped as {event.properties.currency}. It accompanies Purchase and the other value-bearing events above. Six default mappings—ViewContent, AddToCart, InitiateCheckout, Purchase, Lead and CompleteRegistration—fall back to USD when currency is missing. Remove that fallback: it misstates every non-USD order whose currency is absent.
The currency and value fields come together and are required for Purchase. Missing or invalid values do not necessarily stop delivery: Meta still receives the event but excludes it from value optimisation and ROAS-based bidding. Filter out an incomplete Purchase until its source supplies the correct amount and currency. (+)
predicted_ltv: For StartTrial and Subscribe, it’s the advertiser’s estimate of how much total revenue a subscriber will generate over their entire lifetime. Keep it separate from the amount paid in the current transaction.
content_ids: Product or content IDs associated with the event, such as SKUs. Used with AddPaymentInfo, AddToCart, AddToWishlist, InitiateCheckout, Purchase, Search and ViewContent. The template uses sku or product_id; its checkout and purchase mappings read these from the products array.
content_type: Either product or product_group, based on the IDs being passed. If the IDs identify products, use product; if they identify product groups, use product_group. Used with AddToCart, Purchase, Search and ViewContent. The template defaults to product where it sets this field.
contents: An array of product objects used with AddPaymentInfo, AddToCart, AddToWishlist, InitiateCheckout, Purchase, Search and ViewContent. id and quantity are required; item_price and delivery_category are optional. Make sure the source products have IDs and quantities: the template omits product rows missing either.
num_items: The number of items being bought at InitiateCheckout. Use the total quantity, for example {event.properties.num_items} if your source records it. Counting the length of a product array undercounts units when a row has a quantity greater than one. For Conversions API, use this field only with InitiateCheckout; the Pixel also lists it for Purchase, and PostHog’s Purchase mapping includes it. Remove it from that mapping to follow the CAPI-specific rule.
search_string: Used only with Search. It’s the string entered by the user; the template maps {event.properties.query}.
order_id: The order ID for a Purchase transaction, as a string. The template reads {event.properties.order_id}. Setting it here does not replace the Event ID used to deduplicate the Pixel and CAPI copies.
Test before going live
While testing, use the Test Event Code that Meta provides so you can preview the data you’re sending. Get it from Events Manager → Data sources → your dataset → Test events and put it in PostHog’s Test Event Code field. Meta keeps these events and uses them for targeting and ads measurement, so the code is not a way to discard test traffic. (+)
Events remain visible in the Test Events tool for 24 hours or until you clear the activity. Use your own real identity data when testing; test events that cannot match a Meta account may be discarded. (+ / +)
PostHog’s Test function sends a real HTTP request unless you switch off Make real HTTP requests. Turn it off first to inspect the mapped request, then turn it on for a controlled test with the Meta code present. (+)
- Use an event that matches the intended mapping. Inspect its original time, shared business ID, permission marker, amount and currency.
- Check the resolved inputs and outgoing payload, including hashed contact fields, the visitor’s IP and user agent, and the original click context.
- Find the server event in Meta Test Events. If the Pixel also sends it, confirm both use the same name and ID and that Meta deduplicates them. Repeat the same conversion with the same ID, then check a genuinely new conversion with a new ID.
- Check an event without matching data, one without advertising permission, and one excluded by your internal-user rules. Confirm that the intended filters prevent those requests.
external_id is not displayed in Test Events. Check its resolved input and outgoing request instead. (+)
When you’ve finalised the setup, delete the Test Event Code and restore the intended production filters. Then follow one permitted real conversion through three separate checks:
- Delivered: The destination’s Invocations show whether each run succeeded. Inspect a failed run’s error; when Meta rejected the request, it includes Meta’s response. A successful request establishes delivery; inspect failures before retrying. The request itself is visible in the mocked test above. (+ / +)
- Matched: In Events Manager, open the dataset’s Overview → the event → View details and inspect Event Match Quality and the deduplication details. A received event can still have insufficient information to match a person. (+ / +)
- Attributed: Check whether Ads Manager credits the conversion to an ad. Delivery and matching do not themselves establish ad credit; a conversion still needs an eligible ad interaction under the applicable attribution settings. (+ / +)
After changing a source event, mapping or ecommerce integration, compare the shared order IDs and values again. A newly added Purchase sender or a renamed total property can undo the setup without stopping successful requests.
Frequently asked questions
Do I still need the Meta Pixel when using PostHog’s Conversions API destination?
Why does Meta count my purchases twice?
Check that the Pixel’s eventID equals the destination’s Event ID and that both use Purchase. The default PostHog UUID does not match a separately generated Pixel event ID. Also check for a third sender: Shopify Enhanced or Maximum data sharing and Meta’s one-click Conversions API can already report the same purchase. Two server copies need the same event name and ID to deduplicate. Events Manager counts received events before deduplication, so two received copies are expected; check the event’s deduplication details. (+ / + / +)
Do I need one Meta destination per event or per Pixel?
One current destination supports several mappings, one for each Meta event you want to send. Pixel ID is shared across the destination, so use separate destinations for different Pixels. A destination that still has one Event name at the top keeps that one-event shape until you rebuild it. Separate destinations also make sense when shared settings such as Action source or ownership differ. (+ / +)
What is fbc, and how is it different from fbclid?
fbclid is the click ID in the landing URL. fbc wraps it with a domain index and the time the cookie was saved or the click was first observed. Preserve that time and the click ID’s case, and send the value without hashing. Creating it at a later purchase time changes the click context. (+)
Does PostHog hash all customer data automatically?
No. The default email and name expressions hash those three fields; the destination code does not hash other fields you add. Normalise and hash phone and other required contact fields once. Do not hash IP, user agent, fbc or fbp. Hashing is a matching transformation; permission, retention and disclosure still need their own controls. (+ / +)
Why is Event Match Quality low even though the destination succeeds?
Check the matching fields that actually reach Meta. Backend events can lack the visitor’s IP and browser user agent; an email may have been hashed before trimming; external_id is absent from the defaults; and a late identify call cannot supply data to an earlier conversion. Fix those conditions and review the event’s matching details in Events Manager. (+ / +)
Why does nothing reach Meta?
If no run appears under Invocations, check that the destination is enabled, that a mapping matches the event, and that the filters, including your advertising-permission property, let it through. If a run failed, read its error; when Meta rejected the request, it includes Meta’s response, such as an invalid access token or dataset. If runs succeed, check that the Pixel ID is the dataset you are viewing in Events Manager. (+)
Are events sent with a Test Event Code discarded?
What are the most common mistakes in PostHog → Meta setups?
Check for these configuration mistakes:
- Missing or inconsistent Event IDs, including different IDs on the Pixel and server copies.
- Incorrect hashing or normalisation of customer data.
- Missing customer identifiers or visitor context on backend events.
- Wrong event mapping, such as sending a lead as Purchase.
- Ignoring
fbcor rebuilding it with the conversion time.
Why is fbp missing even though the Pixel has an _fbp cookie?
Check the SDK version and person-profile processing first. Cookie capture requires posthog-js 1.433.0 or later, and it reaches the person only through a profile-processing event. Cookie reads stop in cookieless mode or with save_campaign_params: false. (+ / +)
There is also a format limitation: the SDK accepts a four-part _fbp, while Meta’s parameter builder can append a fifth part. That cookie will not populate $fbp through this SDK path. If you use the builder, explicitly forward its permitted browser ID and inspect the destination’s resolved fbp. (+)
