Traffic Orchestrator API

curl -X POST https://api.trafficorchestrator.com/api/v1/validate   -H "Authorization: Bearer to_live_xxxxxxxxxxxxx"   -H "Content-Type: application/json"   -d '{"key": "XXXX-XXXX-XXXX-XXXX", "domain": "example.com"}'

const res = await fetch('https://api.trafficorchestrator.com/api/v1/validate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ key: 'XXXX-XXXX-XXXX-XXXX' })
});

const { valid, license } = await res.json();

if (valid) {
  console.log('License is valid!', license.status);
  // Enable premium features
} else {
  console.error('License validation failed');
}

Authorization: Bearer to_live_xxxxxxxxxxxxx

{
  "valid": true,
  "license": {
    "id": "lic_1234567890",
    "key": "XXXX-XXXX-XXXX-XXXX",
    "status": "active",
    "type": "perpetual",
    "activations": 2,
    "maxActivations": 5,
    "expiresAt": null,
    "metadata": {}
  },
  "validatedAt": "2024-01-15T12:00:00Z"
}

const API_KEY = 'to_live_xxxxxxxxxxxxx';
const BASE = 'https://api.trafficorchestrator.com';

// Validate a license
const res = await fetch(BASE + '/api/v1/validate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    key: 'XXXX-XXXX-XXXX-XXXX',
    domain: 'example.com'
  })
});

const { valid, license } = await res.json();
console.log(valid, license);

const activation = await fetch(BASE + '/api/v1/activate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    license_key: 'XXXX-XXXX-XXXX-XXXX',
    machine_id: 'unique-device-fingerprint'
  })
}).then(r => r.json());

{
  "event": "license.activated",
  "timestamp": "2024-01-15T12:00:00Z",
  "data": {
    "licenseId": "lic_1234567890",
    "machineId": "mach_abcdef",
    "productId": "prod_123"
  }
}

// Node.js / Express
import crypto from 'crypto'

const verifyWebhook = (req, secret) => {
  const signature = req.headers['x-to-signature']
  const timestamp = req.headers['x-to-timestamp']
  const body = JSON.stringify(req.body)

  // Reject if timestamp is older than 5 minutes
  if (Date.now() / 1000 - Number(timestamp) > 300) {
    return false
  }

  const expected = crypto
    .createHmac('sha256', secret)
    .update(timestamp + '.' + body)
    .digest('hex')

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  )
}

app.post('/webhooks/to', (req, res) => {
  if (!verifyWebhook(req, process.env.WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Invalid signature' })
  }
  // Process the webhook event
  console.log('Event:', req.body.event)
  res.status(200).json({ received: true })
})

# Python / Flask
import hmac, hashlib, time
from flask import Flask, request, jsonify

app = Flask(__name__)

def verify_webhook(req, secret):
    signature = req.headers.get('X-TO-Signature', '')
    timestamp = req.headers.get('X-TO-Timestamp', '0')

    # Reject if older than 5 minutes
    if time.time() - int(timestamp) > 300:
        return False

    expected = hmac.new(
        secret.encode(), f"{timestamp}.{req.get_data(as_text=True)}".encode(),
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(signature, expected)

@app.route('/webhooks/to', methods=['POST'])
def handle_webhook():
    if not verify_webhook(request, WEBHOOK_SECRET):
        return jsonify(error='Invalid signature'), 401

    event = request.json
    print(f"Event: {event['event']}")
    return jsonify(received=True), 200

// PHP
$secret    = getenv('WEBHOOK_SECRET');
$signature = $_SERVER['HTTP_X_TO_SIGNATURE'] ?? '';
$timestamp = $_SERVER['HTTP_X_TO_TIMESTAMP'] ?? '0';
$body      = file_get_contents('php://input');

// Reject if older than 5 minutes
if (time() - (int)$timestamp > 300) {
    http_response_code(401);
    exit(json_encode(['error' => 'Timestamp expired']));
}

$expected = hash_hmac('sha256', "{$timestamp}.{$body}", $secret);

if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    exit(json_encode(['error' => 'Invalid signature']));
}

$event = json_decode($body, true);
error_log("Event: " . $event['event']);
http_response_code(200);
echo json_encode(['received' => true]);

{
  "license": {
    "id": "lic_abc123def456",
    "key": "ABCD-EFGH-IJKL-MNOP",
    "productId": "prod_123",
    "type": "subscription",
    "status": "active",
    "maxActivations": 3,
    "createdAt": "2024-01-15T12:00:00Z"
  }
}

import requests

API_KEY = "to_live_xxxxxxxxxxxxx"
BASE = "https://api.trafficorchestrator.com"

# Validate a license
response = requests.post(
    f"{BASE}/api/v1/validate",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"key": "XXXX-XXXX-XXXX-XXXX", "domain": "example.com"}
)

data = response.json()
if data["valid"]:
    print("License is valid!")
else:
    print("Validation failed")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]string{
        "key":    "XXXX-XXXX-XXXX-XXXX",
        "domain": "example.com",
    })

    req, _ := http.NewRequest("POST",
        "https://api.trafficorchestrator.com/api/v1/validate",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer to_live_xxxxxxxxxxxxx")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { return }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println("Valid:", result["valid"])
}

<?php

$ch = curl_init('https://api.trafficorchestrator.com/api/v1/validate');

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer to_live_xxxxxxxxxxxxx',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'key'    => 'XXXX-XXXX-XXXX-XXXX',
        'domain' => 'example.com',
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
echo 'Valid: ' . ($result['valid'] ? 'yes' : 'no');

require 'net/http'
require 'json'

uri = URI('https://api.trafficorchestrator.com/api/v1/validate')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer to_live_xxxxxxxxxxxxx'
req['Content-Type']  = 'application/json'
req.body = { key: 'XXXX-XXXX-XXXX-XXXX', domain: 'example.com' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

result = JSON.parse(res.body)
puts "Valid: #{result['valid']}"

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer to_live_xxxxxxxxxxxxx");

var body = new StringContent(
    JsonSerializer.Serialize(new { key = "XXXX-XXXX-XXXX-XXXX", domain = "example.com" }),
    Encoding.UTF8, "application/json");

var response = await client.PostAsync(
    "https://api.trafficorchestrator.com/api/v1/validate", body);

var json = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize<JsonElement>(json);
Console.WriteLine($"Valid: {result.GetProperty("valid")}");

use reqwest::Client;
use serde_json::json;

let client = Client::new();
let res = client
    .post("https://api.trafficorchestrator.com/api/v1/validate")
    .header("Authorization", "Bearer to_live_xxxxxxxxxxxxx")
    .json(&json!({
        "key": "XXXX-XXXX-XXXX-XXXX",
        "domain": "example.com"
    }))
    .send()
    .await?
    .json::<serde_json::Value>()
    .await?;

println!("Valid: {}", res["valid"]);

// main.ts — Electron main process
import { app, BrowserWindow, dialog } from 'electron';

const API_KEY = 'to_live_xxxxxxxxxxxxx';

app.on('ready', async () => {
  const key = store.get('licenseKey');

  const res = await fetch(
    'https://api.trafficorchestrator.com/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ key })
  });

  const { valid } = await res.json();

  if (!valid) {
    dialog.showErrorBox('License Required', 'Please enter a valid license.');
    return;
  }

  // License valid — launch main window
  const win = new BrowserWindow({ width: 1200, height: 800 });
  win.loadFile('index.html');
});

// hooks/useLicense.ts
import { useState, useEffect } from 'react';

export function useLicense(licenseKey: string) {
  const [isValid, setIsValid] = useState(false);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch('/api/validate', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ license_key: licenseKey })
    })
    .then(r => r.json())
    .then(data => {
      setIsValid(data.valid);
      setLoading(false);
    });
  }, [licenseKey]);

  return { isValid, loading };
}

// Usage in a component
function PremiumFeature() {
  const { isValid, loading } = useLicense('XXXX-XXXX-XXXX-XXXX');

  if (loading) return <Spinner />;
  if (!isValid) return <UpgradePrompt />;

  return <div>Premium content here</div>;
}

// app/api/validate/route.ts
import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const { licenseKey, domain } = await req.json();

  const res = await fetch(
    'https://api.trafficorchestrator.com/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + process.env.TO_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ key: licenseKey, domain })
  });

  const result = await res.json();
  return NextResponse.json(result);
}

// Stripe webhook handler
import Stripe from 'stripe';

const TO_API_KEY = process.env.TO_API_KEY;

app.post('/webhook', async (req, res) => {
  const event = stripe.webhooks.constructEvent(
    req.body, req.headers['stripe-signature'], webhookSecret
  );

  if (event.type === 'checkout.session.completed') {
    const session = event.data.object;

    // Create license via REST API
    await fetch('https://api.trafficorchestrator.com/api/v1/portal/licenses', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ' + TO_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        product: session.metadata.product_id,
        plan: 'pro',
        customer_email: session.customer_email,
        metadata: {
          stripeCustomerId: session.customer,
          stripeSubscriptionId: session.subscription
        }
      })
    });
  }

  res.json({ received: true });
});