Partner Event API

import { createHmac, randomUUID } from "node:crypto";

const keyId = process.env.MEETROAS_KEY_ID;
const secret = process.env.MEETROAS_SECRET;
if (!keyId || !secret) throw new Error("Missing MeetROAS credentials");

const body = JSON.stringify({
  event_id: `test-${randomUUID()}`,
  mr_click_id: "mrc_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
  event: "purchase",
  occurred_at: new Date().toISOString(),
  value: 49.95,
  currency: "USD",
});
const timestamp = String(Math.floor(Date.now() / 1000));
const digest = createHmac("sha256", secret)
  .update(`${timestamp}.${body}`, "utf8")
  .digest("hex");

const response = await fetch("https://api.meetroas.com/v1/events/validate", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-MeetROAS-Key": keyId,
    "X-MeetROAS-Timestamp": timestamp,
    "X-MeetROAS-Signature": `v1=${digest}`,
  },
  body,
});
console.log(response.status, await response.text());

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.UUID;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class MeetROASExample {
  public static void main(String[] args) throws Exception {
    String keyId = requireEnv("MEETROAS_KEY_ID");
    String secret = requireEnv("MEETROAS_SECRET");
    String body = String.format(
      "{\"event_id\":\"test-%s\",\"mr_click_id\":\"mrc_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\"," +
      "\"event\":\"purchase\",\"occurred_at\":\"%s\",\"value\":49.95,\"currency\":\"USD\"}",
      UUID.randomUUID(), Instant.now());
    String timestamp = Long.toString(Instant.now().getEpochSecond());
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
    byte[] digest = mac.doFinal((timestamp + "." + body).getBytes(StandardCharsets.UTF_8));
    StringBuilder hex = new StringBuilder();
    for (byte value : digest) hex.append(String.format("%02x", value & 0xff));
    HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.meetroas.com/v1/events/validate"))
      .header("Content-Type", "application/json")
      .header("X-MeetROAS-Key", keyId)
      .header("X-MeetROAS-Timestamp", timestamp)
      .header("X-MeetROAS-Signature", "v1=" + hex)
      .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8)).build();
    HttpResponse<String> response = HttpClient.newHttpClient()
      .send(request, HttpResponse.BodyHandlers.ofString());
    System.out.println(response.statusCode() + " " + response.body());
  }
  private static String requireEnv(String name) {
    String value = System.getenv(name);
    if (value == null || value.isBlank()) throw new IllegalStateException("Missing " + name);
    return value;
  }
}

package main

import (
  "bytes"
  "crypto/hmac"
  "crypto/sha256"
  "encoding/hex"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
  "strconv"
  "time"
)

type event struct {
  EventID string `json:"event_id"`
  ClickID string `json:"mr_click_id"`
  Event string `json:"event"`
  OccurredAt string `json:"occurred_at"`
  Value float64 `json:"value"`
  Currency string `json:"currency"`
}

func main() {
  keyID, secret := os.Getenv("MEETROAS_KEY_ID"), os.Getenv("MEETROAS_SECRET")
  if keyID == "" || secret == "" { panic("missing MeetROAS credentials") }
  body, err := json.Marshal(event{
    "test-" + strconv.FormatInt(time.Now().UnixNano(), 10), "mrc_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
    "purchase", time.Now().UTC().Format(time.RFC3339), 49.95, "USD",
  })
  if err != nil { panic(err) }
  timestamp := strconv.FormatInt(time.Now().Unix(), 10)
  mac := hmac.New(sha256.New, []byte(secret))
  mac.Write(append([]byte(timestamp+"."), body...))
  req, err := http.NewRequest("POST", "https://api.meetroas.com/v1/events/validate", bytes.NewReader(body))
  if err != nil { panic(err) }
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("X-MeetROAS-Key", keyID)
  req.Header.Set("X-MeetROAS-Timestamp", timestamp)
  req.Header.Set("X-MeetROAS-Signature", "v1="+hex.EncodeToString(mac.Sum(nil)))
  response, err := http.DefaultClient.Do(req)
  if err != nil { panic(err) }
  defer response.Body.Close()
  responseBody, _ := io.ReadAll(response.Body)
  fmt.Printf("%d %s\n", response.StatusCode, responseBody)
}

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

var keyId = RequireEnv("MEETROAS_KEY_ID");
var secret = RequireEnv("MEETROAS_SECRET");
var body = JsonSerializer.Serialize(new {
  event_id = $"test-{Guid.NewGuid()}",
  mr_click_id = "mrc_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
  @event = "purchase",
  occurred_at = DateTimeOffset.UtcNow.ToString("O"),
  value = 49.95,
  currency = "USD",
});
var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
var digest = hmac.ComputeHash(Encoding.UTF8.GetBytes($"{timestamp}.{body}"));
using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.meetroas.com/v1/events/validate");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");
request.Headers.Add("X-MeetROAS-Key", keyId);
request.Headers.Add("X-MeetROAS-Timestamp", timestamp);
request.Headers.Add("X-MeetROAS-Signature", $"v1={Convert.ToHexString(digest).ToLowerInvariant()}");
using var response = await new HttpClient().SendAsync(request);
Console.WriteLine($"{(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");

static string RequireEnv(string name) => Environment.GetEnvironmentVariable(name)
  ?? throw new InvalidOperationException($"Missing {name}");