Pinterest Conversions API: Server-Side Tracking Setup [2025–2026]

Pinterest Server-Side Tracking vs the Pinterest Tag

The Pinterest tag is a JavaScript snippet that runs in the browser — it fires on page views, add-to-cart events, and checkouts client-side. Pinterest server-side tracking (CAPI) sends the same events directly from your server to Pinterest, bypassing the browser entirely.

They are not the same thing and are not interchangeable — they are designed to run together. The tag handles real-time browser signals; CAPI captures the events the tag misses due to ad blockers, ITP, or consent refusals. Running both with deduplication is the correct setup.

Factor	Pinterest Tag (browser)	Conversions API (server)
Runs where	Visitor's browser	Your server
Blocked by ad blockers	Yes	No
Affected by iOS / ITP	Yes	No
Captures click ID (epik)	Yes	Only if passed through from the browser
Typical event loss	15%–40% (industry estimate)	Minimal
Setup difficulty	Low — one snippet	Medium — app or API work
Correct use	Both, sharing one event_id so Pinterest deduplicates

The click ID row is the one most setups get wrong. The epik click ID is only available in the browser, so a server-only implementation loses it unless you capture it client-side and pass it through to your server event. Without it, Pinterest has fewer signals to attribute the conversion back to the ad that caused it.

Do You Need Conversions API?

CAPI is recommended (not required) for most advertisers. You should prioritize it if:

• Your site has significant EU/UK traffic (GDPR consent banners block many tag fires)
• You target audiences that commonly use ad blockers (design-conscious, affluent demographics)
• Your Pinterest-reported conversions seem significantly lower than actual orders
• You're spending $2,000+/month — at that spend level, the data quality improvement is material

For Shopify stores under $1,000/month spend, the Pinterest Shopify app is sufficient — it includes a basic server-side component. CAPI becomes more important as spend and EU traffic increase.

Method 1: Shopify App (Simplest)

The Pinterest Shopify app includes a server-side component that functions as a basic CAPI integration. If you're on Shopify, this is active automatically when you use the Pinterest app — no additional setup.

To verify it's active: Pinterest app settings → verify "Enhanced Conversions" is enabled. This sends hashed customer data (email, name) alongside events to improve match rates.

Method 2: Pinterest CAPI Direct Integration

For non-Shopify stores or custom CAPI setups, you send events directly to Pinterest's API endpoint.

Step 1 — Get your access token

1. Pinterest Ads Manager → Ads → Conversions → Conversion Access Token
2. Create a new token — store it securely (treat like a password)

Step 2 — Send events on order completion (server-side)

When an order is placed, your server sends a POST request to Pinterest's API:

POST https://api.pinterest.com/v5/ad_accounts/{ad_account_id}/events

{
  "data": [
    {
      "event_name": "checkout",
      "action_source": "web",
      "event_time": 1715000000,
      "event_id": "ORDER-12345",
      "event_source_url": "https://yourstore.com/thank-you",
      "user_data": {
        "em": ["HASHED_EMAIL"],
        "ph": ["HASHED_PHONE"],
        "client_ip_address": "1.2.3.4",
        "client_user_agent": "Mozilla/..."
      },
      "custom_data": {
        "currency": "USD",
        "value": "549.00",
        "order_id": "ORDER-12345",
        "contents": [
          {
            "id": "SKU-789",
            "item_price": "549.00",
            "quantity": 1
          }
        ]
      }
    }
  ]
}

action_source accepts four values: web, app_android, app_ios, and offline. Use web for events that happen on your website. offline events cannot be deduplicated against browser events, so never use it for online checkouts.

Step 3 — Hash user data correctly

Pinterest requires PII (email, phone) to be hashed with SHA256 before sending. The email must be normalized first (lowercase, trimmed):

// Node.js example
const crypto = require('crypto');
const hashedEmail = crypto
  .createHash('sha256')
  .update(email.toLowerCase().trim())
  .digest('hex');

Deduplication — Critical

If both your browser tag and CAPI send the same checkout event, Pinterest counts it twice. Deduplication prevents this — use the same unique identifier in both:

• Browser tag: pintrk('track', 'checkout', { event_id: 'ORDER-12345', order_id: 'ORDER-12345', value: 549.00, currency: 'USD' })
• CAPI: "event_id": "ORDER-12345"

Pinterest deduplicates on the pair event_id + event_name. When a browser event and a server event arrive carrying the same event_id and the same event name, Pinterest keeps one and discards the other. If either ID is missing, empty, or different, both are counted and your ROAS looks inflated.

Three conditions have to hold for deduplication to fire:

• event_id and event_name are both present and non-empty on both events.
• The duplicate arrives within 24 hours of the first recorded event.
• action_source is not offline — offline events are never deduplicated.

Generate one event_id per user action, not per page load. An order ID works well because it is unique, stable, and available on both the browser and the server for the same checkout. A timestamp or random value generated separately in each place will never match.

Method 3: Via Integration Platforms

Several integration tools simplify CAPI setup without direct API calls:

• Elevar: Popular for Shopify — handles both tag and CAPI with deduplication
• Littledata: Shopify-specific, robust server-side tracking
• Segment: If you're already using Segment, it has a Pinterest CAPI destination
• Triple Whale: Attribution platform that includes Pinterest CAPI

For most home decor Shopify brands, Elevar or Littledata are the most straightforward options and don't require custom development.

Verifying CAPI Is Working

Three checks, in order. Skipping straight to the test purchase is why most people conclude "it's just delayed" when the connection was never live.

Step 1 — Confirm a server source exists

Pinterest Ads Manager → Conversions → Events Manager, then select your tag. For each event (PageVisit, AddToCart, Checkout), confirm a server processing source appears, not only browser. Note this is Pinterest labelling where the event arrived from — it is a separate thing from the action_source field you send inside the payload. A server source is proof the API connection itself is live.

Step 2 — Read event match quality

Match quality reflects how well Pinterest can tie your server events to real people. It rises with every strong match key you pass:

• Hashed email — the highest-value key for ecommerce
• Click ID (epik) captured in the browser and passed through to the server event
• IP address and user agent
• Hashed phone, name, or external ID where you have them

Low match quality almost always means you are sending events but omitting identifiers. The events still arrive; they simply count for less. Add email and click ID first.

Before sending anything real, you can validate the request itself. Append ?test=true to the events endpoint — Pinterest returns the same response messages so you can confirm the payload is accepted, but the events are not recorded. Use this to debug field and hashing errors without polluting your conversion data.

Step 3 — Run one controlled test purchase

1. Use a real product and a live or test-mode checkout so a genuine Checkout event fires.
2. In Events Manager, watch for that Checkout to appear from both the browser tag and the server.
3. Confirm the two collapse into one conversion — that is deduplication working via the shared event_id.
4. Check the value and currency on the event match the actual order total.

Our rule of thumb: if a test event never surfaces while the ?test=true call returns a success response, the problem is delivery or matching, not reporting lag. Work through the failure modes below rather than waiting.

Common Pinterest CAPI Errors and How to Fix Them

1. Events not appearing at all

Usually the token, the endpoint, or the payload. Check the access token has not expired and belongs to the correct ad account, confirm you are posting to the right ad_account_id, and read the API response body rather than assuming a silent success. An event carrying zero usable match keys can be accepted by the endpoint and then dropped — always send at least a hashed email or an IP address.

2. Conversions doubled after enabling CAPI

The tag and CAPI are both firing the same event without a shared event_id, so each is counted separately. Send one identical event_id from both sources per user action. See the deduplication section above for the three conditions that must hold.

3. Low event match quality

You are either omitting identifiers or hashing them wrongly. Personal data must be hashed with SHA-256 after normalization — lowercase and trim first. Hashing an unnormalized string produces a valid hash that matches nothing, and it fails silently. Add hashed email as the primary key, then the click ID passed from the browser.

4. Authentication and token errors

Conversion access tokens are generated per ad account and can be revoked or expire. Store the token as a server-side secret, never in client-side code, and rotate it if it has ever been exposed. A 401 means the token; a 403 usually means the token is valid but not authorized for that ad account.

5. Wrong event values or currency

Send value as the order total in the same currency you report in, and set currency explicitly on every event. Mismatched or missing currency produces ROAS figures that look plausible and are wrong. Verify against a real order before trusting the numbers.

Pinterest CAPI on WooCommerce

WooCommerce supports Conversions API the same way any other platform does — there is no Pinterest-native equivalent of the Shopify app doing it for you, so you pick one of two routes.

Route 1 — a plugin. The lowest-effort path for most stores. Confirm before installing that the plugin actually sends server-side events (not just the browser tag), and that it exposes the event_id it generates so you can verify deduplication.

Route 2 — custom server-side implementation. Hook the order-completion event, build the payload shown above, and send it from PHP. You control the match keys, which is the main advantage.

The three things WooCommerce stores get wrong:

• Dropping the browser tag. CAPI is not a replacement. Keep both running.
• No shared event_id. Tag and CAPI count separately and conversions inflate.
• Thin match keys. Send hashed email, IP, and user agent from the order and request context, not just the order value.

---