Overview

The View Webhook Event management system provides comprehensive tracking and monitoring of webhook executions within the platform. Webhook events represent individual invocations of webhook rules to specific targets, enabling real-time event tracking, delivery monitoring, retry mechanisms, and execution status management for seamless integrations with external systems.

Key Features

Event Tracking: Complete tracking of webhook event executions and delivery status
Retry Mechanisms: Configurable retry logic with customizable intervals and maximum attempts
Delivery Monitoring: Real-time monitoring of webhook delivery success and failure rates
Status Management: Comprehensive status tracking including timestamps and HTTP responses
Timeout Control: Configurable timeout settings for webhook delivery
Content Management: Support for various content types and payload sizes
Error Handling: Detailed error tracking and failure analysis
Integration Support: Foundation for real-time system integrations and notifications

Supported Operations

Read: Retrieve individual webhook event details and execution status
Enumerate: List all webhook events with pagination support
Read All: Retrieve all webhook events in the tenant
Existence Check: Verify webhook event presence without retrieving details

API Endpoints

Webhook events are managed via the Configuration server API at [http|https]://[hostname]:[port]/v1.0/tenants/[tenant-guid]/webhookevents

Supported HTTP Methods: GET, HEAD

Important: Webhook events are read-only objects that track webhook executions. They cannot be created, updated, or deleted directly.

Webhook Event Object Structure

Webhook event objects contain comprehensive tracking information for webhook executions and delivery status. Here's the complete structure:

{
  "GUID": "8f6e4a3c-1234-4fd9-bcfa-987654321000",
  "TenantGUID": "00000000-0000-0000-0000-000000000000",
  "TargetGUID": "00000000-0000-0000-0000-000000000001",
  "RuleGUID": "00000000-0000-0000-0000-000000000002",
  "EventType": "DocumentUploaded",
  "ContentLength": 2048,
  "TimeoutMs": 5000,
  "Url": "https://webhook.receiver.com/event",
  "ContentType": "application/json",
  "ExpectStatus": 200,
  "RetryIntervalMs": 10000,
  "Attempt": 1,
  "MaxAttempts": 5,
  "HttpStatus": 200,
  "CreatedUtc": "2025-03-29T12:00:00.000Z",
  "AddedUtc": "2025-03-29T12:00:10.000Z",
  "LastAttemptUtc": "2025-03-29T12:01:00.000Z",
  "NextAttemptUtc": "2025-03-29T12:05:00.000Z",
  "LastFailureUtc": "2025-03-29T12:01:00.000Z",
  "SuccessUtc": null,
  "FailedUtc": null
}

Field Descriptions

GUID (GUID): Globally unique identifier for the webhook event object
TenantGUID (GUID): Globally unique identifier for the tenant
TargetGUID (GUID): Globally unique identifier for the webhook target
RuleGUID (GUID): Globally unique identifier for the webhook rule
EventType (string): Type of event that triggered the webhook
ContentLength (number): Length of the webhook payload content in bytes
TimeoutMs (number): Timeout duration for webhook delivery in milliseconds
Url (string): Target URL where the webhook is being delivered
ContentType (string): MIME type of the webhook payload content
ExpectStatus (number): Expected HTTP status code for successful delivery
RetryIntervalMs (number): Interval between retry attempts in milliseconds
Attempt (number): Current attempt number for webhook delivery
MaxAttempts (number): Maximum number of delivery attempts allowed
HttpStatus (number): HTTP status code received from the target endpoint
CreatedUtc (datetime): UTC timestamp when the webhook event was created
AddedUtc (datetime): UTC timestamp when the event was added to the processing queue
LastAttemptUtc (datetime): UTC timestamp of the most recent delivery attempt
NextAttemptUtc (datetime): UTC timestamp for the next scheduled retry attempt
LastFailureUtc (datetime): UTC timestamp of the most recent failure
SuccessUtc (datetime): UTC timestamp when the webhook was successfully delivered (null if not successful)
FailedUtc (datetime): UTC timestamp when the webhook was marked as failed (null if not failed)

Important Notes

Read-Only Objects: Webhook events are automatically generated and cannot be manually created, updated, or deleted
Event Lifecycle: Events progress through various states from creation to success or failure
Retry Logic: Failed webhooks are automatically retried according to configured intervals and maximum attempts
Status Tracking: Comprehensive status tracking provides visibility into webhook delivery performance

Enumerate Webhook Events

Retrieves a paginated list of all webhook event objects in the tenant using GET /v2.0/tenants/[tenant-guid]/webhookevents/. This endpoint provides comprehensive enumeration with pagination support for monitoring webhook execution history and delivery status.

Request Parameters

No additional parameters required beyond authentication.

curl --location 'http://localhost:8000/v2.0/tenants/00000000-0000-0000-0000-000000000000/webhookevents/' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);


const enumerateWebhookEvents = async () => {
  try {
    const response = await api.WebhookEvent.enumerate();
    console.log(response, "Webhook events fetched successfully");
  } catch (err) {
    console.log("Error fetching Webhook events:", err);
  }
};

enumerateWebhookEvents();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def enumerateWebhookEvents():
    webhookEvents = configuration.WebhookEvent.enumerate()
    print(webhookEvents)

enumerateWebhookEvents()

using View.Sdk;
using View.Sdk.Configuration;


ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
EnumerationResult<WebhookEvent> response = await sdk.WebhookEvent.Enumerate();

Response Structure

Returns a paginated list of webhook event objects:

{
    "Success": true,
    "Timestamp": {
        "Start": "2024-10-21T02:36:37.677751Z",
        "TotalMs": 23.58,
        "Messages": {}
    },
    "MaxResults": 10,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "RecordsRemaining": 0,
    "Objects": [
        {
            "GUID": "8f6e4a3c-1234-4fd9-bcfa-987654321000",
            "TenantGUID": "00000000-0000-0000-0000-000000000000",
            "TargetGUID": "00000000-0000-0000-0000-000000000001",
            "RuleGUID": "00000000-0000-0000-0000-000000000002",
            "EventType": "DocumentUploaded",
            "ContentLength": 2048,
            "TimeoutMs": 5000,
            "Url": "https://webhook.receiver.com/event",
            "ContentType": "application/json",
            "ExpectStatus": 200,
            "RetryIntervalMs": 10000,
            "Attempt": 1,
            "MaxAttempts": 5,
            "HttpStatus": 200,
            "CreatedUtc": "2025-03-29T12:00:00.000Z",
            "AddedUtc": "2025-03-29T12:00:10.000Z",
            "LastAttemptUtc": "2025-03-29T12:01:00.000Z",
            "NextAttemptUtc": "2025-03-29T12:05:00.000Z",
            "LastFailureUtc": "2025-03-29T12:01:00.000Z",
            "SuccessUtc": null,
            "FailedUtc": null
        }
    ],
    "ContinuationToken": null
}

Read Webhook Event

Retrieves webhook event details and execution status by GUID using GET /v1.0/tenants/[tenant-guid]/webhookevents/[webhookevent-guid]. Returns the complete webhook event information including delivery status, retry attempts, and execution timestamps. If the event doesn't exist, a 404 error is returned.

Request Parameters

webhookevent-guid (string, Path, Required): GUID of the webhook event object to retrieve

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/webhookevents/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);
const readWebhookEvent = async () => {
  try {
    const response = await api.WebhookEvent.read(
      "<webhookevent-guid>"
    );
    console.log(response, "Webhook events fetched successfully");
  } catch (err) {
    console.log("Error fetching Webhook events:", err);
  }
};

readWebhookEvent();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readWebhookEvent():
    webhookEvent = configuration.WebhookEvent.retrieve("<webhookevent-guid>")
    print(webhookEvent)

readWebhookEvent()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
WebhookEvent webhookEvent = await sdk.WebhookEvent.Retrieve(Guid.Parse("<webhookevent-guid>"));

Response

Returns the complete webhook event details:

{
    "GUID": "8f6e4a3c-1234-4fd9-bcfa-987654321000",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "TargetGUID": "00000000-0000-0000-0000-000000000001",
    "RuleGUID": "00000000-0000-0000-0000-000000000002",
    "EventType": "DocumentUploaded",
    "ContentLength": 2048,
    "TimeoutMs": 5000,
    "Url": "https://webhook.receiver.com/event",
    "ContentType": "application/json",
    "ExpectStatus": 200,
    "RetryIntervalMs": 10000,
    "Attempt": 1,
    "MaxAttempts": 5,
    "HttpStatus": 200,
    "CreatedUtc": "2025-03-29T12:00:00.000Z",
    "AddedUtc": "2025-03-29T12:00:10.000Z",
    "LastAttemptUtc": "2025-03-29T12:01:00.000Z",
    "NextAttemptUtc": "2025-03-29T12:05:00.000Z",
    "LastFailureUtc": "2025-03-29T12:01:00.000Z",
    "SuccessUtc": null,
    "FailedUtc": null
}

Read All Webhook Events

Retrieves all webhook event objects in the tenant using GET /v1.0/tenants/[tenant-guid]/webhookevents/. Returns an array of webhook event objects with complete execution details and status information for all events in the tenant.

Request Parameters

No additional parameters required beyond authentication.

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/webhookevents/' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readWebhookEvents = async () => {
  try {
    const response = await api.WebhookEvent.readAll();
    console.log(response, "Webhook events fetched successfully");
  } catch (err) {
    console.log("Error fetching Webhook events:", err);
  }
};

readWebhookEvents();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readAllWebhookEvents():
    webhookEvents = configuration.WebhookEvent.retrieve_all()
    print(webhookEvents)

readAllWebhookEvents()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
List<WebhookEvent> webhookEvents = await sdk.WebhookEvent.RetrieveMany();

Response

Returns an array of all webhook event objects:

[
    {
        "GUID": "8f6e4a3c-1234-4fd9-bcfa-987654321000",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "TargetGUID": "00000000-0000-0000-0000-000000000001",
        "RuleGUID": "00000000-0000-0000-0000-000000000002",
        "EventType": "DocumentUploaded",
        "ContentLength": 2048,
        "TimeoutMs": 5000,
        "Url": "https://webhook.receiver.com/event",
        "ContentType": "application/json",
        "ExpectStatus": 200,
        "RetryIntervalMs": 10000,
        "Attempt": 1,
        "MaxAttempts": 5,
        "HttpStatus": 200,
        "CreatedUtc": "2025-03-29T12:00:00.000Z",
        "AddedUtc": "2025-03-29T12:00:10.000Z",
        "LastAttemptUtc": "2025-03-29T12:01:00.000Z",
        "NextAttemptUtc": "2025-03-29T12:05:00.000Z",
        "LastFailureUtc": "2025-03-29T12:01:00.000Z",
        "SuccessUtc": null,
        "FailedUtc": null
    },
    {
        "GUID": "9g7f5b4d-2345-5gea-cdgb-098765432111",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "TargetGUID": "00000000-0000-0000-0000-000000000003",
        "RuleGUID": "00000000-0000-0000-0000-000000000004",
        "EventType": "ObjectDelete",
        "ContentLength": 1024,
        "TimeoutMs": 3000,
        "Url": "https://api.example.com/webhooks/delete",
        "ContentType": "application/json",
        "ExpectStatus": 204,
        "RetryIntervalMs": 5000,
        "Attempt": 2,
        "MaxAttempts": 3,
        "HttpStatus": 500,
        "CreatedUtc": "2025-03-29T13:15:30.000Z",
        "AddedUtc": "2025-03-29T13:15:35.000Z",
        "LastAttemptUtc": "2025-03-29T13:20:00.000Z",
        "NextAttemptUtc": "2025-03-29T13:25:00.000Z",
        "LastFailureUtc": "2025-03-29T13:20:00.000Z",
        "SuccessUtc": null,
        "FailedUtc": null
    }
]

Check Webhook Event Existence

Verifies if a webhook event object exists without retrieving its details using HEAD /v1.0/tenants/[tenant-guid]/webhookevents/[webhookevent-guid]. This is an efficient way to check event presence before performing operations.

Request Parameters

webhookevent-guid (string, Path, Required): GUID of the webhook event object to check

curl --location --head 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/webhookevents/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const existWebhookEvent = async () => {
  try {
    const response = await api.WebhookEvent.exists(
      "<webhookevent-guid>"
    );
    console.log(response, "Webhook event exists");
  } catch (err) {
    console.log("Error checking Webhook event:", err);
  }
};
existWebhookEvent();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def existsWebhookEvent():
    webhookEvent = configuration.WebhookEvent.exists("<webhookevent-guid>")
    print(webhookEvent)

existsWebhookEvent()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
        
bool exists = await sdk.WebhookEvent.Exists(Guid.Parse("<webhookevent-guid>"));

Response

200 No Content: Webhook event exists
404 Not Found: Webhook event does not exist
No response body: Only HTTP status code is returned

Note: HEAD requests do not return a response body, only the HTTP status code indicating whether the webhook event exists.

Best Practices

When monitoring webhook events in the View platform, consider the following recommendations for optimal webhook event tracking and management:

Event Monitoring: Regularly monitor webhook event status to identify delivery issues and performance patterns
Retry Configuration: Configure appropriate retry intervals and maximum attempts based on your target system's capabilities
Status Tracking: Use comprehensive status tracking to monitor webhook delivery success rates and identify bottlenecks
Error Analysis: Analyze failed webhook events to identify common failure patterns and improve target system reliability
Performance Optimization: Monitor timeout settings and adjust based on target system response times

Next Steps

After successfully monitoring webhook events, you can:

Webhook Rules: Create and configure webhook rules to define when and how webhooks are triggered
Webhook Targets: Set up webhook targets to specify where webhook events should be delivered
Integration Monitoring: Build comprehensive monitoring dashboards for webhook delivery performance
Alerting Systems: Implement alerting for failed webhook deliveries and performance issues
Analytics: Develop analytics and reporting systems for webhook event patterns and success rates