Method parse

python/composio/core/models/triggers.py:1261–1378

Parse an incoming webhook request into a typed, normalized trigger payload. Pass a framework request object, or pass ``body=`` and ``headers=`` explicitly. When ``verify_secret`` is provided, the SDK verifies the webhook signature before returning the normalized tri

(
        self,
        request: t.Any = None,
        *,
        body: t.Union[str, bytes, t.Mapping[str, t.Any], None] = None,
        headers: t.Union[t.Mapping[str, t.Any], None] = None,
        verify_secret: t.Union[str, None, Omit] = omit,
        tolerance: int = 300,
    )

        }

    def parse(
        self,
        request: t.Any = None,
        *,
        body: t.Union[str, bytes, t.Mapping[str, t.Any], None] = None,
        headers: t.Union[t.Mapping[str, t.Any], None] = None,
        verify_secret: t.Union[str, None, Omit] = omit,
        tolerance: int = 300,
    ) -> VerifyWebhookResult:
        """
        Parse an incoming webhook request into a typed, normalized trigger payload.

        Pass a framework request object, or pass ``body=`` and ``headers=``
        explicitly. When ``verify_secret`` is provided, the SDK verifies the
        webhook signature before returning the normalized trigger payload. When
        it is omitted, the SDK parses the body without verifying the signature.

        ``request`` may be any object exposing the request body and headers, such
        as a Flask, Django, or FastAPI request. The body is read from ``.body``
        (or ``.data`` / ``.get_data()``), and the headers are read from
        ``.headers``. Because this SDK is synchronous, async frameworks must pass
        an already-read raw body, for example via ``body=await request.body()``.

        :param request: The incoming webhook request object (Flask/Django/FastAPI)
        :param body: The raw request body (str/bytes/parsed mapping); overrides ``request``
        :param headers: The request headers as a mapping; overrides ``request``
        :param verify_secret: Webhook secret; when set, the signature is verified.
            Omit it entirely to parse without verification. Passing a present-but-empty
            value (e.g. an unset ``COMPOSIO_WEBHOOK_SECRET``) raises rather than
            silently skipping verification.
        :param tolerance: Max webhook age in seconds (only used when verifying)
        :return: VerifyWebhookResult containing version, normalized payload, and raw payload
        :raises ValidationError: If ``verify_secret`` is empty, or is set but signature headers are missing
        :raises WebhookSignatureVerificationError: If signature verification fails
        :raises WebhookPayloadError: If the payload cannot be parsed

        Example:
            # Flask: verify the signature
            @app.route('/webhooks/composio', methods=['POST'])
            def webhook():
                try:
                    result = composio.triggers.parse(
                        request,
                        verify_secret=os.environ['COMPOSIO_WEBHOOK_SECRET'],
                    )
                    print(f"Trigger: {result['payload']['trigger_slug']}")
                    print(f"Event data: {result['payload']['payload']}")
                    return 'OK', 200
                except exceptions.WebhookSignatureVerificationError:
                    return 'Unauthorized', 401

            # FastAPI: parse without verifying after reading the async body
            @app.post('/webhooks/composio')
            async def webhook(request: Request):
                raw = await request.body()
                result = composio.triggers.parse(body=raw, headers=request.headers)
                return {'trigger': result['payload']['trigger_slug']}
        """