Change webhook configuration to subscription

Signed-off-by: Sacha Al Himdani <sacha@getprobo.com>
2026-02-13 16:54:46 +01:00
parent 6de906d0a9
commit 60538ef2bb
24 changed files with 915 additions and 885 deletions
--- a/pkg/coredata/entity_type_reg.go
+++ b/pkg/coredata/entity_type_reg.go
@@ -79,7 +79,7 @@ const (
 	SCIMEventEntityType                        uint16 = 53
 	TokenEntityType                            uint16 = 54
 	SCIMBridgeEntityType                       uint16 = 55
-	WebhookConfigurationEntityType             uint16 = 56
+	WebhookSubscriptionEntityType              uint16 = 56
 	WebhookDataEntityType                      uint16 = 57
 	WebhookEventEntityType                     uint16 = 58
 )
@@ -194,8 +194,8 @@ func NewEntityFromID(id gid.GID) (any, bool) {
 		return &Token{ID: id}, true
 	case SCIMBridgeEntityType:
 		return &SCIMBridge{ID: id}, true
-	case WebhookConfigurationEntityType:
-		return &WebhookConfiguration{ID: id}, true
+	case WebhookSubscriptionEntityType:
+		return &WebhookSubscription{ID: id}, true
 	case WebhookDataEntityType:
 		return &WebhookData{ID: id}, true
 	case WebhookEventEntityType:
--- a/pkg/coredata/migrations/20260210T135740Z.sql
+++ b/pkg/coredata/migrations/20260210T135740Z.sql
@@ -7,7 +7,7 @@ CREATE TYPE webhook_event_type AS ENUM (
    'vendor:deleted'
 );

-CREATE TABLE webhook_configurations (
+CREATE TABLE webhook_subscriptions (
    id TEXT PRIMARY KEY,
    tenant_id TEXT NOT NULL,
    organization_id TEXT NOT NULL REFERENCES organizations(id) ON UPDATE CASCADE ON DELETE CASCADE,
@@ -38,7 +38,7 @@ CREATE TABLE webhook_events (
    id TEXT PRIMARY KEY,
    tenant_id TEXT NOT NULL,
    webhook_data_id TEXT NOT NULL REFERENCES webhook_data(id) ON UPDATE CASCADE ON DELETE CASCADE,
-    webhook_configuration_id TEXT NOT NULL REFERENCES webhook_configurations(id) ON UPDATE CASCADE ON DELETE CASCADE,
+    webhook_subscription_id TEXT NOT NULL REFERENCES webhook_subscriptions(id) ON UPDATE CASCADE ON DELETE CASCADE,
    status webhook_event_status NOT NULL,
    response JSONB,
    created_at TIMESTAMP WITH TIME ZONE NOT NULL
--- a/pkg/coredata/webhook_event.go
+++ b/pkg/coredata/webhook_event.go
@@ -31,7 +31,7 @@ type (
 	WebhookEvent struct {
 		ID                     gid.GID            `db:"id"`
 		WebhookDataID          gid.GID            `db:"webhook_data_id"`
-		WebhookConfigurationID gid.GID            `db:"webhook_configuration_id"`
+		WebhookSubscriptionID gid.GID            `db:"webhook_subscription_id"`
 		Status                 WebhookEventStatus `db:"status"`
 		Response               json.RawMessage    `db:"response"`
 		CreatedAt              time.Time          `db:"created_at"`
@@ -49,18 +49,18 @@ func (w WebhookEvent) CursorKey(orderBy WebhookEventOrderField) page.CursorKey {
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }

-func (w *WebhookEvents) LoadByConfigurationID(
+func (w *WebhookEvents) LoadBySubscriptionID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 	cursor *page.Cursor[WebhookEventOrderField],
 ) error {
 	q := `
 SELECT
    id,
    webhook_data_id,
-    webhook_configuration_id,
+    webhook_subscription_id,
    status,
    response,
    created_at
@@ -68,12 +68,12 @@ FROM
    webhook_events
 WHERE
    %s
-    AND webhook_configuration_id = @webhook_configuration_id
+    AND webhook_subscription_id = @webhook_subscription_id
    AND %s
 `
 	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())

-	args := pgx.NamedArgs{"webhook_configuration_id": webhookConfigurationID}
+	args := pgx.NamedArgs{"webhook_subscription_id": webhookSubscriptionID}
 	maps.Copy(args, scope.SQLArguments())
 	maps.Copy(args, cursor.SQLArguments())

@@ -91,21 +91,21 @@ WHERE
 	return nil
 }

-func (w *WebhookEvents) CountByConfigurationID(
+func (w *WebhookEvents) CountBySubscriptionID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 ) (int, error) {
 	q := `
 SELECT COUNT(*)
 FROM webhook_events
 WHERE %s
-    AND webhook_configuration_id = @webhook_configuration_id
+    AND webhook_subscription_id = @webhook_subscription_id
 `
 	q = fmt.Sprintf(q, scope.SQLFragment())

-	args := pgx.StrictNamedArgs{"webhook_configuration_id": webhookConfigurationID}
+	args := pgx.StrictNamedArgs{"webhook_subscription_id": webhookSubscriptionID}
 	maps.Copy(args, scope.SQLArguments())

 	var count int
@@ -126,7 +126,7 @@ INSERT INTO webhook_events (
    id,
    tenant_id,
    webhook_data_id,
-    webhook_configuration_id,
+    webhook_subscription_id,
    status,
    response,
    created_at
@@ -135,7 +135,7 @@ VALUES (
    @id,
    @tenant_id,
    @webhook_data_id,
-    @webhook_configuration_id,
+    @webhook_subscription_id,
    @status,
    @response,
    @created_at
@@ -146,7 +146,7 @@ VALUES (
 		"id":                       w.ID,
 		"tenant_id":                scope.GetTenantID(),
 		"webhook_data_id":          w.WebhookDataID,
-		"webhook_configuration_id": w.WebhookConfigurationID,
+		"webhook_subscription_id": w.WebhookSubscriptionID,
 		"status":                   w.Status,
 		"response":                 w.Response,
 		"created_at":               w.CreatedAt,
--- a/pkg/coredata/webhook_configuration.go
+++ b/pkg/coredata/webhook_configuration.go
@@ -31,7 +31,7 @@ import (
 )

 type (
-	WebhookConfiguration struct {
+	WebhookSubscription struct {
 		ID                     gid.GID           `db:"id"`
 		OrganizationID         gid.GID           `db:"organization_id"`
 		EndpointURL            string            `db:"endpoint_url"`
@@ -41,10 +41,10 @@ type (
 		UpdatedAt              time.Time         `db:"updated_at"`
 	}

-	WebhookConfigurations []*WebhookConfiguration
+	WebhookSubscriptions []*WebhookSubscription
 )

-func (w *WebhookConfiguration) GenerateSigningSecret(encryptionKey cipher.EncryptionKey) (string, error) {
+func (w *WebhookSubscription) GenerateSigningSecret(encryptionKey cipher.EncryptionKey) (string, error) {
 	secret := make([]byte, 32)
 	if _, err := rand.Read(secret); err != nil {
 		return "", fmt.Errorf("cannot generate signing secret: %w", err)
@@ -62,7 +62,7 @@ func (w *WebhookConfiguration) GenerateSigningSecret(encryptionKey cipher.Encryp
 	return signingSecret, nil
 }

-func (w *WebhookConfiguration) DecryptSigningSecret(encryptionKey cipher.EncryptionKey) (string, error) {
+func (w *WebhookSubscription) DecryptSigningSecret(encryptionKey cipher.EncryptionKey) (string, error) {
 	if len(w.EncryptedSigningSecret) == 0 {
 		return "", fmt.Errorf("no encrypted signing secret")
 	}
@@ -75,9 +75,9 @@ func (w *WebhookConfiguration) DecryptSigningSecret(encryptionKey cipher.Encrypt
 	return string(plaintext), nil
 }

-func (w WebhookConfiguration) CursorKey(orderBy WebhookConfigurationOrderField) page.CursorKey {
+func (w WebhookSubscription) CursorKey(orderBy WebhookSubscriptionOrderField) page.CursorKey {
 	switch orderBy {
-	case WebhookConfigurationOrderFieldCreatedAt:
+	case WebhookSubscriptionOrderFieldCreatedAt:
 		return page.NewCursorKey(w.ID, w.CreatedAt)
 	}

@@ -85,25 +85,25 @@ func (w WebhookConfiguration) CursorKey(orderBy WebhookConfigurationOrderField)
 }

 // AuthorizationAttributes returns the authorization attributes for policy evaluation.
-func (w *WebhookConfiguration) AuthorizationAttributes(ctx context.Context, conn pg.Conn) (map[string]string, error) {
-	q := `SELECT organization_id FROM webhook_configurations WHERE id = $1 LIMIT 1;`
+func (w *WebhookSubscription) AuthorizationAttributes(ctx context.Context, conn pg.Conn) (map[string]string, error) {
+	q := `SELECT organization_id FROM webhook_subscriptions WHERE id = $1 LIMIT 1;`

 	var organizationID gid.GID
 	if err := conn.QueryRow(ctx, q, w.ID).Scan(&organizationID); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
-		return nil, fmt.Errorf("cannot query webhook configuration authorization attributes: %w", err)
+		return nil, fmt.Errorf("cannot query webhook subscription authorization attributes: %w", err)
 	}

 	return map[string]string{"organization_id": organizationID.String()}, nil
 }

-func (w *WebhookConfiguration) LoadByID(
+func (w *WebhookSubscription) LoadByID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 ) error {
 	q := `
 SELECT
@@ -115,42 +115,42 @@ SELECT
    created_at,
    updated_at
 FROM
-    webhook_configurations
+    webhook_subscriptions
 WHERE
    %s
-    AND id = @webhook_configuration_id
+    AND id = @webhook_subscription_id
 LIMIT 1;
 `

 	q = fmt.Sprintf(q, scope.SQLFragment())

-	args := pgx.StrictNamedArgs{"webhook_configuration_id": webhookConfigurationID}
+	args := pgx.StrictNamedArgs{"webhook_subscription_id": webhookSubscriptionID}
 	maps.Copy(args, scope.SQLArguments())

 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
-		return fmt.Errorf("cannot query webhook configurations: %w", err)
+		return fmt.Errorf("cannot query webhook subscriptions: %w", err)
 	}

-	wc, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[WebhookConfiguration])
+	wc, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[WebhookSubscription])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}

-		return fmt.Errorf("cannot collect webhook configuration: %w", err)
+		return fmt.Errorf("cannot collect webhook subscription: %w", err)
 	}

 	*w = wc
 	return nil
 }

-func (w *WebhookConfigurations) LoadByOrganizationID(
+func (w *WebhookSubscriptions) LoadByOrganizationID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
 	organizationID gid.GID,
-	cursor *page.Cursor[WebhookConfigurationOrderField],
+	cursor *page.Cursor[WebhookSubscriptionOrderField],
 ) error {
 	q := `
 SELECT
@@ -162,7 +162,7 @@ SELECT
    created_at,
    updated_at
 FROM
-    webhook_configurations
+    webhook_subscriptions
 WHERE
    %s
    AND organization_id = @organization_id
@@ -176,19 +176,19 @@ WHERE

 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
-		return fmt.Errorf("cannot query webhook configurations: %w", err)
+		return fmt.Errorf("cannot query webhook subscriptions: %w", err)
 	}

-	configurations, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[WebhookConfiguration])
+	subscriptions, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[WebhookSubscription])
 	if err != nil {
-		return fmt.Errorf("cannot collect webhook configurations: %w", err)
+		return fmt.Errorf("cannot collect webhook subscriptions: %w", err)
 	}

-	*w = configurations
+	*w = subscriptions
 	return nil
 }

-func (w *WebhookConfigurations) CountByOrganizationID(
+func (w *WebhookSubscriptions) CountByOrganizationID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
@@ -198,7 +198,7 @@ func (w *WebhookConfigurations) CountByOrganizationID(
 SELECT
    COUNT(*)
 FROM
-    webhook_configurations
+    webhook_subscriptions
 WHERE
    %s
    AND organization_id = @organization_id
@@ -213,13 +213,13 @@ WHERE
 	row := conn.QueryRow(ctx, q, args)
 	var count int
 	if err := row.Scan(&count); err != nil {
-		return 0, fmt.Errorf("cannot count webhook configurations: %w", err)
+		return 0, fmt.Errorf("cannot count webhook subscriptions: %w", err)
 	}

 	return count, nil
 }

-func (w *WebhookConfigurations) ExistsByOrganizationIDAndEventType(
+func (w *WebhookSubscriptions) ExistsByOrganizationIDAndEventType(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
@@ -229,7 +229,7 @@ func (w *WebhookConfigurations) ExistsByOrganizationIDAndEventType(
 	q := `
 SELECT EXISTS (
    SELECT 1
-    FROM webhook_configurations
+    FROM webhook_subscriptions
    WHERE %s
        AND organization_id = @organization_id
        AND @event_type = ANY(selected_events)
@@ -245,20 +245,20 @@ SELECT EXISTS (

 	var exists bool
 	if err := conn.QueryRow(ctx, q, args).Scan(&exists); err != nil {
-		return false, fmt.Errorf("cannot check webhook configuration existence: %w", err)
+		return false, fmt.Errorf("cannot check webhook subscription existence: %w", err)
 	}

 	return exists, nil
 }

-func (w *WebhookConfiguration) Insert(
+func (w *WebhookSubscription) Insert(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
 ) error {
 	q := `
 INSERT INTO
-    webhook_configurations (
+    webhook_subscriptions (
        tenant_id,
        id,
        organization_id,
@@ -270,7 +270,7 @@ INSERT INTO
    )
 VALUES (
    @tenant_id,
-    @webhook_configuration_id,
+    @webhook_subscription_id,
    @organization_id,
    @endpoint_url,
    @selected_events,
@@ -281,52 +281,52 @@ VALUES (
 `

 	args := pgx.StrictNamedArgs{
-		"tenant_id":                scope.GetTenantID(),
-		"webhook_configuration_id": w.ID,
-		"organization_id":          w.OrganizationID,
-		"endpoint_url":             w.EndpointURL,
-		"selected_events":          w.SelectedEvents,
+		"tenant_id":               scope.GetTenantID(),
+		"webhook_subscription_id": w.ID,
+		"organization_id":         w.OrganizationID,
+		"endpoint_url":            w.EndpointURL,
+		"selected_events":         w.SelectedEvents,
 		"encrypted_signing_secret": w.EncryptedSigningSecret,
-		"created_at":               w.CreatedAt,
-		"updated_at":               w.UpdatedAt,
+		"created_at":              w.CreatedAt,
+		"updated_at":              w.UpdatedAt,
 	}
 	_, err := conn.Exec(ctx, q, args)

 	if err != nil {
-		return fmt.Errorf("cannot insert webhook configuration: %w", err)
+		return fmt.Errorf("cannot insert webhook subscription: %w", err)
 	}

 	return nil
 }

-func (w *WebhookConfiguration) Update(
+func (w *WebhookSubscription) Update(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
 ) error {
 	q := `
-UPDATE webhook_configurations
+UPDATE webhook_subscriptions
 SET
    endpoint_url = @endpoint_url,
    selected_events = @selected_events,
    updated_at = @updated_at
 WHERE %s
-    AND id = @webhook_configuration_id
+    AND id = @webhook_subscription_id
 `

 	q = fmt.Sprintf(q, scope.SQLFragment())

 	args := pgx.StrictNamedArgs{
-		"webhook_configuration_id": w.ID,
-		"endpoint_url":             w.EndpointURL,
-		"selected_events":          w.SelectedEvents,
-		"updated_at":               w.UpdatedAt,
+		"webhook_subscription_id": w.ID,
+		"endpoint_url":            w.EndpointURL,
+		"selected_events":         w.SelectedEvents,
+		"updated_at":              w.UpdatedAt,
 	}
 	maps.Copy(args, scope.SQLArguments())

 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
-		return fmt.Errorf("cannot update webhook configuration: %w", err)
+		return fmt.Errorf("cannot update webhook subscription: %w", err)
 	}

 	if result.RowsAffected() == 0 {
@@ -336,7 +336,7 @@ WHERE %s
 	return nil
 }

-func (w *WebhookConfigurations) LoadMatchingByOrganizationIDAndEventType(
+func (w *WebhookSubscriptions) LoadMatchingByOrganizationIDAndEventType(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
@@ -353,7 +353,7 @@ SELECT
    created_at,
    updated_at
 FROM
-    webhook_configurations
+    webhook_subscriptions
 WHERE
    %s
    AND organization_id = @organization_id
@@ -369,38 +369,38 @@ WHERE

 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
-		return fmt.Errorf("cannot query matching webhook configurations: %w", err)
+		return fmt.Errorf("cannot query matching webhook subscriptions: %w", err)
 	}

-	configurations, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[WebhookConfiguration])
+	subscriptions, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[WebhookSubscription])
 	if err != nil {
-		return fmt.Errorf("cannot collect matching webhook configurations: %w", err)
+		return fmt.Errorf("cannot collect matching webhook subscriptions: %w", err)
 	}

-	*w = configurations
+	*w = subscriptions
 	return nil
 }

-func (w *WebhookConfiguration) Delete(
+func (w *WebhookSubscription) Delete(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
 ) error {
 	q := `
-DELETE FROM webhook_configurations
+DELETE FROM webhook_subscriptions
 WHERE %s
-    AND id = @webhook_configuration_id
+    AND id = @webhook_subscription_id
 `
 	q = fmt.Sprintf(q, scope.SQLFragment())

 	args := pgx.StrictNamedArgs{
-		"webhook_configuration_id": w.ID,
+		"webhook_subscription_id": w.ID,
 	}
 	maps.Copy(args, scope.SQLArguments())

 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
-		return fmt.Errorf("cannot delete webhook configuration: %w", err)
+		return fmt.Errorf("cannot delete webhook subscription: %w", err)
 	}

 	if result.RowsAffected() == 0 {
--- a/pkg/coredata/webhook_configuration_order_field.go
+++ b/pkg/coredata/webhook_configuration_order_field.go
@@ -19,37 +19,37 @@ import (
 )

 type (
-	WebhookConfigurationOrderField string
+	WebhookSubscriptionOrderField string
 )

 const (
-	WebhookConfigurationOrderFieldCreatedAt WebhookConfigurationOrderField = "CREATED_AT"
+	WebhookSubscriptionOrderFieldCreatedAt WebhookSubscriptionOrderField = "CREATED_AT"
 )

-func (p WebhookConfigurationOrderField) Column() string {
+func (p WebhookSubscriptionOrderField) Column() string {
 	return string(p)
 }

-func (p WebhookConfigurationOrderField) String() string {
+func (p WebhookSubscriptionOrderField) String() string {
 	return string(p)
 }

-func (p WebhookConfigurationOrderField) IsValid() bool {
+func (p WebhookSubscriptionOrderField) IsValid() bool {
 	switch p {
-	case WebhookConfigurationOrderFieldCreatedAt:
+	case WebhookSubscriptionOrderFieldCreatedAt:
 		return true
 	}
 	return false
 }

-func (p WebhookConfigurationOrderField) MarshalText() ([]byte, error) {
+func (p WebhookSubscriptionOrderField) MarshalText() ([]byte, error) {
 	return []byte(p.String()), nil
 }

-func (p *WebhookConfigurationOrderField) UnmarshalText(text []byte) error {
-	*p = WebhookConfigurationOrderField(text)
+func (p *WebhookSubscriptionOrderField) UnmarshalText(text []byte) error {
+	*p = WebhookSubscriptionOrderField(text)
 	if !p.IsValid() {
-		return fmt.Errorf("%s is not a valid WebhookConfigurationOrderField", string(text))
+		return fmt.Errorf("%s is not a valid WebhookSubscriptionOrderField", string(text))
 	}
 	return nil
 }
--- a/pkg/probo/actions.go
+++ b/pkg/probo/actions.go
@@ -317,10 +317,10 @@ const (
 	ActionApplicabilityStatementUpdate = "core:applicability-statement:update"
 	ActionApplicabilityStatementDelete = "core:applicability-statement:delete"

-	// WebhookConfiguration actions
-	ActionWebhookConfigurationList   = "core:webhook-configuration:list"
-	ActionWebhookConfigurationGet    = "core:webhook-configuration:get"
-	ActionWebhookConfigurationCreate = "core:webhook-configuration:create"
-	ActionWebhookConfigurationUpdate = "core:webhook-configuration:update"
-	ActionWebhookConfigurationDelete = "core:webhook-configuration:delete"
+	// WebhookSubscription actions
+	ActionWebhookSubscriptionList   = "core:webhook-subscription:list"
+	ActionWebhookSubscriptionGet    = "core:webhook-subscription:get"
+	ActionWebhookSubscriptionCreate = "core:webhook-subscription:create"
+	ActionWebhookSubscriptionUpdate = "core:webhook-subscription:update"
+	ActionWebhookSubscriptionDelete = "core:webhook-subscription:delete"
 )
--- a/pkg/probo/policies.go
+++ b/pkg/probo/policies.go
@@ -79,7 +79,7 @@ var ViewerPolicy = policy.NewPolicy(
 		ActionRightsRequestGet, ActionRightsRequestList,
 		ActionStateOfApplicabilityGet, ActionStateOfApplicabilityList,
 		ActionApplicabilityStatementGet, ActionApplicabilityStatementList,
-		ActionWebhookConfigurationGet, ActionWebhookConfigurationList,
+		ActionWebhookSubscriptionGet, ActionWebhookSubscriptionList,
 	).WithSID("entity-read-access").When(organizationCondition),

 	policy.Allow(
--- a/pkg/probo/service.go
+++ b/pkg/probo/service.go
@@ -92,7 +92,7 @@ type (
 		Data                              *DatumService
 		Audits                            *AuditService
 		Meetings                          *MeetingService
-		WebhookConfigurations             *WebhookConfigurationService
+		WebhookSubscriptions              *WebhookSubscriptionService
 		Reports                           *ReportService
 		TrustCenters                      *TrustCenterService
 		TrustCenterAccesses               *TrustCenterAccessService
@@ -214,7 +214,7 @@ func (s *Service) WithTenant(tenantID gid.TenantID) *TenantService {
 	tenantService.Data = &DatumService{svc: tenantService}
 	tenantService.Audits = &AuditService{svc: tenantService}
 	tenantService.Meetings = &MeetingService{svc: tenantService}
-	tenantService.WebhookConfigurations = &WebhookConfigurationService{svc: tenantService}
+	tenantService.WebhookSubscriptions = &WebhookSubscriptionService{svc: tenantService}
 	tenantService.Reports = &ReportService{svc: tenantService}
 	tenantService.TrustCenters = &TrustCenterService{svc: tenantService}
 	tenantService.TrustCenterAccesses = &TrustCenterAccessService{svc: tenantService}
--- a/pkg/probo/webhook_configuration_service.go
+++ b/pkg/probo/webhook_configuration_service.go
@@ -26,25 +26,25 @@ import (
 	"go.probo.inc/probo/pkg/validator"
 )

-type WebhookConfigurationService struct {
+type WebhookSubscriptionService struct {
 	svc *TenantService
 }

 type (
-	CreateWebhookConfigurationRequest struct {
+	CreateWebhookSubscriptionRequest struct {
 		OrganizationID gid.GID
 		EndpointURL    string
 		SelectedEvents []coredata.WebhookEventType
 	}

-	UpdateWebhookConfigurationRequest struct {
-		WebhookConfigurationID gid.GID
-		EndpointURL            *string
-		SelectedEvents         []coredata.WebhookEventType
+	UpdateWebhookSubscriptionRequest struct {
+		WebhookSubscriptionID gid.GID
+		EndpointURL           *string
+		SelectedEvents        []coredata.WebhookEventType
 	}
 )

-func (r *CreateWebhookConfigurationRequest) Validate() error {
+func (r *CreateWebhookSubscriptionRequest) Validate() error {
 	v := validator.New()

 	v.Check(r.OrganizationID, "organization_id", validator.Required(), validator.GID(coredata.OrganizationEntityType))
@@ -53,21 +53,21 @@ func (r *CreateWebhookConfigurationRequest) Validate() error {
 	return v.Error()
 }

-func (r *UpdateWebhookConfigurationRequest) Validate() error {
+func (r *UpdateWebhookSubscriptionRequest) Validate() error {
 	v := validator.New()

-	v.Check(r.WebhookConfigurationID, "webhook_configuration_id", validator.Required(), validator.GID(coredata.WebhookConfigurationEntityType))
+	v.Check(r.WebhookSubscriptionID, "webhook_subscription_id", validator.Required(), validator.GID(coredata.WebhookSubscriptionEntityType))
 	v.Check(r.EndpointURL, "endpoint_url", validator.NotEmpty(), validator.HTTPSUrl())

 	return v.Error()
 }

-func (s WebhookConfigurationService) ListForOrganizationID(
+func (s WebhookSubscriptionService) ListForOrganizationID(
 	ctx context.Context,
 	organizationID gid.GID,
-	cursor *page.Cursor[coredata.WebhookConfigurationOrderField],
-) (*page.Page[*coredata.WebhookConfiguration, coredata.WebhookConfigurationOrderField], error) {
-	var configurations coredata.WebhookConfigurations
+	cursor *page.Cursor[coredata.WebhookSubscriptionOrderField],
+) (*page.Page[*coredata.WebhookSubscription, coredata.WebhookSubscriptionOrderField], error) {
+	var subscriptions coredata.WebhookSubscriptions
 	organization := &coredata.Organization{}

 	err := s.svc.pg.WithConn(
@@ -77,7 +77,7 @@ func (s WebhookConfigurationService) ListForOrganizationID(
 				return fmt.Errorf("cannot load organization: %w", err)
 			}

-			err := configurations.LoadByOrganizationID(
+			err := subscriptions.LoadByOrganizationID(
 				ctx,
 				conn,
 				s.svc.scope,
@@ -85,7 +85,7 @@ func (s WebhookConfigurationService) ListForOrganizationID(
 				cursor,
 			)
 			if err != nil {
-				return fmt.Errorf("cannot load webhook configurations: %w", err)
+				return fmt.Errorf("cannot load webhook subscriptions: %w", err)
 			}

 			return nil
@@ -96,10 +96,10 @@ func (s WebhookConfigurationService) ListForOrganizationID(
 		return nil, err
 	}

-	return page.NewPage(configurations, cursor), nil
+	return page.NewPage(subscriptions, cursor), nil
 }

-func (s WebhookConfigurationService) CountForOrganizationID(
+func (s WebhookSubscriptionService) CountForOrganizationID(
 	ctx context.Context,
 	organizationID gid.GID,
 ) (int, error) {
@@ -108,10 +108,10 @@ func (s WebhookConfigurationService) CountForOrganizationID(
 	err := s.svc.pg.WithConn(
 		ctx,
 		func(conn pg.Conn) (err error) {
-			configurations := &coredata.WebhookConfigurations{}
-			count, err = configurations.CountByOrganizationID(ctx, conn, s.svc.scope, organizationID)
+			subscriptions := &coredata.WebhookSubscriptions{}
+			count, err = subscriptions.CountByOrganizationID(ctx, conn, s.svc.scope, organizationID)
 			if err != nil {
-				return fmt.Errorf("cannot count webhook configurations: %w", err)
+				return fmt.Errorf("cannot count webhook subscriptions: %w", err)
 			}

 			return nil
@@ -125,17 +125,17 @@ func (s WebhookConfigurationService) CountForOrganizationID(
 	return count, nil
 }

-func (s WebhookConfigurationService) Get(
+func (s WebhookSubscriptionService) Get(
 	ctx context.Context,
-	webhookConfigurationID gid.GID,
-) (*coredata.WebhookConfiguration, error) {
-	wc := &coredata.WebhookConfiguration{}
+	webhookSubscriptionID gid.GID,
+) (*coredata.WebhookSubscription, error) {
+	wc := &coredata.WebhookSubscription{}

 	err := s.svc.pg.WithConn(
 		ctx,
 		func(conn pg.Conn) error {
-			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookConfigurationID); err != nil {
-				return fmt.Errorf("cannot load webhook configuration: %w", err)
+			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookSubscriptionID); err != nil {
+				return fmt.Errorf("cannot load webhook subscription: %w", err)
 			}

 			return nil
@@ -149,16 +149,16 @@ func (s WebhookConfigurationService) Get(
 	return wc, nil
 }

-func (s WebhookConfigurationService) Create(
+func (s WebhookSubscriptionService) Create(
 	ctx context.Context,
-	req CreateWebhookConfigurationRequest,
-) (*coredata.WebhookConfiguration, error) {
+	req CreateWebhookSubscriptionRequest,
+) (*coredata.WebhookSubscription, error) {
 	if err := req.Validate(); err != nil {
 		return nil, err
 	}

 	now := time.Now()
-	var wc *coredata.WebhookConfiguration
+	var wc *coredata.WebhookSubscription
 	organization := &coredata.Organization{}

 	err := s.svc.pg.WithTx(
@@ -168,8 +168,8 @@ func (s WebhookConfigurationService) Create(
 				return fmt.Errorf("cannot load organization: %w", err)
 			}

-			wc = &coredata.WebhookConfiguration{
-				ID:             gid.New(organization.ID.TenantID(), coredata.WebhookConfigurationEntityType),
+			wc = &coredata.WebhookSubscription{
+				ID:             gid.New(organization.ID.TenantID(), coredata.WebhookSubscriptionEntityType),
 				OrganizationID: organization.ID,
 				EndpointURL:    req.EndpointURL,
 				SelectedEvents: req.SelectedEvents,
@@ -182,7 +182,7 @@ func (s WebhookConfigurationService) Create(
 			}

 			if err := wc.Insert(ctx, conn, s.svc.scope); err != nil {
-				return fmt.Errorf("cannot insert webhook configuration: %w", err)
+				return fmt.Errorf("cannot insert webhook subscription: %w", err)
 			}

 			return nil
@@ -196,21 +196,21 @@ func (s WebhookConfigurationService) Create(
 	return wc, nil
 }

-func (s WebhookConfigurationService) Update(
+func (s WebhookSubscriptionService) Update(
 	ctx context.Context,
-	req UpdateWebhookConfigurationRequest,
-) (*coredata.WebhookConfiguration, error) {
+	req UpdateWebhookSubscriptionRequest,
+) (*coredata.WebhookSubscription, error) {
 	if err := req.Validate(); err != nil {
 		return nil, err
 	}

-	wc := &coredata.WebhookConfiguration{}
+	wc := &coredata.WebhookSubscription{}

 	err := s.svc.pg.WithTx(
 		ctx,
 		func(conn pg.Conn) error {
-			if err := wc.LoadByID(ctx, conn, s.svc.scope, req.WebhookConfigurationID); err != nil {
-				return fmt.Errorf("cannot load webhook configuration: %w", err)
+			if err := wc.LoadByID(ctx, conn, s.svc.scope, req.WebhookSubscriptionID); err != nil {
+				return fmt.Errorf("cannot load webhook subscription: %w", err)
 			}

 			if req.EndpointURL != nil {
@@ -223,7 +223,7 @@ func (s WebhookConfigurationService) Update(
 			wc.UpdatedAt = time.Now()

 			if err := wc.Update(ctx, conn, s.svc.scope); err != nil {
-				return fmt.Errorf("cannot update webhook configuration: %w", err)
+				return fmt.Errorf("cannot update webhook subscription: %w", err)
 			}

 			return nil
@@ -237,17 +237,17 @@ func (s WebhookConfigurationService) Update(
 	return wc, nil
 }

-func (s WebhookConfigurationService) GetSigningSecret(
+func (s WebhookSubscriptionService) GetSigningSecret(
 	ctx context.Context,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 ) (string, error) {
-	wc := &coredata.WebhookConfiguration{}
+	wc := &coredata.WebhookSubscription{}

 	err := s.svc.pg.WithConn(
 		ctx,
 		func(conn pg.Conn) error {
-			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookConfigurationID); err != nil {
-				return fmt.Errorf("cannot load webhook configuration: %w", err)
+			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookSubscriptionID); err != nil {
+				return fmt.Errorf("cannot load webhook subscription: %w", err)
 			}

 			return nil
@@ -261,9 +261,9 @@ func (s WebhookConfigurationService) GetSigningSecret(
 	return wc.DecryptSigningSecret(s.svc.encryptionKey)
 }

-func (s WebhookConfigurationService) ListEventsForConfigurationID(
+func (s WebhookSubscriptionService) ListEventsForSubscriptionID(
 	ctx context.Context,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 	cursor *page.Cursor[coredata.WebhookEventOrderField],
 ) (*page.Page[*coredata.WebhookEvent, coredata.WebhookEventOrderField], error) {
 	var events coredata.WebhookEvents
@@ -271,7 +271,7 @@ func (s WebhookConfigurationService) ListEventsForConfigurationID(
 	err := s.svc.pg.WithConn(
 		ctx,
 		func(conn pg.Conn) error {
-			if err := events.LoadByConfigurationID(ctx, conn, s.svc.scope, webhookConfigurationID, cursor); err != nil {
+			if err := events.LoadBySubscriptionID(ctx, conn, s.svc.scope, webhookSubscriptionID, cursor); err != nil {
 				return fmt.Errorf("cannot load webhook events: %w", err)
 			}

@@ -286,9 +286,9 @@ func (s WebhookConfigurationService) ListEventsForConfigurationID(
 	return page.NewPage(events, cursor), nil
 }

-func (s WebhookConfigurationService) CountEventsForConfigurationID(
+func (s WebhookSubscriptionService) CountEventsForSubscriptionID(
 	ctx context.Context,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 ) (int, error) {
 	var count int

@@ -296,7 +296,7 @@ func (s WebhookConfigurationService) CountEventsForConfigurationID(
 		ctx,
 		func(conn pg.Conn) (err error) {
 			events := &coredata.WebhookEvents{}
-			count, err = events.CountByConfigurationID(ctx, conn, s.svc.scope, webhookConfigurationID)
+			count, err = events.CountBySubscriptionID(ctx, conn, s.svc.scope, webhookSubscriptionID)

 			if err != nil {
 				return fmt.Errorf("cannot count webhook events: %w", err)
@@ -313,21 +313,21 @@ func (s WebhookConfigurationService) CountEventsForConfigurationID(
 	return count, nil
 }

-func (s WebhookConfigurationService) Delete(
+func (s WebhookSubscriptionService) Delete(
 	ctx context.Context,
-	webhookConfigurationID gid.GID,
+	webhookSubscriptionID gid.GID,
 ) error {
-	wc := &coredata.WebhookConfiguration{ID: webhookConfigurationID}
+	wc := &coredata.WebhookSubscription{ID: webhookSubscriptionID}

 	err := s.svc.pg.WithTx(
 		ctx,
 		func(conn pg.Conn) error {
-			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookConfigurationID); err != nil {
-				return fmt.Errorf("cannot load webhook configuration: %w", err)
+			if err := wc.LoadByID(ctx, conn, s.svc.scope, webhookSubscriptionID); err != nil {
+				return fmt.Errorf("cannot load webhook subscription: %w", err)
 			}

 			if err := wc.Delete(ctx, conn, s.svc.scope); err != nil {
-				return fmt.Errorf("cannot delete webhook configuration: %w", err)
+				return fmt.Errorf("cannot delete webhook subscription: %w", err)
 			}

 			return nil
--- a/pkg/server/api/console/v1/schema.graphql
+++ b/pkg/server/api/console/v1/schema.graphql
@@ -488,13 +488,13 @@ enum MeetingOrderField
        )
 }

-enum WebhookConfigurationOrderField
+enum WebhookSubscriptionOrderField
    @goModel(
-        model: "go.probo.inc/probo/pkg/coredata.WebhookConfigurationOrderField"
+        model: "go.probo.inc/probo/pkg/coredata.WebhookSubscriptionOrderField"
    ) {
    CREATED_AT
        @goEnum(
-            value: "go.probo.inc/probo/pkg/coredata.WebhookConfigurationOrderFieldCreatedAt"
+            value: "go.probo.inc/probo/pkg/coredata.WebhookSubscriptionOrderFieldCreatedAt"
        )
 }

@@ -1355,12 +1355,12 @@ input MeetingOrder
    field: MeetingOrderField!
 }

-input WebhookConfigurationOrder
+input WebhookSubscriptionOrder
    @goModel(
-        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.WebhookConfigurationOrderBy"
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.WebhookSubscriptionOrderBy"
    ) {
    direction: OrderDirection!
-    field: WebhookConfigurationOrderField!
+    field: WebhookSubscriptionOrderField!
 }

 input RiskOrder
@@ -1835,13 +1835,13 @@ type Organization implements Node {

    customDomain: CustomDomain @goField(forceResolver: true)

-    webhookConfigurations(
+    webhookSubscriptions(
        first: Int
        after: CursorKey
        last: Int
        before: CursorKey
-        orderBy: WebhookConfigurationOrder
-    ): WebhookConfigurationConnection! @goField(forceResolver: true)
+        orderBy: WebhookSubscriptionOrder
+    ): WebhookSubscriptionConnection! @goField(forceResolver: true)

    createdAt: Datetime!
    updatedAt: Datetime!
@@ -2284,7 +2284,7 @@ enum WebhookEventType
        @goEnum(value: "go.probo.inc/probo/pkg/coredata.WebhookEventTypeVendorDeleted")
 }

-type WebhookConfiguration implements Node {
+type WebhookSubscription implements Node {
    id: ID!
    organization: Organization @goField(forceResolver: true)
    endpointUrl: String!
@@ -2304,18 +2304,18 @@ type WebhookConfiguration implements Node {
    permission(action: String!): Boolean! @goField(forceResolver: true)
 }

-type WebhookConfigurationConnection
+type WebhookSubscriptionConnection
    @goModel(
-        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.WebhookConfigurationConnection"
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.WebhookSubscriptionConnection"
    ) {
-    edges: [WebhookConfigurationEdge!]!
+    edges: [WebhookSubscriptionEdge!]!
    pageInfo: PageInfo!
    totalCount: Int! @goField(forceResolver: true)
 }

-type WebhookConfigurationEdge {
+type WebhookSubscriptionEdge {
    cursor: CursorKey!
-    node: WebhookConfiguration!
+    node: WebhookSubscription!
 }

 enum WebhookEventStatus
@@ -2348,7 +2348,7 @@ input WebhookEventOrder

 type WebhookEvent implements Node {
    id: ID!
-    webhookConfigurationId: ID!
+    webhookSubscriptionId: ID!
    status: WebhookEventStatus!
    response: String
    createdAt: Datetime!
@@ -3396,16 +3396,16 @@ type Mutation {
    createMeeting(input: CreateMeetingInput!): CreateMeetingPayload!
    updateMeeting(input: UpdateMeetingInput!): UpdateMeetingPayload!
    deleteMeeting(input: DeleteMeetingInput!): DeleteMeetingPayload!
-    # WebhookConfiguration mutations
-    createWebhookConfiguration(
-        input: CreateWebhookConfigurationInput!
-    ): CreateWebhookConfigurationPayload!
-    updateWebhookConfiguration(
-        input: UpdateWebhookConfigurationInput!
-    ): UpdateWebhookConfigurationPayload!
-    deleteWebhookConfiguration(
-        input: DeleteWebhookConfigurationInput!
-    ): DeleteWebhookConfigurationPayload!
+    # WebhookSubscription mutations
+    createWebhookSubscription(
+        input: CreateWebhookSubscriptionInput!
+    ): CreateWebhookSubscriptionPayload!
+    updateWebhookSubscription(
+        input: UpdateWebhookSubscriptionInput!
+    ): UpdateWebhookSubscriptionPayload!
+    deleteWebhookSubscription(
+        input: DeleteWebhookSubscriptionInput!
+    ): DeleteWebhookSubscriptionPayload!
    # StateOfApplicability mutations
    createStateOfApplicability(
        input: CreateStateOfApplicabilityInput!
@@ -4757,32 +4757,32 @@ type DeleteMeetingPayload {
    deletedMeetingId: ID!
 }

-input CreateWebhookConfigurationInput {
+input CreateWebhookSubscriptionInput {
    organizationId: ID!
    endpointUrl: String!
    selectedEvents: [WebhookEventType!]!
 }

-input UpdateWebhookConfigurationInput {
+input UpdateWebhookSubscriptionInput {
    id: ID!
    endpointUrl: String
    selectedEvents: [WebhookEventType!]
 }

-input DeleteWebhookConfigurationInput {
-    webhookConfigurationId: ID!
+input DeleteWebhookSubscriptionInput {
+    webhookSubscriptionId: ID!
 }

-type CreateWebhookConfigurationPayload {
-    webhookConfigurationEdge: WebhookConfigurationEdge!
+type CreateWebhookSubscriptionPayload {
+    webhookSubscriptionEdge: WebhookSubscriptionEdge!
 }

-type UpdateWebhookConfigurationPayload {
-    webhookConfiguration: WebhookConfiguration!
+type UpdateWebhookSubscriptionPayload {
+    webhookSubscription: WebhookSubscription!
 }

-type DeleteWebhookConfigurationPayload {
-    deletedWebhookConfigurationId: ID!
+type DeleteWebhookSubscriptionPayload {
+    deletedWebhookSubscriptionId: ID!
 }

 type CreateStateOfApplicabilityPayload {
--- a/pkg/server/api/console/v1/schema/schema.go
+++ b/pkg/server/api/console/v1/schema/schema.go
--- a/pkg/server/api/console/v1/types/types.go
+++ b/pkg/server/api/console/v1/types/types.go
@@ -693,14 +693,14 @@ type CreateVendorServicePayload struct {
 	VendorServiceEdge *VendorServiceEdge `json:"vendorServiceEdge"`
 }

-type CreateWebhookConfigurationInput struct {
+type CreateWebhookSubscriptionInput struct {
 	OrganizationID gid.GID                     `json:"organizationId"`
 	EndpointURL    string                      `json:"endpointUrl"`
 	SelectedEvents []coredata.WebhookEventType `json:"selectedEvents"`
 }

-type CreateWebhookConfigurationPayload struct {
-	WebhookConfigurationEdge *WebhookConfigurationEdge `json:"webhookConfigurationEdge"`
+type CreateWebhookSubscriptionPayload struct {
+	WebhookSubscriptionEdge *WebhookSubscriptionEdge `json:"webhookSubscriptionEdge"`
 }

 type CustomDomain struct {
@@ -1113,12 +1113,12 @@ type DeleteVendorServicePayload struct {
 	DeletedVendorServiceID gid.GID `json:"deletedVendorServiceId"`
 }

-type DeleteWebhookConfigurationInput struct {
-	WebhookConfigurationID gid.GID `json:"webhookConfigurationId"`
+type DeleteWebhookSubscriptionInput struct {
+	WebhookSubscriptionID gid.GID `json:"webhookSubscriptionId"`
 }

-type DeleteWebhookConfigurationPayload struct {
-	DeletedWebhookConfigurationID gid.GID `json:"deletedWebhookConfigurationId"`
+type DeleteWebhookSubscriptionPayload struct {
+	DeletedWebhookSubscriptionID gid.GID `json:"deletedWebhookSubscriptionId"`
 }

 type Document struct {
@@ -1517,7 +1517,7 @@ type Organization struct {
 	TrustCenterFiles                *TrustCenterFileConnection                `json:"trustCenterFiles"`
 	TrustCenter                     *TrustCenter                              `json:"trustCenter,omitempty"`
 	CustomDomain                    *CustomDomain                             `json:"customDomain,omitempty"`
-	WebhookConfigurations           *WebhookConfigurationConnection           `json:"webhookConfigurations"`
+	WebhookSubscriptions           *WebhookSubscriptionConnection           `json:"webhookSubscriptions"`
 	CreatedAt                       time.Time                                 `json:"createdAt"`
 	UpdatedAt                       time.Time                                 `json:"updatedAt"`
 	Permission                      bool                                      `json:"permission"`
@@ -2361,14 +2361,14 @@ type UpdateVendorServicePayload struct {
 	VendorService *VendorService `json:"vendorService"`
 }

-type UpdateWebhookConfigurationInput struct {
+type UpdateWebhookSubscriptionInput struct {
 	ID             gid.GID                     `json:"id"`
 	EndpointURL    *string                     `json:"endpointUrl,omitempty"`
 	SelectedEvents []coredata.WebhookEventType `json:"selectedEvents,omitempty"`
 }

-type UpdateWebhookConfigurationPayload struct {
-	WebhookConfiguration *WebhookConfiguration `json:"webhookConfiguration"`
+type UpdateWebhookSubscriptionPayload struct {
+	WebhookSubscription *WebhookSubscription `json:"webhookSubscription"`
 }

 type UploadAuditReportInput struct {
@@ -2623,7 +2623,7 @@ type Viewer struct {
 	SignableDocument  *SignableDocument           `json:"signableDocument,omitempty"`
 }

-type WebhookConfiguration struct {
+type WebhookSubscription struct {
 	ID             gid.GID                     `json:"id"`
 	Organization   *Organization               `json:"organization,omitempty"`
 	EndpointURL    string                      `json:"endpointUrl"`
@@ -2635,17 +2635,17 @@ type WebhookConfiguration struct {
 	Permission     bool                        `json:"permission"`
 }

-func (WebhookConfiguration) IsNode()             {}
-func (this WebhookConfiguration) GetID() gid.GID { return this.ID }
+func (WebhookSubscription) IsNode()             {}
+func (this WebhookSubscription) GetID() gid.GID { return this.ID }

-type WebhookConfigurationEdge struct {
-	Cursor page.CursorKey        `json:"cursor"`
-	Node   *WebhookConfiguration `json:"node"`
+type WebhookSubscriptionEdge struct {
+	Cursor page.CursorKey       `json:"cursor"`
+	Node   *WebhookSubscription `json:"node"`
 }

 type WebhookEvent struct {
 	ID                     gid.GID                     `json:"id"`
-	WebhookConfigurationID gid.GID                     `json:"webhookConfigurationId"`
+	WebhookSubscriptionID gid.GID                     `json:"webhookSubscriptionId"`
 	Status                 coredata.WebhookEventStatus `json:"status"`
 	Response               *string                     `json:"response,omitempty"`
 	CreatedAt              time.Time                   `json:"createdAt"`
--- a/pkg/server/api/console/v1/types/webhook_event.go
+++ b/pkg/server/api/console/v1/types/webhook_event.go
@@ -69,7 +69,7 @@ func NewWebhookEvent(we *coredata.WebhookEvent) *WebhookEvent {

 	return &WebhookEvent{
 		ID:                     we.ID,
-		WebhookConfigurationID: we.WebhookConfigurationID,
+		WebhookSubscriptionID: we.WebhookSubscriptionID,
 		Status:                 we.Status,
 		Response:               response,
 		CreatedAt:              we.CreatedAt,
--- a/pkg/server/api/console/v1/types/webhook_configuration.go
+++ b/pkg/server/api/console/v1/types/webhook_configuration.go
@@ -21,11 +21,11 @@ import (
 )

 type (
-	WebhookConfigurationOrderBy OrderBy[coredata.WebhookConfigurationOrderField]
+	WebhookSubscriptionOrderBy OrderBy[coredata.WebhookSubscriptionOrderField]

-	WebhookConfigurationConnection struct {
+	WebhookSubscriptionConnection struct {
 		TotalCount int
-		Edges      []*WebhookConfigurationEdge
+		Edges      []*WebhookSubscriptionEdge
 		PageInfo   PageInfo

 		Resolver any
@@ -33,18 +33,18 @@ type (
 	}
 )

-func NewWebhookConfigurationConnection(
-	p *page.Page[*coredata.WebhookConfiguration, coredata.WebhookConfigurationOrderField],
+func NewWebhookSubscriptionConnection(
+	p *page.Page[*coredata.WebhookSubscription, coredata.WebhookSubscriptionOrderField],
 	parentType any,
 	parentID gid.GID,
-) *WebhookConfigurationConnection {
-	var edges = make([]*WebhookConfigurationEdge, len(p.Data))
+) *WebhookSubscriptionConnection {
+	var edges = make([]*WebhookSubscriptionEdge, len(p.Data))

 	for i := range edges {
-		edges[i] = NewWebhookConfigurationEdge(p.Data[i], p.Cursor.OrderBy.Field)
+		edges[i] = NewWebhookSubscriptionEdge(p.Data[i], p.Cursor.OrderBy.Field)
 	}

-	return &WebhookConfigurationConnection{
+	return &WebhookSubscriptionConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

@@ -53,15 +53,15 @@ func NewWebhookConfigurationConnection(
 	}
 }

-func NewWebhookConfigurationEdge(wc *coredata.WebhookConfiguration, orderBy coredata.WebhookConfigurationOrderField) *WebhookConfigurationEdge {
-	return &WebhookConfigurationEdge{
+func NewWebhookSubscriptionEdge(wc *coredata.WebhookSubscription, orderBy coredata.WebhookSubscriptionOrderField) *WebhookSubscriptionEdge {
+	return &WebhookSubscriptionEdge{
 		Cursor: wc.CursorKey(orderBy),
-		Node:   NewWebhookConfiguration(wc),
+		Node:   NewWebhookSubscription(wc),
 	}
 }

-func NewWebhookConfiguration(wc *coredata.WebhookConfiguration) *WebhookConfiguration {
-	return &WebhookConfiguration{
+func NewWebhookSubscription(wc *coredata.WebhookSubscription) *WebhookSubscription {
+	return &WebhookSubscription{
 		ID: wc.ID,
 		Organization: &Organization{
 			ID: wc.OrganizationID,
--- a/pkg/server/api/console/v1/v1_resolver.go
+++ b/pkg/server/api/console/v1/v1_resolver.go
@@ -3678,74 +3678,74 @@ func (r *mutationResolver) DeleteMeeting(ctx context.Context, input types.Delete
 	}, nil
 }

-// CreateWebhookConfiguration is the resolver for the createWebhookConfiguration field.
-func (r *mutationResolver) CreateWebhookConfiguration(ctx context.Context, input types.CreateWebhookConfigurationInput) (*types.CreateWebhookConfigurationPayload, error) {
-	if err := r.authorize(ctx, input.OrganizationID, probo.ActionWebhookConfigurationCreate); err != nil {
+// CreateWebhookSubscription is the resolver for the createWebhookSubscription field.
+func (r *mutationResolver) CreateWebhookSubscription(ctx context.Context, input types.CreateWebhookSubscriptionInput) (*types.CreateWebhookSubscriptionPayload, error) {
+	if err := r.authorize(ctx, input.OrganizationID, probo.ActionWebhookSubscriptionCreate); err != nil {
 		return nil, err
 	}

 	prb := r.ProboService(ctx, input.OrganizationID.TenantID())

-	wc, err := prb.WebhookConfigurations.Create(
+	wc, err := prb.WebhookSubscriptions.Create(
 		ctx,
-		probo.CreateWebhookConfigurationRequest{
+		probo.CreateWebhookSubscriptionRequest{
 			OrganizationID: input.OrganizationID,
 			EndpointURL:    input.EndpointURL,
 			SelectedEvents: input.SelectedEvents,
 		},
 	)
 	if err != nil {
-		r.logger.ErrorCtx(ctx, "cannot create webhook configuration", log.Error(err))
+		r.logger.ErrorCtx(ctx, "cannot create webhook subscription", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}

-	return &types.CreateWebhookConfigurationPayload{
-		WebhookConfigurationEdge: types.NewWebhookConfigurationEdge(wc, coredata.WebhookConfigurationOrderFieldCreatedAt),
+	return &types.CreateWebhookSubscriptionPayload{
+		WebhookSubscriptionEdge: types.NewWebhookSubscriptionEdge(wc, coredata.WebhookSubscriptionOrderFieldCreatedAt),
 	}, nil
 }

-// UpdateWebhookConfiguration is the resolver for the updateWebhookConfiguration field.
-func (r *mutationResolver) UpdateWebhookConfiguration(ctx context.Context, input types.UpdateWebhookConfigurationInput) (*types.UpdateWebhookConfigurationPayload, error) {
-	if err := r.authorize(ctx, input.ID, probo.ActionWebhookConfigurationUpdate); err != nil {
+// UpdateWebhookSubscription is the resolver for the updateWebhookSubscription field.
+func (r *mutationResolver) UpdateWebhookSubscription(ctx context.Context, input types.UpdateWebhookSubscriptionInput) (*types.UpdateWebhookSubscriptionPayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionWebhookSubscriptionUpdate); err != nil {
 		return nil, err
 	}

 	prb := r.ProboService(ctx, input.ID.TenantID())

-	wc, err := prb.WebhookConfigurations.Update(
+	wc, err := prb.WebhookSubscriptions.Update(
 		ctx,
-		probo.UpdateWebhookConfigurationRequest{
-			WebhookConfigurationID: input.ID,
+		probo.UpdateWebhookSubscriptionRequest{
+			WebhookSubscriptionID: input.ID,
 			EndpointURL:            input.EndpointURL,
 			SelectedEvents:         input.SelectedEvents,
 		},
 	)
 	if err != nil {
-		r.logger.ErrorCtx(ctx, "cannot update webhook configuration", log.Error(err))
+		r.logger.ErrorCtx(ctx, "cannot update webhook subscription", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}

-	return &types.UpdateWebhookConfigurationPayload{
-		WebhookConfiguration: types.NewWebhookConfiguration(wc),
+	return &types.UpdateWebhookSubscriptionPayload{
+		WebhookSubscription: types.NewWebhookSubscription(wc),
 	}, nil
 }

-// DeleteWebhookConfiguration is the resolver for the deleteWebhookConfiguration field.
-func (r *mutationResolver) DeleteWebhookConfiguration(ctx context.Context, input types.DeleteWebhookConfigurationInput) (*types.DeleteWebhookConfigurationPayload, error) {
-	if err := r.authorize(ctx, input.WebhookConfigurationID, probo.ActionWebhookConfigurationDelete); err != nil {
+// DeleteWebhookSubscription is the resolver for the deleteWebhookSubscription field.
+func (r *mutationResolver) DeleteWebhookSubscription(ctx context.Context, input types.DeleteWebhookSubscriptionInput) (*types.DeleteWebhookSubscriptionPayload, error) {
+	if err := r.authorize(ctx, input.WebhookSubscriptionID, probo.ActionWebhookSubscriptionDelete); err != nil {
 		return nil, err
 	}

-	prb := r.ProboService(ctx, input.WebhookConfigurationID.TenantID())
+	prb := r.ProboService(ctx, input.WebhookSubscriptionID.TenantID())

-	err := prb.WebhookConfigurations.Delete(ctx, input.WebhookConfigurationID)
+	err := prb.WebhookSubscriptions.Delete(ctx, input.WebhookSubscriptionID)
 	if err != nil {
-		r.logger.ErrorCtx(ctx, "cannot delete webhook configuration", log.Error(err))
+		r.logger.ErrorCtx(ctx, "cannot delete webhook subscription", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}

-	return &types.DeleteWebhookConfigurationPayload{
-		DeletedWebhookConfigurationID: input.WebhookConfigurationID,
+	return &types.DeleteWebhookSubscriptionPayload{
+		DeletedWebhookSubscriptionID: input.WebhookSubscriptionID,
 	}, nil
 }

@@ -6384,20 +6384,20 @@ func (r *organizationResolver) CustomDomain(ctx context.Context, obj *types.Orga
 	return types.NewCustomDomain(domain, r.customDomainCname), nil
 }

-// WebhookConfigurations is the resolver for the webhookConfigurations field.
-func (r *organizationResolver) WebhookConfigurations(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.WebhookConfigurationOrderBy) (*types.WebhookConfigurationConnection, error) {
-	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookConfigurationList); err != nil {
+// WebhookSubscriptions is the resolver for the webhookSubscriptions field.
+func (r *organizationResolver) WebhookSubscriptions(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.WebhookSubscriptionOrderBy) (*types.WebhookSubscriptionConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookSubscriptionList); err != nil {
 		return nil, err
 	}

 	prb := r.ProboService(ctx, obj.ID.TenantID())

-	pageOrderBy := page.OrderBy[coredata.WebhookConfigurationOrderField]{
-		Field:     coredata.WebhookConfigurationOrderFieldCreatedAt,
+	pageOrderBy := page.OrderBy[coredata.WebhookSubscriptionOrderField]{
+		Field:     coredata.WebhookSubscriptionOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
 	}
 	if orderBy != nil {
-		pageOrderBy = page.OrderBy[coredata.WebhookConfigurationOrderField]{
+		pageOrderBy = page.OrderBy[coredata.WebhookSubscriptionOrderField]{
 			Field:     orderBy.Field,
 			Direction: orderBy.Direction,
 		}
@@ -6405,13 +6405,13 @@ func (r *organizationResolver) WebhookConfigurations(ctx context.Context, obj *t

 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)

-	page, err := prb.WebhookConfigurations.ListForOrganizationID(ctx, obj.ID, cursor)
+	page, err := prb.WebhookSubscriptions.ListForOrganizationID(ctx, obj.ID, cursor)
 	if err != nil {
-		r.logger.ErrorCtx(ctx, "cannot list organization webhook configurations", log.Error(err))
+		r.logger.ErrorCtx(ctx, "cannot list organization webhook subscriptions", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}

-	return types.NewWebhookConfigurationConnection(page, r, obj.ID), nil
+	return types.NewWebhookSubscriptionConnection(page, r, obj.ID), nil
 }

 // Permission is the resolver for the permission field.
@@ -6862,14 +6862,14 @@ func (r *queryResolver) Node(ctx context.Context, id gid.GID) (types.Node, error
 			}
 			return types.NewStateOfApplicability(stateOfApplicability), nil
 		}
-	case coredata.WebhookConfigurationEntityType:
-		action = probo.ActionWebhookConfigurationGet
+	case coredata.WebhookSubscriptionEntityType:
+		action = probo.ActionWebhookSubscriptionGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
-			wc, err := prb.WebhookConfigurations.Get(ctx, id)
+			wc, err := prb.WebhookSubscriptions.Get(ctx, id)
 			if err != nil {
 				return nil, err
 			}
-			return types.NewWebhookConfiguration(wc), nil
+			return types.NewWebhookSubscription(wc), nil
 		}
 	default:
 	}
@@ -8560,7 +8560,7 @@ func (r *viewerResolver) SignableDocument(ctx context.Context, obj *types.Viewer
 }

 // Organization is the resolver for the organization field.
-func (r *webhookConfigurationResolver) Organization(ctx context.Context, obj *types.WebhookConfiguration) (*types.Organization, error) {
+func (r *webhookSubscriptionResolver) Organization(ctx context.Context, obj *types.WebhookSubscription) (*types.Organization, error) {
 	if err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
 		return nil, err
 	}
@@ -8581,14 +8581,14 @@ func (r *webhookConfigurationResolver) Organization(ctx context.Context, obj *ty
 }

 // SigningSecret is the resolver for the signingSecret field.
-func (r *webhookConfigurationResolver) SigningSecret(ctx context.Context, obj *types.WebhookConfiguration) (string, error) {
-	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookConfigurationUpdate); err != nil {
+func (r *webhookSubscriptionResolver) SigningSecret(ctx context.Context, obj *types.WebhookSubscription) (string, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookSubscriptionUpdate); err != nil {
 		return "", err
 	}

 	prb := r.ProboService(ctx, obj.ID.TenantID())

-	signingSecret, err := prb.WebhookConfigurations.GetSigningSecret(ctx, obj.ID)
+	signingSecret, err := prb.WebhookSubscriptions.GetSigningSecret(ctx, obj.ID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot get signing secret", log.Error(err))
 		return "", gqlutils.Internal(ctx)
@@ -8598,8 +8598,8 @@ func (r *webhookConfigurationResolver) SigningSecret(ctx context.Context, obj *t
 }

 // Events is the resolver for the events field.
-func (r *webhookConfigurationResolver) Events(ctx context.Context, obj *types.WebhookConfiguration, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.WebhookEventOrderBy) (*types.WebhookEventConnection, error) {
-	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookConfigurationGet); err != nil {
+func (r *webhookSubscriptionResolver) Events(ctx context.Context, obj *types.WebhookSubscription, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.WebhookEventOrderBy) (*types.WebhookEventConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionWebhookSubscriptionGet); err != nil {
 		return nil, err
 	}

@@ -8618,7 +8618,7 @@ func (r *webhookConfigurationResolver) Events(ctx context.Context, obj *types.We

 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)

-	page, err := prb.WebhookConfigurations.ListEventsForConfigurationID(ctx, obj.ID, cursor)
+	page, err := prb.WebhookSubscriptions.ListEventsForSubscriptionID(ctx, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list webhook events", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
@@ -8628,13 +8628,13 @@ func (r *webhookConfigurationResolver) Events(ctx context.Context, obj *types.We
 }

 // Permission is the resolver for the permission field.
-func (r *webhookConfigurationResolver) Permission(ctx context.Context, obj *types.WebhookConfiguration, action string) (bool, error) {
+func (r *webhookSubscriptionResolver) Permission(ctx context.Context, obj *types.WebhookSubscription, action string) (bool, error) {
 	return r.Resolver.Permission(ctx, obj, action)
 }

 // TotalCount is the resolver for the totalCount field.
-func (r *webhookConfigurationConnectionResolver) TotalCount(ctx context.Context, obj *types.WebhookConfigurationConnection) (int, error) {
-	if err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookConfigurationList); err != nil {
+func (r *webhookSubscriptionConnectionResolver) TotalCount(ctx context.Context, obj *types.WebhookSubscriptionConnection) (int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookSubscriptionList); err != nil {
 		return 0, err
 	}

@@ -8642,27 +8642,27 @@ func (r *webhookConfigurationConnectionResolver) TotalCount(ctx context.Context,

 	switch obj.Resolver.(type) {
 	case *organizationResolver:
-		count, err := prb.WebhookConfigurations.CountForOrganizationID(ctx, obj.ParentID)
+		count, err := prb.WebhookSubscriptions.CountForOrganizationID(ctx, obj.ParentID)
 		if err != nil {
-			r.logger.ErrorCtx(ctx, "cannot count webhook configurations", log.Error(err))
+			r.logger.ErrorCtx(ctx, "cannot count webhook subscriptions", log.Error(err))
 			return 0, gqlutils.Internal(ctx)
 		}
 		return count, nil
 	}

-	r.logger.ErrorCtx(ctx, "unsupported resolver for webhook configuration connection", log.String("resolver", fmt.Sprintf("%T", obj.Resolver)))
+	r.logger.ErrorCtx(ctx, "unsupported resolver for webhook subscription connection", log.String("resolver", fmt.Sprintf("%T", obj.Resolver)))
 	return 0, gqlutils.Internal(ctx)
 }

 // TotalCount is the resolver for the totalCount field.
 func (r *webhookEventConnectionResolver) TotalCount(ctx context.Context, obj *types.WebhookEventConnection) (int, error) {
-	if err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookConfigurationGet); err != nil {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookSubscriptionGet); err != nil {
 		return 0, err
 	}

 	prb := r.ProboService(ctx, obj.ParentID.TenantID())

-	count, err := prb.WebhookConfigurations.CountEventsForConfigurationID(ctx, obj.ParentID)
+	count, err := prb.WebhookSubscriptions.CountEventsForSubscriptionID(ctx, obj.ParentID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot count webhook events", log.Error(err))
 		return 0, gqlutils.Internal(ctx)
@@ -8973,14 +8973,14 @@ func (r *Resolver) VendorService() schema.VendorServiceResolver { return &vendor
 // Viewer returns schema.ViewerResolver implementation.
 func (r *Resolver) Viewer() schema.ViewerResolver { return &viewerResolver{r} }

-// WebhookConfiguration returns schema.WebhookConfigurationResolver implementation.
-func (r *Resolver) WebhookConfiguration() schema.WebhookConfigurationResolver {
-	return &webhookConfigurationResolver{r}
+// WebhookSubscription returns schema.WebhookSubscriptionResolver implementation.
+func (r *Resolver) WebhookSubscription() schema.WebhookSubscriptionResolver {
+	return &webhookSubscriptionResolver{r}
 }

-// WebhookConfigurationConnection returns schema.WebhookConfigurationConnectionResolver implementation.
-func (r *Resolver) WebhookConfigurationConnection() schema.WebhookConfigurationConnectionResolver {
-	return &webhookConfigurationConnectionResolver{r}
+// WebhookSubscriptionConnection returns schema.WebhookSubscriptionConnectionResolver implementation.
+func (r *Resolver) WebhookSubscriptionConnection() schema.WebhookSubscriptionConnectionResolver {
+	return &webhookSubscriptionConnectionResolver{r}
 }

 // WebhookEventConnection returns schema.WebhookEventConnectionResolver implementation.
@@ -9060,6 +9060,6 @@ type vendorDataPrivacyAgreementResolver struct{ *Resolver }
 type vendorRiskAssessmentResolver struct{ *Resolver }
 type vendorServiceResolver struct{ *Resolver }
 type viewerResolver struct{ *Resolver }
-type webhookConfigurationResolver struct{ *Resolver }
-type webhookConfigurationConnectionResolver struct{ *Resolver }
+type webhookSubscriptionResolver struct{ *Resolver }
+type webhookSubscriptionConnectionResolver struct{ *Resolver }
 type webhookEventConnectionResolver struct{ *Resolver }
--- a/pkg/webhook/data.go
+++ b/pkg/webhook/data.go
@@ -33,10 +33,10 @@ func InsertEvent(
 	eventType coredata.WebhookEventType,
 	data any,
 ) error {
-	var configs coredata.WebhookConfigurations
+	var configs coredata.WebhookSubscriptions
 	exists, err := configs.ExistsByOrganizationIDAndEventType(ctx, conn, scope, organizationID, eventType)
 	if err != nil {
-		return fmt.Errorf("cannot check webhook configurations: %w", err)
+		return fmt.Errorf("cannot check webhook subscriptions: %w", err)
 	}

 	if !exists {
--- a/pkg/webhook/sender.go
+++ b/pkg/webhook/sender.go
@@ -64,7 +64,7 @@ type (

 	pendingDelivery struct {
 		Event  *coredata.WebhookEvent
-		Config *coredata.WebhookConfiguration
+		Config *coredata.WebhookSubscription
 	}
 )

@@ -138,22 +138,22 @@ func (s *Sender) claimNextWebhookData(ctx context.Context) (*coredata.WebhookDat

 		scope := coredata.NewScopeFromObjectID(webhookData.ID)

-		var configs coredata.WebhookConfigurations
+		var configs coredata.WebhookSubscriptions
 		if err := configs.LoadMatchingByOrganizationIDAndEventType(
 			ctx, tx, scope, webhookData.OrganizationID, webhookData.EventType,
 		); err != nil {
-			return fmt.Errorf("cannot load matching webhook configurations: %w", err)
+			return fmt.Errorf("cannot load matching webhook subscriptions: %w", err)
 		}

 		now := time.Now()

 		for _, config := range configs {
 			event := &coredata.WebhookEvent{
-				ID:                     gid.New(webhookData.ID.TenantID(), coredata.WebhookEventEntityType),
-				WebhookDataID:          webhookData.ID,
-				WebhookConfigurationID: config.ID,
-				Status:                 coredata.WebhookEventStatusPending,
-				CreatedAt:              now,
+				ID:                    gid.New(webhookData.ID.TenantID(), coredata.WebhookEventEntityType),
+				WebhookDataID:         webhookData.ID,
+				WebhookSubscriptionID: config.ID,
+				Status:                coredata.WebhookEventStatusPending,
+				CreatedAt:             now,
 			}

 			if err := event.Insert(ctx, tx, scope); err != nil {
@@ -195,7 +195,7 @@ func (s *Sender) deliver(ctx context.Context, webhookData *coredata.WebhookData,
 		s.logger.ErrorCtx(ctx, "cannot get signing secret",
 			log.Error(err),
 			log.String("webhook_data_id", webhookData.ID.String()),
-			log.String("configuration_id", d.Config.ID.String()),
+			log.String("subscription_id", d.Config.ID.String()),
 		)
 		s.updateEventStatus(ctx, d.Event, scope, coredata.WebhookEventStatusFailed, nil)
 		return
@@ -238,8 +238,8 @@ func (s *Sender) updateEventStatus(
 	}
 }

-func (s *Sender) getSigningSecret(webhookConfigurationID string, encryptedSigningSecret []byte) (string, error) {
-	if cached, ok := s.cache.Load(webhookConfigurationID); ok {
+func (s *Sender) getSigningSecret(webhookSubscriptionID string, encryptedSigningSecret []byte) (string, error) {
+	if cached, ok := s.cache.Load(webhookSubscriptionID); ok {
 		entry := cached.(*cachedSecret)
 		if bytes.Equal(entry.encryptedSecret, encryptedSigningSecret) {
 			return entry.plaintext, nil
@@ -252,7 +252,7 @@ func (s *Sender) getSigningSecret(webhookConfigurationID string, encryptedSignin
 	}

 	signingSecret := string(plaintext)
-	s.cache.Store(webhookConfigurationID, &cachedSecret{
+	s.cache.Store(webhookSubscriptionID, &cachedSecret{
 		encryptedSecret: encryptedSigningSecret,
 		plaintext:       signingSecret,
 	})
@@ -265,16 +265,16 @@ func (s *Sender) doHTTPCall(
 	eventID gid.GID,
 	endpointURL string,
 	webhookData *coredata.WebhookData,
-	configurationID gid.GID,
+	subscriptionID gid.GID,
 	signingSecret string,
 ) (json.RawMessage, error) {
 	payload := map[string]any{
-		"eventId":         eventID.String(),
-		"configurationId": configurationID.String(),
-		"organizationId":  webhookData.OrganizationID.String(),
-		"eventType":       webhookData.EventType.String(),
-		"createdAt":       webhookData.CreatedAt,
-		"data":            webhookData.Data,
+		"eventId":        eventID.String(),
+		"subscriptionId": subscriptionID.String(),
+		"organizationId": webhookData.OrganizationID.String(),
+		"eventType":      webhookData.EventType.String(),
+		"createdAt":      webhookData.CreatedAt,
+		"data":           webhookData.Data,
 	}
 	body, err := json.Marshal(payload)
 	if err != nil {