Feature-level lifecycle event subscriptions

Feature-level lifecycle event subscriptions let app developers receive webhook notifications when users interact with specific app features (e.g., when a board view is duplicated, an object is created, or a column extension is deleted).

This capability extends monday.com's lifecycle events beyond the app level, providing you with fine-grained control over which feature-level events your app listens to and how each event is handled.

Overview

With feature-level lifecycle event subscriptions, you can subscribe to lifecycle events per app feature, rather than handling all events at the app level through a single webhook.

You can:

  • Subscribe only to the feature-level events you care about
  • Route different events to different webhooks endpoints
  • Choose synchronous or asynchronous handling per event
  • Manage subscriptions using clear feature identifiers

This enables you to design your backend around the behavior of individual features instead of funneling all lifecycle events through a single endpoint.

For example, you might route board view duplication events to one service while handling column extension deletions in another, depending on your app’s architecture.

Supported event types

Feature-level lifecycle events are supported across several app feature types. Each event type is associated with a specific app feature type and must match the feature you're subscribing to.

Board view events

Event TypeDescription
AppFeatureBoardView:deleteA board view is deleted
AppFeatureBoardView:duplicateA board view is duplicated
AppFeatureBoardView:restoreA board view is restored

Column extension events

Event TypeDescription
AppFeatureBoardColumnExtension:deleteA column extension is deleted
AppFeatureBoardColumnExtension:duplicateA column extension is duplicated
AppFeatureBoardColumnExtension:exportA column extension is exported

Custom column events

Event TypeDescription
AppFeatureColumn:createA custom column is created
AppFeatureColumn:deleteA custom column is deleted

Custom object events

Event TypeDescription
AppFeatureObject:archiveA custom object is archived
AppFeatureObject:createA custom object is created
AppFeatureObject:deleteA custom object is deleted
AppFeatureObject:duplicateA custom object is duplicated
AppFeatureObject:importA custom object is imported
AppFeatureObject:publishA custom object is published
AppFeatureObject:restoreA custom object is restored from the archive
AppFeatureObject:unpublishA custom object is unpublished
AppFeatureObject:update_attributesA custom object's attributes are updated
💡

Event types must match the app feature type. For example, you can't subscribe to AppFeatureObject:* events on a board view app feature.

Manage feature-level subscriptions

Feature-level lifecycle subscriptions are fully self-serve and managed through a dedicated GraphQL API. Subscriptions are configured per app feature and per event type, allowing you to control:

  • Which feature-level events your app listens to
  • Where each event is delivered
  • Whether each event is handled synchronously or asynchronously

This allows you to route different feature interactions to different services and choose the most appropriate handling mode for each event.

Event flow

Once a feature-level lifecycle subscription is configured via the API, the following flow occurs whenever a subscribed event is triggered.

sequenceDiagram
    participant MondayPlatform as monday platform
    participant MondayAppsService as monday app service
    participant YourApp as Your app

    MondayPlatform->>MondayAppsService: Lifecycle event triggered
    MondayAppsService->>MondayAppsService: Look up subscription
    MondayAppsService->>YourApp: POST to webhook URL

    alt Sync Mode (is_sync: true)
        YourApp-->>MondayAppsService: HTTP 200 (success) or 4XX (failure)
        MondayAppsService->>MondayPlatform: Notify result
        Note over MondayPlatform: Update UI
    else Async Mode (is_sync: false)
        YourApp-->>MondayAppsService: HTTP 202 (acknowledged)
        Note over YourApp: Process event...
        YourApp->>MondayAppsService: POST to back_to_url with result
        MondayAppsService->>MondayPlatform: Notify result
        Note over MondayPlatform: Update UI
    end

Webhook security

All feature-level lifecycle webhook requests are authenticated using a JWT signed with your app’s signing secret.

Your server must verify the JWT in each request to confirm it was sent by monday.com. Receiving a payload without verifying the signature doesn't guarantee that the request is authentic.

Webhook request

When a subscribed feature-level event is triggered, monday.com sends a POST request to the configured webhook URL.

  • Authorization: JWT signed with your app’s signing secret (used to verify the request came from monday)
  • Content-Type: application/json
  • X-Apps-Event-Id: Unique event ID for tracking

Verifying the webhook request

To ensure the request was sent by monday.com:

  1. Retrieve the JWT from the Authorization header.
  2. Verify the JWT signature using your app’s signing secret.
  3. Reject the request if verification fails.

Read more about the Authorization header here.

Synchronous vs asynchronous mode

Each feature-level lifecycle event can be handled independently, either synchronously or asynchronously.

  • Respond with HTTP 202 to acknowledge receipt
  • Process the event in the background
  • Call back_to_url when processing is complete

Async Response Example

curl -X POST "{back_to_url}" \
  -H "Content-Type: application/json" \
  -d '{"success": true}'

Best for: Complex calculations, external API calls, database operations, file processing