Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.getmembrane.com/llms.txt

Use this file to discover all available pages before exploring further.

External Event Types are an experimental workspace-level element. The shape of the API and console UI may change before it is generally available.
External Event Types let you subscribe to events from an external app without modifying a Connector — or thinking about connectors at all. Compared to connector-level External Events, an External Event Type is a stand-alone workspace element with its own JavaScript implementation. You define the event in your workspace, point it at an Integration or a specific Connection, and Membrane handles subscription lifecycle the same way it does for connector events. Use a stand-alone External Event Type when:
  • The connector you use is shared (for example a public connector from the Membrane Universe) and you don’t want to fork it just to add one event.
  • Different tenants need different events from the same app and managing that variability inside the connector would be awkward.
  • You want to iterate on event handling without going through a connector publish cycle.
When a Flow trigger references an External Event Type and the flow is enabled, Membrane creates an External Event Subscription and runs the type’s subscribe, handle, unsubscribe, and (optional) refresh functions — exactly the same lifecycle and logging as connector-level events.

​
Scoping

A single External Event Type can live at one of three scopes:
ScopeSet when…Applies to
UniversalNo integrationId or connectionId is setEvery integration in the workspace. Children can be created per integration to override the definition.
IntegrationintegrationId is setAll connections of a single integration.
ConnectionconnectionId is setA single connection (typically used to override the type for one tenant).
This mirrors how stand-alone Actions are scoped — the same “universal → integration → connection” override chain applies.

​
Definition

External Event Types are managed from the External Event Types page in the console (under the experimental section), or via the /external-event-types API endpoints. Each type has:
FieldDescription
nameHuman-readable name shown in the console.
keyStable identifier used by triggers and exports.
typeImplementation flavour. Currently only webhook is supported.
parametersSchemaJSON Schema for parameters the subscriber must supply (for example, projectId).
schemaJSON Schema describing the payload of emitted events.
exampleOptional example payload, used for testing and to generate schema.
subscribeJavaScript function called once when a subscription is created. Registers the webhook with the external system and returns subscription state.
handleJavaScript function called for each incoming webhook payload. Returns { events, response?, state? }.
unsubscribeJavaScript function called when the subscription is no longer needed. Deregisters the webhook.
refreshOptional JavaScript function called periodically to keep the subscription alive when the external app requires it.
The four function slots have the same signatures and semantics as the corresponding connector-level methods documented in Webhook Events — the only difference is where the definition lives.

​
Subscribing from a Flow

Use a connector-event-trigger in your flow and point its eventKey at the key of the External Event Type. The same trigger node handles connector-level events and stand-alone External Event Types — Membrane resolves the right definition based on the integration and connection used by the flow instance. 
trigger:
  type: connector-event-trigger
  name: New Form Submission
  config:
    eventKey: form-submitted
    parameters:
      formId: '{{config.formId}}'
Once the flow is enabled, Membrane creates an External Event Subscription that runs the type’s subscribe function, generates a webhook URI, and routes incoming payloads through handle and into the flow.

​
Logs and Troubleshooting

Stand-alone External Event Types use the same monitoring surfaces as connector-level events: