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

const axios = require('axios');

const SECRET_KEY = process.env.MODULUS_SECRET_KEY;

async function deleteWebhook(webhookId) {
  try {
    const response = await axios.delete(
      `https://webhooks.sbx.moduluslabs.io/v1/webhooks/${webhookId}`,
      {
        auth: {
          username: SECRET_KEY,
          password: ''
        }
      }
    );

    if (response.status === 204) {
      console.log(` Webhook ${webhookId} deleted successfully`);
      return true;
    }
  } 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;
  }
}

deleteWebhook(123);

import requests
import os

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')

def delete_webhook(webhook_id):
    try:
        response = requests.delete(
            f'https://webhooks.sbx.moduluslabs.io/v1/webhooks/{webhook_id}',
            auth=(SECRET_KEY, '')
        )

        response.raise_for_status()

        if response.status_code == 204:
            print(f' Webhook {webhook_id} deleted successfully')
            return True

    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__':
    delete_webhook(123)

<?php

$secretKey = getenv('MODULUS_SECRET_KEY');
$webhookId = 123;

$ch = curl_init("https://webhooks.sbx.moduluslabs.io/v1/webhooks/{$webhookId}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');

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

if ($httpCode === 204) {
    echo " Webhook {$webhookId} deleted successfully\n";
} else {
    echo " Error: HTTP $httpCode\n";
    echo "Details: $response\n";
}

import java.net.http.*;
import java.net.URI;
import java.util.Base64;

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

        // 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/" + webhookId))
            .header("Authorization", "Basic " + encodedAuth)
            .DELETE()
            .build();

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

        if (response.statusCode() == 204) {
            System.out.println(" Webhook " + webhookId + " deleted successfully");
        } else {
            System.out.println(" Error: HTTP " + response.statusCode());
            System.out.println("Details: " + response.body());
        }
    }
}

package main

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

func deleteWebhook(webhookID int) error {
    secretKey := os.Getenv("MODULUS_SECRET_KEY")

    url := fmt.Sprintf("https://webhooks.sbx.moduluslabs.io/v1/webhooks/%d", webhookID)
    req, err := http.NewRequest("DELETE", url, nil)
    if err != nil {
        return err
    }

    req.SetBasicAuth(secretKey, "")

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

    if resp.StatusCode == 204 {
        fmt.Printf(" Webhook %d deleted successfully\n", webhookID)
        return nil
    }

    body, _ := io.ReadAll(resp.Body)
    fmt.Printf(" Error: HTTP %d\n", resp.StatusCode)
    fmt.Printf("Details: %s\n", string(body))
    return fmt.Errorf("HTTP %d", resp.StatusCode)
}

func main() {
    err := deleteWebhook(123)
    if err != nil {
        fmt.Printf("Failed to delete webhook: %v\n", err)
    }
}

// Required NuGet package: jose-jwt (for decrypting response if needed)
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 DeleteWebhook("a78efd32-de3b-4854-b599-11ae9f98f97e");
    }

    static async Task<bool> DeleteWebhook(string webhookId)
    {
        // Get credentials from environment variables
        var secretKey = Environment.GetEnvironmentVariable("MODULUS_SECRET_KEY");
        var encryptionKey = Environment.GetEnvironmentVariable("MODULUS_ENCRYPTION_KEY");

        if (string.IsNullOrEmpty(secretKey))
        {
            Console.WriteLine("Error: MODULUS_SECRET_KEY environment variable not set");
            return false;
        }

        try
        {
            // 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 DELETE request
            var response = await client.DeleteAsync(
                $"https://webhooks.sbx.moduluslabs.io/v1/webhooks/{webhookId}"
            );

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

            // API returns 200 OK with encrypted response (not 204 No Content)
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine($"Webhook {webhookId} deleted successfully");

                // Optionally decrypt the response for confirmation
                if (!string.IsNullOrEmpty(encryptionKey) && responseBody.Contains("Token"))
                {
                    var keyBytes = Base64UrlDecode(encryptionKey);
                    var encryptedResponse = JsonSerializer.Deserialize<JsonElement>(responseBody);
                    var responseToken = encryptedResponse
                        .GetProperty("response")
                        .GetProperty("Token")
                        .GetString();
                    var decryptedJson = JWT.Decode(responseToken, keyBytes);
                    Console.WriteLine($"Response: {decryptedJson}");
                }

                return true;
            }
            else
            {
                Console.WriteLine($"Error: HTTP {(int)response.StatusCode}");
                Console.WriteLine($"Details: {responseBody}");
                return false;
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error: {e.Message}");
            return false;
        }
    }

    // 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);
    }
}

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

{
  "code": "20000004",
  "error": "Webhook not found",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

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