Server-to-server Conversions API

const context = window.thradTag.getServerContext();
await fetch("/api/complete-order", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ orderId, context }),
});

POST https://events.thrad.ai/v1/api/events
Authorization: Bearer <THRAD_EVENTS_API_KEY>
Content-Type: application/json

curl -X POST https://events.thrad.ai/v1/api/events \
  -H "Authorization: Bearer $THRAD_EVENTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "version": 1,
    "tag_id": "adv_example_123",
    "events": [{
      "event_id": "order_12345",
      "event_name": "order_created",
      "timestamp_ms": 1773892800000,
      "action_source": "web",
      "source_url": "https://shop.example.com/checkout/confirmation",
      "context": { "version": 1, "oppref": "oppref_abc" },
      "user": {
        "emails_sha256": ["b4c9a289323b21a01c3e940f150eb9b8c542587f1abfd8f0e1cc1ffc5e475514"],
        "countries": ["US"]
      },
      "data": {
        "type": "contents",
        "amount": 2599,
        "currency": "USD",
        "contents": [{ "id": "sku_123", "quantity": 1 }]
      }
    }]
  }'

{
  "version": 1,
  "request_id": "req_...",
  "test_mode": false,
  "results": [
    {
      "index": 0,
      "event_id": "order_12345",
      "status": "accepted",
      "errors": [],
      "warnings": []
    }
  ]
}

{
  "user": {
    "emails": ["customer@example.com"],
    "phone_numbers": ["+1 (415) 555-0123"],
    "external_ids": ["customer-123"]
  }
}

import { createHash } from "node:crypto";

const sha256 = (value) => createHash("sha256").update(value, "utf8").digest("hex");
const normalizeEmail = (value) => value.trim().toLowerCase();
const normalizePhone = (value) => {
  const normalized = value.trim().replace(/[\s().-]/g, "").replace(/^(?:\+|00)/, "");
  if (!/^[1-9]\d{7,14}$/.test(normalized)) throw new Error("Use an international phone number");
  return normalized;
};
const normalizeExternalId = (value) => value.trim();
const asciiPunctuation = new Set('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~');
const normalizeName = (value) => [...value.trim().toLowerCase()]
  .filter((character) => !/\s/u.test(character) && !asciiPunctuation.has(character))
  .join("");

const emailHash = sha256(normalizeEmail(email));
const phoneHash = sha256(normalizePhone(phone));
const externalIdHash = sha256(normalizeExternalId(externalId));
const firstNameHash = sha256(normalizeName(firstName));

import hashlib
import re
import string

sha256 = lambda value: hashlib.sha256(value.encode("utf-8")).hexdigest()
normalize_email = lambda value: value.strip().lower()
def normalize_phone(value):
    normalized = re.sub(r"^(?:\+|00)|[\s().-]", "", value.strip())
    if re.fullmatch(r"[1-9][0-9]{7,14}", normalized) is None:
        raise ValueError("Use an international phone number")
    return normalized

normalize_external_id = lambda value: value.strip()
normalize_name = lambda value: "".join(
    char for char in value.strip().lower()
    if not char.isspace() and char not in string.punctuation
)

email_hash = sha256(normalize_email(email))
phone_hash = sha256(normalize_phone(phone))
external_id_hash = sha256(normalize_external_id(external_id))
first_name_hash = sha256(normalize_name(first_name))

$sha256 = fn(string $value): string => hash('sha256', $value);
$normalizeEmail = fn(string $value): string => strtolower(trim($value));
$normalizePhone = function (string $value): string {
  $normalized = preg_replace('/^\\+|^00|[\\s().-]/', '', trim($value));
  if (!preg_match('/^[1-9][0-9]{7,14}$/', $normalized)) {
    throw new InvalidArgumentException('Use an international phone number');
  }
  return $normalized;
};
$normalizeExternalId = fn(string $value): string => trim($value);
$normalizeName = fn(string $value): string => str_replace(
  str_split("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"),
  '',
  preg_replace('/\\s+/', '', strtolower(trim($value)))
);

$emailHash = $sha256($normalizeEmail($email));
$phoneHash = $sha256($normalizePhone($phone));
$externalIdHash = $sha256($normalizeExternalId($externalId));
$firstNameHash = $sha256($normalizeName($firstName));

purchase:v1: + lowercase SHA256(UTF8(compact JSON [trim(tag_id), normalized_order_id]))

import { createHash } from "node:crypto";

function purchaseEventId(tagId, orderId) {
  if (typeof tagId !== "string" || typeof orderId !== "string") {
    throw new Error("Tag ID and final order ID must be strings");
  }
  const tag = tagId.trim();
  const order = orderId.trim().replace(/^gid:\/\/shopify\/Order\/([1-9][0-9]*)$/, "$1");
  if (!tag || !order) throw new Error("Tag ID and final order ID are required");
  return "purchase:v1:" + createHash("sha256")
    .update(JSON.stringify([tag, order]), "utf8").digest("hex");
}

const eventId = purchaseEventId(tagId, finalShopifyOrderId);