# Note: You need to encrypt the payload first using a script/tool
# See the Encryption Guide for JWE token creation

# 1. Create encrypted JWE token (using external tool/script)
ENCRYPTED_TOKEN="eyJhbGciOiJBMjU2S1ciL..."

# 2. Make API request
curl -X POST https://webhooks.sbx.moduluslabs.io/v1/webhooks \
  -u sk_your_secret_key: \
  -H "Content-Type: application/json" \
  -d "{\"request\": {\"Token\": \"$ENCRYPTED_TOKEN\"}}"

# 3. Response contains the created webhook object

const axios = require('axios');
const jose = require('jose');

const SECRET_KEY = process.env.MODULUS_SECRET_KEY;
const ENCRYPTION_KEY = process.env.MODULUS_ENCRYPTION_KEY;

async function createWebhook() {
  // 1. Prepare the payload
  const payload = {
    webhookAction: 'QRPH_SUCCESS',
    callbackUrl: 'https://api.yourcompany.com/webhooks/success'
  };

  // 2. Encrypt payload into JWE token
  const key = Buffer.from(ENCRYPTION_KEY, 'base64');
  const jweToken = await new jose.CompactEncrypt(
    new TextEncoder().encode(JSON.stringify(payload))
  )
    .setProtectedHeader({ alg: 'A256KW', enc: 'A256CBC-HS512' })
    .encrypt(key);

  // 3. Make API request
  const response = await axios.post(
    'https://webhooks.sbx.moduluslabs.io/v1/webhooks',
    { request: { Token: jweToken } },
    {
      auth: { username: SECRET_KEY, password: '' },
      headers: { 'Content-Type': 'application/json' }
    }
  );

  const result = response.data;
  console.log('Webhook created successfully');
  console.log('Webhook ID:', result.id);
  console.log('Webhook URL:', result.callbackUrl);
  console.log('Action:', result.webhookAction);
  console.log('Status:', result.webhookStatus);

  return result;
}

createWebhook()
  .catch(error => {
    console.error('Error:', error.response?.data || error.message);
  });

import os
import json
import requests
from jose import jwe

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')
ENCRYPTION_KEY = os.getenv('MODULUS_ENCRYPTION_KEY')

def create_webhook():
    # 1. Prepare the payload
    payload = {
        'webhookAction': 'QRPH_SUCCESS',
        'callbackUrl': 'https://api.yourcompany.com/webhooks/success'
    }

    # 2. Encrypt payload into JWE token
    jwe_token = jwe.encrypt(
        json.dumps(payload),
        ENCRYPTION_KEY,
        algorithm='A256KW',
        encryption='A256CBC-HS512'
    )

    # 3. Make API request
    response = requests.post(
        'https://webhooks.sbx.moduluslabs.io/v1/webhooks',
        json={'request': {'Token': jwe_token}},
        auth=(SECRET_KEY, ''),
        headers={'Content-Type': 'application/json'}
    )

    response.raise_for_status()

    result = response.json()
    print('Webhook created successfully')
    print(f"Webhook ID: {result['id']}")
    print(f"Webhook URL: {result['callbackUrl']}")
    print(f"Status: {result['webhookStatus']}")

    return result

if __name__ == '__main__':
    try:
        create_webhook()
    except Exception as e:
        print(f'Error: {str(e)}')

<?php
require 'vendor/autoload.php';

use Jose\Component\Core\AlgorithmManager;
use Jose\Component\Core\JWK;
use Jose\Component\Encryption\Algorithm\KeyEncryption\A256KW;
use Jose\Component\Encryption\Algorithm\ContentEncryption\A256CBCHS512;
use Jose\Component\Encryption\JWEBuilder;
use Jose\Component\Encryption\Serializer\CompactSerializer;

$secretKey = getenv('MODULUS_SECRET_KEY');
$encryptionKey = getenv('MODULUS_ENCRYPTION_KEY');

function createWebhook() {
    global $secretKey, $encryptionKey;

    // 1. Prepare the payload
    $payload = [
        'webhookAction' => 'QRPH_SUCCESS',
        'callbackUrl' => 'https://api.yourcompany.com/webhooks/success'
    ];

    // 2. Encrypt payload (simplified - use proper JWE library)
    // See encryption documentation for full implementation
    $jweToken = encryptToJWE(json_encode($payload), $encryptionKey);

    // 3. Make API request
    $ch = curl_init('https://webhooks.sbx.moduluslabs.io/v1/webhooks');
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['request' => ['Token' => $jweToken]]));
    curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 201) {
        $result = json_decode($response, true);
        echo "Webhook created successfully\n";
        echo "Webhook ID: {$result['id']}\n";
        echo "Webhook URL: {$result['callbackUrl']}\n";
        echo "Status: {$result['webhookStatus']}\n";
        return $result;
    } else {
        echo "Error: HTTP $httpCode\n";
        echo "Details: $response\n";
        return null;
    }
}

try {
    createWebhook();
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.*;
import com.nimbusds.jose.jwk.OctetSequenceKey;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.*;
import java.util.*;

public class CreateWebhookExample {
    private static final ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws Exception {
        createWebhook();
    }

    static void createWebhook() throws Exception {
        String secretKey = System.getenv("MODULUS_SECRET_KEY");
        String encryptionKey = System.getenv("MODULUS_ENCRYPTION_KEY");

        // 1. Prepare the payload
        Map<String, Object> payload = new LinkedHashMap<>();
        payload.put("webhookAction", "QRPH_SUCCESS");
        payload.put("callbackUrl", "https://api.yourcompany.com/webhooks/success");

        String payloadJson = mapper.writeValueAsString(payload);

        // 2. Encrypt payload into JWE token
        byte[] keyBytes = Base64.getUrlDecoder().decode(encryptionKey);
        OctetSequenceKey jwk = new OctetSequenceKey.Builder(keyBytes).build();

        JWEHeader header = new JWEHeader(JWEAlgorithm.A256KW, EncryptionMethod.A256CBC_HS512);
        JWEObject jwe = new JWEObject(header, new Payload(payloadJson));
        jwe.encrypt(new AESEncrypter(jwk));
        String jweToken = jwe.serialize();

        // 3. Make API request with Basic Auth
        HttpClient client = HttpClient.newHttpClient();
        String auth = secretKey + ":";
        String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes());

        String requestBody = mapper.writeValueAsString(Map.of("request", Map.of("Token", jweToken)));

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://webhooks.sbx.moduluslabs.io/v1/webhooks"))
            .header("Authorization", "Basic " + encodedAuth)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 201) {
            Map<String, Object> result = mapper.readValue(response.body(), Map.class);
            System.out.println("Webhook created successfully");
            System.out.println("Webhook ID: " + result.get("id"));
            System.out.println("Webhook URL: " + result.get("callbackUrl"));
            System.out.println("Status: " + result.get("webhookStatus"));
        } else {
            System.out.println("Error: HTTP " + response.statusCode());
            System.out.println("Details: " + response.body());
        }
    }
}

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"

	"github.com/lestrrat-go/jwx/v2/jwa"
	"github.com/lestrrat-go/jwx/v2/jwe"
)

type WebhookPayload struct {
	WebhookAction string `json:"webhookAction"`
	CallbackUrl   string `json:"callbackUrl"`
}

type TokenWrapper struct {
	Token string `json:"Token"`
}

type TokenRequest struct {
	Request TokenWrapper `json:"request"`
}

type WebhookResponse struct {
	ID            string `json:"id"`
	WebhookAction string `json:"webhookAction"`
	WebhookStatus string `json:"webhookStatus"`
	CallbackUrl   string `json:"callbackUrl"`
}

func main() {
	if err := createWebhook(); err != nil {
		fmt.Printf("Error: %v\n", err)
	}
}

func createWebhook() error {
	secretKey := os.Getenv("MODULUS_SECRET_KEY")
	encryptionKey := os.Getenv("MODULUS_ENCRYPTION_KEY")

	// 1. Prepare the payload
	payload := WebhookPayload{
		WebhookAction: "QRPH_SUCCESS",
		CallbackUrl:   "https://api.yourcompany.com/webhooks/success",
	}

	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return fmt.Errorf("failed to marshal payload: %w", err)
	}

	// 2. Encrypt payload into JWE token
	keyBytes, err := base64.RawURLEncoding.DecodeString(encryptionKey)
	if err != nil {
		return fmt.Errorf("failed to decode encryption key: %w", err)
	}

	encrypted, err := jwe.Encrypt(payloadJSON,
		jwe.WithKey(jwa.A256KW, keyBytes),
		jwe.WithContentEncryption(jwa.A256CBC_HS512),
	)
	if err != nil {
		return fmt.Errorf("failed to encrypt payload: %w", err)
	}
	jweToken := string(encrypted)

	// 3. Make API request with Basic Auth
	reqBody := TokenRequest{Request: TokenWrapper{Token: jweToken}}
	jsonData, _ := json.Marshal(reqBody)

	req, err := http.NewRequest("POST", "https://webhooks.sbx.moduluslabs.io/v1/webhooks", bytes.NewBuffer(jsonData))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}

	req.SetBasicAuth(secretKey, "")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)

	if resp.StatusCode == 201 {
		var result WebhookResponse
		json.Unmarshal(body, &result)
		fmt.Println("Webhook created successfully")
		fmt.Printf("Webhook ID: %s\n", result.ID)
		fmt.Printf("Webhook URL: %s\n", result.CallbackUrl)
		fmt.Printf("Status: %s\n", result.WebhookStatus)
		return nil
	}

	return fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
}

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

namespace ModulusWebhooks;

class Program
{
    static async Task Main(string[] args)
    {
        await CreateWebhook();
    }

    static byte[] Base64UrlDecode(string base64Url)
    {
        var base64 = base64Url
            .Replace('-', '+')
            .Replace('_', '/');

        switch (base64.Length % 4)
        {
            case 2: base64 += "=="; break;
            case 3: base64 += "="; break;
        }

        return Convert.FromBase64String(base64);
    }

    static async Task CreateWebhook()
    {
        var secretKey = Environment.GetEnvironmentVariable("MODULUS_SECRET_KEY");
        var encryptionKey = Environment.GetEnvironmentVariable("MODULUS_ENCRYPTION_KEY");

        if (string.IsNullOrEmpty(secretKey) || string.IsNullOrEmpty(encryptionKey))
        {
            Console.WriteLine("Error: MODULUS_SECRET_KEY and MODULUS_ENCRYPTION_KEY must be set");
            return;
        }

        try
        {
            // 1. Prepare the payload
            var payload = new
            {
                webhookAction = "QRPH_SUCCESS",
                callbackUrl = "https://api.yourcompany.com/webhooks/success"
            };

            // 2. Encrypt payload into JWE token
            var key = Base64UrlDecode(encryptionKey);
            var payloadJson = JsonSerializer.Serialize(payload);
            var jweToken = JWT.Encode(
                payloadJson,
                key,
                JweAlgorithm.A256KW,
                JweEncryption.A256CBC_HS512
            );

            // 3. Make API request with Basic Auth
            using var client = new HttpClient();
            var authBytes = Encoding.ASCII.GetBytes($"{secretKey}:");
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authBytes));

            var requestBody = new { request = new { Token = jweToken } };
            var content = new StringContent(
                JsonSerializer.Serialize(requestBody),
                Encoding.UTF8,
                "application/json"
            );

            var response = await client.PostAsync(
                "https://webhooks.sbx.moduluslabs.io/v1/webhooks",
                content
            );

            var responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                var result = JsonSerializer.Deserialize<WebhookResponse>(
                    responseBody,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                );

                Console.WriteLine("Webhook created successfully");
                Console.WriteLine($"Webhook ID: {result?.Id}");
                Console.WriteLine($"Webhook URL: {result?.CallbackUrl}");
                Console.WriteLine($"Action: {result?.WebhookAction}");
                Console.WriteLine($"Status: {result?.WebhookStatus}");
            }
            else
            {
                Console.WriteLine($"Error: HTTP {(int)response.StatusCode}");
                Console.WriteLine($"Details: {responseBody}");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

public class WebhookResponse
{
    public string? Id { get; set; }
    public string? CallbackUrl { get; set; }
    public string? WebhookAction { get; set; }
    public string? WebhookStatus { get; set; }
}

{
  "id": "a78efd32-de3b-4854-b599-11ae9f98f97e",
  "webhookAction": "QRPH_SUCCESS",
  "webhookStatus": "ENABLED",
  "callbackUrl": "https://api.yourcompany.com/webhooks/success"
}

{
  "code": "20000002",
  "error": "Invalid callbackUrl: must be a valid HTTPS URL",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "10000013",
  "error": "Invalid API Key",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "20000003",
  "error": "Webhook URL already exists",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "10000001",
  "error": "An unexpected error occurred. Please try again later.",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}