Collect in a few lines and sign server events.

npm install @yourownmetric/sdk

import { YOM } from '@yourownmetric/sdk'

YOM.init({
  apiKey: 'yom_pk_live_…',          // publishable key from your dashboard
  consent: { default: 'unknown' },  // cookieless until granted
  autoCapture: {
    pageviews: true,
    engagement: true,
    errors: true,
    performance: true,
    ecommerce: true,
  },
})

// Call from your consent banner / CMP
YOM.setConsent({ analytics: true, marketing: false })

// GA4-aligned ecommerce helpers
YOM.ecommerce.viewItem({ item_id: 'SKU-1', price: 20 })
YOM.ecommerce.addToCart({ item_id: 'SKU-1', price: 20 }, 2)
YOM.ecommerce.purchase({
  transaction_id: '1043',
  value: 212.0,
  currency: 'USD',
})

// Lead / form conversion: never put contact details in the browser event
YOM.lead('contact-form')

// Any custom event (snake_case, up to 64 chars)
YOM.track('trial_started', { plan: 'pro' })

import { YOMProvider, useTrack } from '@yourownmetric/sdk/react'

export function App() {
  return (
    <YOMProvider
      config={{ apiKey: 'yom_pk_live_…', consent: { default: 'unknown' }, autoCapture: { pageviews: true } }}
    >
      {/* your routes: page views are captured on every route change */}
    </YOMProvider>
  )
}

function BuyButton() {
  const track = useTrack()
  return <button onClick={() => track('cta_click', { id: 'buy' })}>Buy</button>
}

import { YOMServer } from '@yourownmetric/sdk/node'

const yom = new YOMServer({
  secretKey: process.env.YOM_SECRET_KEY,   // yom_sk_… with the server scope
  // auth: 'hmac', keyId: 'key_…',         // sign instead of sending the key
})

yom.track({
  event: 'purchase',
  id: '1043',                              // same id as the browser purchase = counted once
  subTenant: 'client-a',                   // optional: platforms & agencies
  params: { transaction_id: '1043', value: 212.0, currency: 'USD' },
})

// Lead details belong server-side, where they can reach your CRM
yom.track({ event: 'generate_lead', params: { form_id: 'demo', email } })

process.on('SIGTERM', async () => {
  await yom.shutdown()                     // flushes the queue
})

curl -X POST https://ingest.yourownmetrics.aapastech.com/v2/events \
  -H "Authorization: Bearer $YOM_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -H "User-Agent: my-app/1.0" \
  -d '{
    "v": 2,
    "events": [{
      "e": "purchase",
      "id": "1043",
      "p": { "transaction_id": "1043", "value": 212.0, "currency": "USD" }
    }]
  }'

# HMAC instead of a bearer key: sign "<unix-ts>.<raw body>" with your secret key
BODY='{"v":2,"events":[{"e":"sign_up","id":"u-88"}]}'
TS=$(date +%s)
SIG=$(printf '%s.%s' "$TS" "$BODY" | openssl dgst -sha256 -hmac "$YOM_SECRET_KEY" -hex | sed 's/^.* //')

curl -X POST https://ingest.yourownmetrics.aapastech.com/v2/events \
  -H "YOM-Key-Id: $YOM_KEY_ID" \
  -H "YOM-Signature: t=$TS,v1=$SIG" \
  -H "Content-Type: application/json" \
  -d "$BODY"

import { verifyWebhook } from '@yourownmetric/sdk/node'

export async function POST(req: Request) {
  const raw = await req.text()                       // the RAW body, before JSON.parse
  const ok = await verifyWebhook(
    process.env.YOM_WEBHOOK_SECRET,                  // whsec_… shown once at creation
    req.headers.get('yom-signature'),
    raw,
  )
  if (!ok) return new Response('bad signature', { status: 401 })

  const eventId = req.headers.get('yom-event-id')    // stable across retries
  // if (await seen(eventId)) return new Response('ok')  ← dedupe here
  const payload = JSON.parse(raw)
  return new Response('ok')
}

import { createHmac, timingSafeEqual } from 'node:crypto'

// YOM-Signature: t=<unix>,v1=<hex hmac_sha256(secret, t + "." + body)>
export function verify(secret: string, header: string, rawBody: string) {
  const parts = Object.fromEntries(header.split(',').map((p) => p.trim().split('=')))
  const t = Number(parts.t)
  if (!t || Math.abs(Date.now() / 1000 - t) > 300) return false   // 5-minute tolerance
  const expected = createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex')
  const given = Buffer.from(parts.v1 ?? '', 'hex')
  return given.length === 32 && timingSafeEqual(given, Buffer.from(expected, 'hex'))
}