Snapchat Ads Integrations | Blue Frog Docs

Snapchat Ads Integrations

Learn how to integrate Snap Pixel, Conversions API, partner platforms, and the Snapchat Marketing API.

Snapchat Ads Integrations Overview

Snapchat Ads offers robust integration options to connect your marketing stack, eCommerce platform, and analytics tools. These integrations enable seamless tracking, campaign optimization, and data synchronization across your digital ecosystem.

Snap Pixel

What is Snap Pixel?

The Snap Pixel is a JavaScript snippet that tracks user behavior on your website after viewing or engaging with Snapchat ads. It powers conversion tracking, audience building, and campaign optimization.

Key Capabilities

Feature Description
Conversion Tracking Track purchases, signups, and custom events
Audience Building Create retargeting and lookalike audiences
Campaign Optimization Optimize delivery to users likely to convert
Attribution Measure ad impact with configurable windows
Advanced Matching Improve match rates with hashed user data

Basic Pixel Implementation

<!-- Snap Pixel Base Code -->
<script type='text/javascript'>
(function(e,t,n){if(e.snaptr)return;var a=e.snaptr=function()
{a.handleRequest?a.handleRequest.apply(a,arguments):a.queue.push(arguments)};
a.queue=[];var s='script';var r=t.createElement(s);r.async=!0;
r.src=n;var u=t.getElementsByTagName(s)[0];
u.parentNode.insertBefore(r,u);})(window,document,
'https://sc-static.net/scevent.min.js');

snaptr('init', 'YOUR_PIXEL_ID', {
  'user_email': '__INSERT_USER_EMAIL__'
});

snaptr('track', 'PAGE_VIEW');
</script>

Advanced Matching

Enhance match quality by passing hashed user identifiers:

// Hash user data before sending
function hashData(data) {
  // Use SHA256 hashing
  return sha256(data.toLowerCase().trim());
}

// Initialize pixel with user data
snaptr('init', 'YOUR_PIXEL_ID', {
  'user_email': hashData('user@example.com'),
  'user_phone_number': hashData('+15551234567'),
  'user_hashed_email': hashData('user@example.com'),
  'user_hashed_phone_number': hashData('+15551234567')
});

// Track event
snaptr('track', 'PURCHASE', {
  'price': 99.99,
  'currency': 'USD',
  'transaction_id': 'ORDER_12345'
});

Standard Events

// Page View
snaptr('track', 'PAGE_VIEW');

// View Content
snaptr('track', 'VIEW_CONTENT', {
  'item_ids': ['SKU_123'],
  'item_category': 'Electronics',
  'price': 99.99,
  'currency': 'USD'
});

// Add to Cart
snaptr('track', 'ADD_CART', {
  'item_ids': ['SKU_123'],
  'price': 99.99,
  'currency': 'USD'
});

// Purchase
snaptr('track', 'PURCHASE', {
  'item_ids': ['SKU_123', 'SKU_456'],
  'price': 199.98,
  'currency': 'USD',
  'transaction_id': 'ORDER_12345',
  'number_items': 2
});

// Sign Up
snaptr('track', 'SIGN_UP', {
  'sign_up_method': 'email'
});

// Start Checkout
snaptr('track', 'START_CHECKOUT', {
  'item_ids': ['SKU_123'],
  'price': 99.99,
  'currency': 'USD'
});

Snapchat Conversions API (CAPI)

What is Conversions API?

The Snapchat Conversions API enables server-side event tracking, providing more reliable measurement than browser-based pixels, especially with ad blockers and privacy restrictions.

Benefits

  • Browser-independent tracking - Not affected by ad blockers
  • Improved data accuracy - Direct server-to-Snapchat connection
  • Better attribution - Server-side data less prone to loss
  • Enhanced privacy - Control what data is shared
  • Event deduplication - Combine with Pixel for complete coverage

Conversions API Implementation

Node.js Example

const axios = require('axios');
const crypto = require('crypto');

function hashSHA256(data) {
  return crypto.createHash('sha256')
    .update(data.toLowerCase().trim())
    .digest('hex');
}

async function sendSnapEvent(eventData) {
  const payload = {
    data: [{
      event_type: 'PURCHASE',
      event_conversion_type: 'WEB',
      event_tag: 'event_tag',
      timestamp: Math.floor(Date.now()),
      hashed_email: hashSHA256(eventData.email),
      hashed_phone_number: hashSHA256(eventData.phone),
      user_agent: eventData.userAgent,
      hashed_ip_address: hashSHA256(eventData.ipAddress),
      uuid_c1: eventData.snapClickId, // From _scid cookie
      item_ids: eventData.items.map(item => item.sku),
      price: eventData.total.toString(),
      currency: eventData.currency,
      transaction_id: eventData.orderId,
      number_items: eventData.items.length.toString(),
      page_url: eventData.pageUrl
    }]
  };

  const response = await axios.post(
    `https://tr.snapchat.com/v2/conversion`,
    payload,
    {
      headers: {
        'Authorization': `Bearer ${process.env.SNAP_ACCESS_TOKEN}`,
        'Content-Type': 'application/json'
      }
    }
  );

  return response.data;
}

// Usage
await sendSnapEvent({
  email: 'user@example.com',
  phone: '+15551234567',
  userAgent: req.headers['user-agent'],
  ipAddress: req.ip,
  snapClickId: req.cookies._scid,
  items: [
    { sku: 'SKU_123', price: 99.99, quantity: 1 }
  ],
  total: 99.99,
  currency: 'USD',
  orderId: 'ORDER_12345',
  pageUrl: 'https://example.com/confirmation'
});

Python Example

import requests
import hashlib
import time
import os

def hash_sha256(data):
    return hashlib.sha256(data.lower().strip().encode()).hexdigest()

def send_snap_event(event_data):
    url = 'https://tr.snapchat.com/v2/conversion'

    headers = {
        'Authorization': f"Bearer {os.environ['SNAP_ACCESS_TOKEN']}",
        'Content-Type': 'application/json'
    }

    payload = {
        'data': [{
            'event_type': 'PURCHASE',
            'event_conversion_type': 'WEB',
            'event_tag': 'event_tag',
            'timestamp': int(time.time() * 1000),
            'hashed_email': hash_sha256(event_data['email']),
            'hashed_phone_number': hash_sha256(event_data['phone']),
            'user_agent': event_data['user_agent'],
            'hashed_ip_address': hash_sha256(event_data['ip_address']),
            'uuid_c1': event_data.get('snap_click_id', ''),
            'item_ids': [item['sku'] for item in event_data['items']],
            'price': str(event_data['total']),
            'currency': event_data['currency'],
            'transaction_id': event_data['order_id'],
            'number_items': str(len(event_data['items'])),
            'page_url': event_data['page_url']
        }]
    }

    response = requests.post(url, json=payload, headers=headers)
    return response.json()

Event Deduplication

Prevent duplicate counting when using both Pixel and CAPI:

// Browser-side (Pixel)
const clientEventId = `ORDER_${orderId}_${Date.now()}`;
snaptr('track', 'PURCHASE', {
  'price': 99.99,
  'currency': 'USD',
  'transaction_id': orderId,
  'client_dedup_id': clientEventId  // Deduplication key
});

// Server-side (CAPI) - Use same client_dedup_id
const payload = {
  data: [{
    client_dedup_id: clientEventId,  // Matches browser event
    event_type: 'PURCHASE',
    // ... rest of event data
  }]
};

Partner Integrations

Shopify Integration

Snapchat offers native integration with Shopify for seamless eCommerce tracking.

Setup Steps

  1. Install Snapchat App

    • Go to Shopify App Store
    • Search "Snapchat Ads"
    • Click "Add app"

  2. Connect Accounts

    • Log in with Snapchat Business account
    • Select or create Snapchat Ads account
    • Authorize connection

  3. Configure Pixel

    • Pixel automatically installs on all pages
    • Standard events auto-configured:
      • PAGE_VIEW (All pages)
      • VIEW_CONTENT (Product pages)
      • ADD_CART
      • START_CHECKOUT
      • PURCHASE

  4. Sync Product Catalog

    • Products sync to Snapchat Catalog
    • Enable dynamic product ads
    • Configure catalog settings

Benefits

  • Automatic pixel installation - No coding required
  • Product catalog sync - Real-time inventory updates
  • Order tracking - Automatic purchase events
  • Dynamic ads - Retarget with product catalogs
  • Advanced matching - Email and phone hashing

Advanced Configuration

// Add custom Shopify tracking
// theme.liquid or custom script

// Track product views with detailed data
{% if template contains 'product' %}
<script>
snaptr('track', 'VIEW_CONTENT', {
  'item_ids': ['{{ product.id }}'],
  'item_category': '{{ product.type }}',
  'price': {{ product.price | money_without_currency }},
  'currency': '{{ shop.currency }}',
  'description': '{{ product.title | escape }}'
});
</script>
{% endif %}

// Track purchases with complete order data
{% if template contains 'thank_you' %}
<script>
snaptr('track', 'PURCHASE', {
  'item_ids': [{% for line_item in order.line_items %}'{{ line_item.product_id }}'{% unless forloop.last %},{% endunless %}{% endfor %}],
  'price': {{ order.total_price | money_without_currency }},
  'currency': '{{ order.currency }}',
  'transaction_id': '{{ order.order_number }}',
  'number_items': {{ order.item_count }}
});
</script>
{% endif %}

WooCommerce Integration

Plugin Installation

  1. Install "PixelYourSite" or "Snap Pixel for WooCommerce" plugin
  2. Enter Snap Pixel ID in settings
  3. Configure event tracking options
  4. Enable enhanced eCommerce tracking

Manual Implementation

// functions.php

// Add Snap Pixel to header
add_action('wp_head', 'add_snap_pixel');
function add_snap_pixel() {
  ?>
  <script type='text/javascript'>
  (function(e,t,n){if(e.snaptr)return;var a=e.snaptr=function()
  {a.handleRequest?a.handleRequest.apply(a,arguments):a.queue.push(arguments)};
  a.queue=[];var s='script';var r=t.createElement(s);r.async=!0;
  r.src=n;var u=t.getElementsByTagName(s)[0];
  u.parentNode.insertBefore(r,u);})(window,document,
  'https://sc-static.net/scevent.min.js');

  snaptr('init', '<?php echo get_option('snap_pixel_id'); ?>');
  snaptr('track', 'PAGE_VIEW');
  </script>
  <?php
}

// Track purchase on order received page
add_action('woocommerce_thankyou', 'snap_track_purchase');
function snap_track_purchase($order_id) {
  $order = wc_get_order($order_id);
  $item_ids = array();

  foreach ($order->get_items() as $item) {
    $product = $item->get_product();
    $item_ids[] = $product->get_sku() ?: $product->get_id();
  }
  ?>
  <script>
  snaptr('track', 'PURCHASE', {
    'item_ids': <?php echo json_encode($item_ids); ?>,
    'price': <?php echo $order->get_total(); ?>,
    'currency': '<?php echo $order->get_currency(); ?>',
    'transaction_id': '<?php echo $order_id; ?>',
    'number_items': <?php echo $order->get_item_count(); ?>
  });
  </script>
  <?php
}

// Track add to cart
add_action('woocommerce_add_to_cart', 'snap_track_add_to_cart', 10, 6);
function snap_track_add_to_cart($cart_item_key, $product_id, $quantity, $variation_id, $variation, $cart_item_data) {
  $product = wc_get_product($product_id);
  ?>
  <script>
  snaptr('track', 'ADD_CART', {
    'item_ids': ['<?php echo $product->get_sku() ?: $product_id; ?>'],
    'price': <?php echo $product->get_price(); ?>,
    'currency': '<?php echo get_woocommerce_currency(); ?>'
  });
  </script>
  <?php
}

BigCommerce Integration

Setup Process

  1. Install Snapchat App

    • BigCommerce App Marketplace
    • Install "Snapchat for BigCommerce"

  2. Configure Integration

    • Connect Snapchat Ads account
    • Authorize data sharing
    • Map product attributes

  3. Enable Features

    • Auto-install pixel
    • Sync product catalog
    • Enable order tracking

Catalog Mapping

BigCommerce Field Snapchat Field
Product ID item_id
Product Name description
Category item_category
Price price
Image URL image_link
Product URL link

Magento Integration

Extension Installation

  1. Download Snapchat Pixel extension
  2. Upload to Magento installation
  3. Enable module: bin/magento module:enable Snapchat_Pixel
  4. Configure in Admin > Stores > Configuration > Snapchat

Event Tracking Configuration

  • PAGE_VIEW - All pages
  • VIEW_CONTENT - Product pages
  • ADD_CART - Cart additions
  • START_CHECKOUT - Checkout start
  • PURCHASE - Order success

Snapchat Marketing API

API Overview

The Snapchat Marketing API enables programmatic campaign management, reporting, and audience management.

Authentication

Access Token Generation

  1. Create Snapchat Business account
  2. Navigate to Business Manager > API Setup
  3. Create OAuth app and generate access token
  4. Store token securely (refresh tokens expire every 6 months)
// API authentication example
const axios = require('axios');

const snapAPI = axios.create({
  baseURL: 'https://adsapi.snapchat.com/v1/',
  headers: {
    'Authorization': `Bearer ${process.env.SNAP_ACCESS_TOKEN}`,
    'Content-Type': 'application/json'
  }
});

Campaign Management

Create Campaign

async function createCampaign(adAccountId) {
  const response = await snapAPI.post(`adaccounts/${adAccountId}/campaigns`, {
    campaigns: [{
      name: 'Q1 Product Launch',
      ad_account_id: adAccountId,
      status: 'ACTIVE',
      objective: 'WEBSITE_CONVERSIONS',
      start_time: '2025-01-01T00:00:00.000-00:00',
      daily_budget_micro: 10000000000  // $10,000 in micro currency
    }]
  });

  return response.data;
}

Fetch Campaign Performance

async function getCampaignStats(campaignId) {
  const response = await snapAPI.get(`campaigns/${campaignId}/stats`, {
    params: {
      granularity: 'DAY',
      start_time: '2025-01-01T00:00:00.000-00:00',
      end_time: '2025-01-31T23:59:59.999-00:00',
      fields: [
        'impressions',
        'swipes',
        'spend',
        'conversion_purchases',
        'conversion_purchases_value'
      ].join(',')
    }
  });

  return response.data;
}

Audience Management

Create Segment (Custom Audience)

async function createCustomAudience(adAccountId, userList) {
  const response = await snapAPI.post(`adaccounts/${adAccountId}/segments`, {
    segments: [{
      name: 'Email List - Q1 2025',
      ad_account_id: adAccountId,
      source_type: 'FIRST_PARTY',
      retention_in_days: 180,
      description: 'Customer email list uploaded Q1 2025'
    }]
  });

  const segmentId = response.data.segments[0].segment.id;

  // Upload users to segment
  await uploadAudienceData(segmentId, userList);

  return response.data;
}

Upload User Data

const crypto = require('crypto');

function hashEmail(email) {
  return crypto.createHash('sha256')
    .update(email.toLowerCase().trim())
    .digest('hex');
}

async function uploadAudienceData(segmentId, emails) {
  const hashedEmails = emails.map(email => ({
    schema: ['EMAIL_SHA256'],
    data: [[hashEmail(email)]]
  }));

  const response = await snapAPI.post(`segments/${segmentId}/users`, {
    users: hashedEmails
  });

  return response.data;
}

Reporting API

Fetch Ad Performance

import requests
import os
from datetime import datetime

def get_ad_performance(ad_account_id, start_date, end_date):
    url = f'https://adsapi.snapchat.com/v1/adaccounts/{ad_account_id}/stats'

    headers = {
        'Authorization': f"Bearer {os.environ['SNAP_ACCESS_TOKEN']}",
        'Content-Type': 'application/json'
    }

    params = {
        'granularity': 'DAY',
        'start_time': start_date,
        'end_time': end_date,
        'fields': ','.join([
            'impressions',
            'swipes',
            'spend',
            'swipe_up_percent',
            'conversion_purchases',
            'conversion_purchases_value',
            'conversion_add_cart',
            'conversion_view_content'
        ])
    }

    response = requests.get(url, params=params, headers=headers)
    return response.json()

# Example usage
performance = get_ad_performance(
    ad_account_id='12345678-1234-1234-1234-123456789012',
    start_date='2025-01-01T00:00:00.000-00:00',
    end_date='2025-01-31T23:59:59.999-00:00'
)

Google Tag Manager Integration

Container Setup

  1. Create Snap Pixel ID Variable

    • Variables > New > Constant
    • Name: "Snap Pixel ID"
    • Value: Your pixel ID

  2. Create Base Pixel Tag

    • Tags > New > Custom HTML
    • Paste Snap Pixel base code
    • Trigger: All Pages

  3. Create Event Tags

    • Tags > New > Custom HTML
    • Add event tracking code
    • Trigger: Based on page or dataLayer events

DataLayer Integration

// Push to dataLayer on purchase
window.dataLayer = window.dataLayer || [];
dataLayer.push({
  'event': 'purchase',
  'transactionId': 'ORDER_12345',
  'transactionTotal': 199.98,
  'transactionCurrency': 'USD',
  'transactionProducts': [
    {
      'sku': 'SKU_123',
      'name': 'Blue Widget',
      'price': 99.99,
      'quantity': 2
    }
  ]
});

GTM Event Tag

<script>
snaptr('track', 'PURCHASE', {
  'price': {{Transaction Total}},
  'currency': {{Transaction Currency}},
  'transaction_id': {{Transaction ID}},
  'item_ids': {{Transaction Product SKUs}},
  'number_items': {{Transaction Product Count}}
});
</script>

Best Practices

Integration Strategy

  1. Start with Snap Pixel for browser-based tracking
  2. Add CAPI for server-side backup
  3. Implement deduplication with client_dedup_id
  4. Use platform integrations where available
  5. Test thoroughly before going live

Data Quality

  1. Hash all PII before sending (email, phone)
  2. Pass complete event parameters for optimization
  3. Match item_ids to product catalog exactly
  4. Include currency for all monetary values
  5. Use transaction_id for order identification

Privacy & Compliance

  1. Implement consent management for GDPR/CCPA
  2. Update privacy policy to disclose Snapchat tracking
  3. Honor user opt-outs through platform controls
  4. Use hashing for all personally identifiable information
  5. Audit data sharing regularly

Performance Optimization

  1. Load pixel asynchronously to avoid blocking
  2. Minimize custom events (prefer standard events)
  3. Batch API calls when possible
  4. Monitor Event Quality in Events Manager
  5. Test integrations with Snap Pixel Helper

Troubleshooting

Pixel Not Loading

  • Verify pixel ID is correct
  • Check for JavaScript errors in console
  • Ensure script loads before events fire
  • Test without ad blockers

Events Not Tracking

  • Wait 15-30 minutes for processing
  • Verify event names match standard events
  • Check Events Manager for errors
  • Validate event parameters

API Errors

  • Verify access token is valid (check expiration)
  • Check request format against API docs
  • Review rate limits
  • Validate required fields included

Integration Issues

  • Verify platform connection status
  • Check catalog sync settings
  • Review product mapping
  • Test with single product first

Resources

↑ Back to top
// SYS.FOOTER