Snapchat Conversions API for F2F creators

Why Snapchat needs server-side tracking

Snapchat's audience skews young and mobile-first, which makes it a strong channel for many F2F creators. It also means nearly all traffic is iOS or Android in-app browser traffic, the environment where pixels perform worst. When a fan swipes up on a Snap ad, the destination opens inside Snapchat's own browser. If the fan subscribes later on F2F.com in Safari or Chrome, the Snap Pixel never sees it, and Snapchat's algorithm receives no signal that the ad worked.

The Snapchat Conversions API (CAPI) closes that gap. F2F API records the ScCid click identifier on your tracking link, then sends the eventual subscription, tip or PPV purchase to Snapchat from the server, with hashed identifiers that Snap can match to the original Snapchatter. Snap uses these events for attribution, reporting and campaign optimization, including its Pixel Purchase and Value optimization goals.

Because the event is sent server-to-server, it is not affected by ad blockers or by browser cookie restrictions, and it arrives even when the purchase happens in a completely different browser from the click.

Core identifiers

• ScCid: the Snapchat click ID appended to ad destination URLs. Store it immediately and send it as click_id.
• _scid: the Snap Pixel browser cookie. Send it as uuid_c1 when the Pixel runs on your link page.
• Snap Pixel ID: the UUID of the pixel receiving events.
• Snap CAPI token: a long-lived access token generated in Business Manager for server-side events.
• Hashed email and phone: normalized and SHA-256 hashed, sent as hashed_email and hashed_phone_number.
• Client IP and user agent: captured at click time; the IP is sent hashed as hashed_ip_address and the user agent is sent as user_agent.

Note that unlike Meta, Snapchat expects the IP address to be hashed in v2 payloads. F2F API applies the correct treatment for each network automatically, so you never have to remember which fields are hashed where.

Step 1: Create the Snap Pixel and CAPI token

1. In Snapchat Ads Manager, open Events Manager and create a new Web Pixel for the creator.
2. Copy the Pixel ID, a UUID such as a1b2c3d4-5678-90ab-cdef-1234567890ab.
3. Open Business Details, then select Conversions API Tokens, and generate a new token. Store it securely; it grants write access to every pixel in the organization.
4. In your F2F API dashboard, open Ads Tracking, choose Snapchat, and paste the Pixel ID and token.

If you manage many creators, create a separate pixel per creator inside the same organization. One CAPI token can write to all of them, and F2F API routes each event to the right pixel by creator.

Step 2: Capture ScCid on your tracking link

Snapchat appends ScCid to the landing URL on every ad click. Capture it server-side on the first request and keep it in a first-party cookie for 90 days, then forward it to F2F API with the click record:

# Verify your tracking link sets the first-party _sccid cookie
curl -I "https://link.yourdomain.com/go/creator?ScCid=TEST_CLICK_123"

# Expected response header:
# Set-Cookie: _sccid=TEST_CLICK_123; Path=/; Max-Age=7776000; SameSite=Lax; Secure

Parameter names are case sensitive. Some link shorteners and redirect services lowercase query strings, turning ScCid into sccid. If you see clicks without click IDs, check that every hop in your redirect chain preserves the original query string exactly.

Step 3: Hash personal data correctly

Snapchat rejects or fails to match events whose identifiers are not normalized before hashing. These are the rules F2F API applies, and the rules you should follow if you ever send events directly:

• Email: trim whitespace, convert to lowercase, then SHA-256 hash. Fan@Example.com becomes the hash of fan@example.com.
• Phone: remove spaces, dashes and brackets, include the country code without the plus sign or leading zeros, then hash. +1 (555) 123-4567 becomes the hash of 15551234567.
• IP address: hash the plain IPv4 or IPv6 string.
• Never double hash. If a value already looks like a 64-character hex string, it is sent as is.

Hashing happens inside F2F API before any data leaves the platform. Snapchat never receives raw emails or phone numbers.

Step 4: Event mapping

F2F API maps F2F actions to Snapchat standard events:

• PAGE_VIEW: tracking link visit.
• SIGN_UP: free follow or email capture.
• SUBSCRIBE: new paid subscription on F2F.
• PURCHASE: PPV unlock, tip or renewal, sent with price and currency.

You can send a conversion manually through F2F API, which is useful for testing or for custom funnels:

curl -X POST "https://api.apif2f.com/v1/capi/conversions" \
  -H "Authorization: Bearer $F2F_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "creator_id": "crt_8f2a91",
    "networks": [
      "snapchat"
    ],
    "event_name": "PURCHASE",
    "event_id": "evt_9d2e4a",
    "value": 15,
    "currency": "USD",
    "user_data": {
      "email": "fan@example.com",
      "sc_click_id": "c8f1e2d3-ScCid-example",
      "scid": "a7b6c5d4-e3f2",
      "client_ip_address": "203.0.113.24",
      "client_user_agent": "Mozilla/5.0 (Android 15)"
    }
  }'

Step 5: Deduplicate with client_dedup_id

If the Snap Pixel fires on your link page and the same conversion is also sent server-side, Snapchat needs a way to recognize them as one event. Pass the same identifier in both places: the Pixel's client_dedup_id parameter in the browser and client_dedup_id in the server payload. Snapchat deduplicates matching events within 48 hours. Generate the ID on your server as a UUID and pass it to the page template so the Pixel can use it.

For purchases that happen on F2F.com, F2F API derives the deduplication ID from the F2F transaction ID. Retries of the same transaction, for example after a temporary network failure, are therefore never counted twice.

Step 6: Validate in Events Manager

Open your pixel in Snapchat Events Manager and select the Test Events tab, or use the Event Quality view. Send a few test conversions through F2F API with test mode enabled. Within a few minutes you should see each event with its name, value, currency and the list of matched identifiers. Check that click IDs are present for ad traffic, that hashed email appears on purchase events, and that deduplicated events are flagged.

After going live, monitor the Event Quality score and the Diagnostics panel. F2F API request logs record every Snapchat response, including validation errors returned in the response body, so you can trace any rejected event back to the exact transaction that caused it.

Event Quality and optimization

Snapchat's delivery system needs consistent signal volume to optimize well. Aim for at least 50 conversions per week per ad set on your chosen optimization event. Smaller accounts often optimize for SUBSCRIBE first and switch to PURCHASE with value once enough data accumulates. Sending renewals as PURCHASE events with their actual value helps Snapchat learn which audiences produce long-term spenders.

Going live checklist

Run through these checks for every new creator before scaling Snapchat spend. Each step takes a minute and together they prevent the most common attribution gaps.

1. Tap a live Snap ad on a real device and confirm the landing request reaches your server with ScCid intact and correctly cased.
2. Check that the response sets the _sccid cookie on your domain for 90 days.
3. Open the F2F API click log and verify the click ID, IP address and user agent were recorded against the visit.
4. Send a test PURCHASE through F2F API in test mode and confirm it appears in Events Manager with click ID and hashed email matched.
5. Disable test mode and compare Snapchat reported purchases with the F2F API conversion report after two days.

Small differences between the two reports are expected, because Snapchat only credits conversions within its attribution window (28-day click and 1-day view by default) and only for Snapchatters it can match. Large differences usually mean click IDs are being lost before the cookie is set, most often because of a redirect service that rewrites query strings.

How F2F API handles delivery failures

Temporary errors from Snapchat, such as timeouts or rate limits, are retried with exponential backoff for up to 24 hours using the same deduplication ID, so a delayed success is never counted twice. Permanent errors such as a revoked token stop immediately and trigger a dashboard alert and a capi.delivery_failed webhook. You can replay any failed event from the request log once the underlying issue is fixed, as long as it is still inside Snapchat's seven day acceptance window.

Every delivery attempt is visible in the log with the full request, the hashed identifiers that were sent and the response Snapchat returned, which makes support conversations with Snap quick and concrete.

Troubleshooting

Privacy

Show a clear cookie notice on your link pages and skip click ID storage for visitors who decline. Snapchat's terms require that you have the right to share the identifiers you send. F2F API hashes all personal identifiers, supports per-pixel field controls, and never stores raw fan emails in event logs.