curl https://webhooks.sbx.moduluslabs.io/v1/webhooks \
  -u sk_your_secret_key:

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 getWebhooks() {
  try {
    // Decode encryption key from base64
    const key = Buffer.from(ENCRYPTION_KEY, 'base64');

    const response = await axios.get(
      'https://webhooks.sbx.moduluslabs.io/v1/webhooks',
      {
        auth: {
          username: SECRET_KEY,
          password: ''
        }
      }
    );

    // Decrypt the response token
    const { plaintext } = await jose.compactDecrypt(
      response.data.response.Token,
      key
    );
    const webhooks = JSON.parse(new TextDecoder().decode(plaintext));

    console.log(`Found ${webhooks.length} webhook(s)`);

    webhooks.forEach(webhook => {
      console.log('\nWebhook ID:', webhook.id);
      console.log('URL:', webhook.callbackUrl);
      console.log('Action:', webhook.webhookAction);
      console.log('Status:', webhook.webhookStatus);
    });

    return webhooks;
  } catch (error) {
    if (error.response) {
      console.error('Error:', error.response.status);
      console.error('Details:', error.response.data);
    } else {
      console.error('Request failed:', error.message);
    }
    throw error;
  }
}

getWebhooks();

import requests
import os

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')

def get_webhooks():
    try:
        response = requests.get(
            'https://webhooks.sbx.moduluslabs.io/v1/webhooks',
            auth=(SECRET_KEY, '')
        )

        response.raise_for_status()

        data = response.json()
        webhooks = data['webhooks']

        print(f"Found {len(webhooks)} webhook(s)")

        for webhook in webhooks:
            print(f"\nWebhook ID: {webhook['id']}")
            print(f"URL: {webhook['webhookUrl']}")
            print(f"Actions: {', '.join(webhook['actions'])}")
            print(f"Status: {webhook['status']}")
            print(f"Created: {webhook['createdAt']}")

        return webhooks

    except requests.exceptions.HTTPError as e:
        print(f' Error: {e.response.status_code}')
        print('Details:', e.response.json())
        raise
    except requests.exceptions.RequestException as e:
        print(f' Request failed: {str(e)}')
        raise

if __name__ == '__main__':
    get_webhooks()

<?php

$secretKey = getenv('MODULUS_SECRET_KEY');

$ch = curl_init('https://webhooks.sbx.moduluslabs.io/v1/webhooks');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');

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

if ($httpCode === 200) {
    $data = json_decode($response, true);
    $webhooks = $data['webhooks'];

    echo "Found " . count($webhooks) . " webhook(s)\n";

    foreach ($webhooks as $webhook) {
        echo "\nWebhook ID: {$webhook['id']}\n";
        echo "URL: {$webhook['webhookUrl']}\n";
        echo "Actions: " . implode(', ', $webhook['actions']) . "\n";
        echo "Status: {$webhook['status']}\n";
        echo "Created: {$webhook['createdAt']}\n";
    }
} else {
    echo " Error: HTTP $httpCode\n";
    echo "Details: $response\n";
}

import java.net.http.*;
import java.net.URI;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;

public class GetWebhooksExample {
    public static void main(String[] args) throws Exception {
        String secretKey = System.getenv("MODULUS_SECRET_KEY");

        // Create HTTP client
        HttpClient client = HttpClient.newHttpClient();

        // Encode credentials
        String auth = secretKey + ":";
        String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes());

        // Build request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://webhooks.sbx.moduluslabs.io/v1/webhooks"))
            .header("Authorization", "Basic " + encodedAuth)
            .GET()
            .build();

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

        if (response.statusCode() == 200) {
            Gson gson = new Gson();
            JsonObject data = gson.fromJson(response.body(), JsonObject.class);
            JsonArray webhooks = data.getAsJsonArray("webhooks");

            System.out.println("Found " + webhooks.size() + " webhook(s)");

            for (int i = 0; i < webhooks.size(); i++) {
                JsonObject webhook = webhooks.get(i).getAsJsonObject();
                System.out.println("\nWebhook ID: " + webhook.get("id").getAsInt());
                System.out.println("URL: " + webhook.get("webhookUrl").getAsString());
                System.out.println("Status: " + webhook.get("status").getAsString());
            }
        } else {
            System.out.println(" Error: HTTP " + response.statusCode());
            System.out.println("Details: " + response.body());
        }
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Webhook struct {
    ID         int      `json:"id"`
    WebhookURL string   `json:"webhookUrl"`
    Actions    []string `json:"actions"`
    Status     string   `json:"status"`
    CreatedAt  string   `json:"createdAt"`
    UpdatedAt  string   `json:"updatedAt"`
}

type WebhooksResponse struct {
    Webhooks []Webhook `json:"webhooks"`
}

func getWebhooks() ([]Webhook, error) {
    secretKey := os.Getenv("MODULUS_SECRET_KEY")

    // Create request
    req, err := http.NewRequest(
        "GET",
        "https://webhooks.sbx.moduluslabs.io/v1/webhooks",
        nil,
    )
    if err != nil {
        return nil, err
    }

    // Set basic auth
    req.SetBasicAuth(secretKey, "")

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

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

    if resp.StatusCode == 200 {
        var webhooksResp WebhooksResponse
        json.Unmarshal(body, &webhooksResp)

        fmt.Printf("Found %d webhook(s)\n", len(webhooksResp.Webhooks))

        for _, webhook := range webhooksResp.Webhooks {
            fmt.Printf("\nWebhook ID: %d\n", webhook.ID)
            fmt.Printf("URL: %s\n", webhook.WebhookURL)
            fmt.Printf("Actions: %v\n", webhook.Actions)
            fmt.Printf("Status: %s\n", webhook.Status)
            fmt.Printf("Created: %s\n", webhook.CreatedAt)
        }

        return webhooksResp.Webhooks, nil
    }

    fmt.Printf(" Error: HTTP %d\n", resp.StatusCode)
    fmt.Printf("Details: %s\n", string(body))
    return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
}

func main() {
    webhooks, err := getWebhooks()
    if err != nil {
        fmt.Printf("Failed to get webhooks: %v\n", err)
    }
}

// Required NuGet package: jose-jwt
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Jose;

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

    static async Task GetWebhooks()
    {
        // Get credentials from environment variables
        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
        {
            // Decode the Base64URL encryption key
            var keyBytes = Base64UrlDecode(encryptionKey);

            // Create HTTP client with Basic Authentication
            using var client = new HttpClient();
            var credentials = Convert.ToBase64String(
                Encoding.ASCII.GetBytes($"{secretKey}:")
            );
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Basic", credentials);

            // Send GET request
            var response = await client.GetAsync(
                "https://webhooks.sbx.moduluslabs.io/v1/webhooks"
            );

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

            if (response.IsSuccessStatusCode)
            {
                // Decrypt the response token
                var encryptedResponse = JsonSerializer.Deserialize<JsonElement>(responseBody);
                var responseToken = encryptedResponse
                    .GetProperty("response")
                    .GetProperty("Token")
                    .GetString();

                var decryptedJson = JWT.Decode(responseToken, keyBytes);

                // Response is a direct array of webhooks
                var webhooks = JsonSerializer.Deserialize<Webhook[]>(
                    decryptedJson,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                );

                Console.WriteLine($"Found {webhooks.Length} webhook(s)");

                foreach (var webhook in webhooks)
                {
                    Console.WriteLine($"\nWebhook ID: {webhook.Id}");
                    Console.WriteLine($"URL: {webhook.CallbackUrl}");
                    Console.WriteLine($"Action: {webhook.WebhookAction}");
                    Console.WriteLine($"Status: {webhook.WebhookStatus}");
                }
            }
            else
            {
                Console.WriteLine($"Error: HTTP {(int)response.StatusCode}");
                Console.WriteLine($"Details: {responseBody}");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }

    // Base64URL decoding helper
    static byte[] Base64UrlDecode(string input)
    {
        var base64 = input.Replace('-', '+').Replace('_', '/');
        switch (base64.Length % 4)
        {
            case 2: base64 += "=="; break;
            case 3: base64 += "="; break;
        }
        return Convert.FromBase64String(base64);
    }
}

// Response model
public class Webhook
{
    public string Id { get; set; }
    public string CallbackUrl { get; set; }
    public string WebhookAction { get; set; }
    public string WebhookStatus { get; set; }
}

{
  "webhooks": [
    {
      "id": 123,
      "webhookUrl": "https://api.yourcompany.com/webhooks/modulus",
      "actions": ["QRPH_SUCCESS", "QRPH_DECLINED"],
      "status": "ENABLED",
      "createdAt": "2024-01-15T10:30:00Z",
      "updatedAt": "2024-01-15T10:30:00Z"
    }
  ]
}

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

{
  "code": "10000015",
  "error": "Insufficient permissions",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

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