---
updatedAt: 2026-07-01T08:06:06.000Z
agentTools:
  projectIndex: https://docs.pixop.com/llms.txt
---

# Retrieve webhook events

Retrieves a paginated list of webhook events associated with the provided API key.

Each event represents delivery attempts for a configured webhook, including both successful and failed attempts.


# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "Pixop API",
    "description": "\nThe Pixop API provides a comprehensive RESTful interface for interacting with the Pixop Platform.\nIt allows users to manage API keys, projects, videos, and more.\n\nThe Pixop Platform offers video processing features such as upscaling, format conversion, and compression. It uses\nAI-driven algorithms to optimize video quality, reduce file sizes, and improve playback performance.\n\n**Quick Start Guide**\n- Explore the [Pixop API Documentation](https://docs.pixop.com/reference/) to familiarize yourself with the API's capabilities.\n\n**Required Headers**\nInclude the following headers in all API requests:\n- `Accept`: `application/json`\n- `Content-Type`: `application/json`\n- `X-API-Key`: Your API key for authentication (e.g., `X-API-Key: <your-api-key>`).  \n  **Note:** API key management endpoints that use Basic Authentication do not require the `X-API-Key` header.\n\n**Rate Limits**\nAll endpoints, except those related to API key management, enforce rate limits. Response headers provide the following rate limit details:\n- `X-RateLimit-Limit`: The maximum number of requests allowed per minute.\n- `X-RateLimit-Remaining`: The number of requests remaining in the current rate limit window.\n- `X-RateLimit-Reset`: The number of seconds until the current rate limit window resets.\n",
    "termsOfService": "https://docs.pixop.com/reference/terms-of-service",
    "contact": {
      "email": "api@pixop.com"
    },
    "version": "2.1.0"
  },
  "x-proxy-enabled": false,
  "externalDocs": {
    "description": "Learn more about Pixop",
    "url": "https://www.pixop.com"
  },
  "servers": [
    {
      "url": "https://api.pixop.com/api",
      "description": "Production environment"
    },
    {
      "url": "https://staging-api.pixop.com/api",
      "description": "Staging environment"
    }
  ],
  "tags": [
    {
      "name": "webhook event",
      "description": "Operations for viewing webhook event deliveries and their statuses."
    }
  ],
  "security": [
    {
      "api_key": []
    }
  ],
  "paths": {
    "/v1/webhooks/events": {
      "get": {
        "tags": [
          "webhook event"
        ],
        "summary": "Retrieve webhook events",
        "description": "Retrieves a paginated list of webhook events associated with the provided API key.\n\nEach event represents delivery attempts for a configured webhook, including both successful and failed attempts.\n",
        "operationId": "getWebhookEvents",
        "parameters": [
          {
            "$ref": "#/components/parameters/PageNumberParam"
          },
          {
            "$ref": "#/components/parameters/PageSizeParam"
          },
          {
            "$ref": "#/components/parameters/SortDirectionParam"
          },
          {
            "$ref": "#/components/parameters/SortByBaseParam"
          },
          {
            "$ref": "#/components/parameters/FilterByTeamId"
          },
          {
            "$ref": "#/components/parameters/FilterSuccessfulMode"
          },
          {
            "$ref": "#/components/parameters/FilterTestMode"
          },
          {
            "$ref": "#/components/parameters/FilterByOccurredAtFrom"
          },
          {
            "$ref": "#/components/parameters/FilterByOccurredAtUntil"
          }
        ],
        "responses": {
          "200": {
            "$ref": "#/components/responses/WebhookEventsPageResponse"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "UUID": {
        "type": "string",
        "format": "uuid",
        "description": "A universally unique identifier (UUID) compliant with [RFC 4122](https://tools.ietf.org/html/rfc4122). Used as a unique key to identify resources or entities across systems.",
        "examples": [
          "123e4567-e89b-12d3-a456-426614174000"
        ]
      },
      "BaseObject": {
        "type": "object",
        "description": "A base schema for common object attributes shared across multiple entities. Includes metadata such as ID and timestamps. Extended by specific schemas to inherit these common attributes.",
        "required": [
          "id",
          "createdAt",
          "updatedAt"
        ],
        "properties": {
          "id": {
            "description": "Unique identifier for the object.",
            "$ref": "#/components/schemas/UUID",
            "readOnly": true
          },
          "createdAt": {
            "description": "Date and time when the object was created.",
            "type": "string",
            "format": "date-time",
            "readOnly": true,
            "examples": [
              1734520108148
            ]
          },
          "updatedAt": {
            "description": "Date and time when the object was last updated.",
            "type": "string",
            "format": "date-time",
            "readOnly": true,
            "examples": [
              1734520708148
            ]
          }
        }
      },
      "WebhookEventType": {
        "type": "string",
        "description": "The type of event that triggered the webhook.\n",
        "enum": [
          "video_in.started",
          "video_in.done",
          "video_in.failed",
          "video_in_ingestion.started",
          "video_in_ingestion.done",
          "video_in_ingestion.failed",
          "clip_processing.started",
          "clip_processing.done",
          "clip_processing.failed",
          "clip_ingestion.started",
          "clip_ingestion.done",
          "clip_ingestion.failed",
          "video_processing.started",
          "video_processing.done",
          "video_processing.failed",
          "video_processing_ingestion.started",
          "video_processing_ingestion.done",
          "video_processing_ingestion.failed",
          "video_out.started",
          "video_out.done",
          "video_out.failed",
          "video.deleted"
        ]
      },
      "WebhookEventDataType": {
        "type": "string",
        "description": "The type of data associated with a webhook event.  \nThe value determines the schema of the accompanying `data` object.\n- `VIDEO`: The event is related to a video.\n",
        "enum": [
          "VIDEO"
        ]
      },
      "WebhookEventData": {
        "type": "object",
        "description": "Represents the data associated with a webhook event.  \nThe structure of the `data` object varies depending on the `type` field. Currently, only video-related events are supported.\n",
        "required": [
          "type"
        ],
        "discriminator": {
          "propertyName": "type",
          "mapping": {
            "VIDEO": "#/components/schemas/WebhookEventVideoData"
          }
        },
        "properties": {
          "type": {
            "$ref": "#/components/schemas/WebhookEventDataType"
          }
        }
      },
      "WebhookEventVideoData": {
        "description": "Represents the payload data for video-related webhook events.",
        "allOf": [
          {
            "$ref": "#/components/schemas/WebhookEventData"
          },
          {
            "type": "object",
            "properties": {
              "videoId": {
                "$ref": "#/components/schemas/UUID",
                "description": "The unique identifier of the video associated with the event.",
                "readOnly": true
              }
            }
          }
        ]
      },
      "WebhookEvent": {
        "allOf": [
          {
            "$ref": "#/components/schemas/BaseObject"
          },
          {
            "type": "object",
            "description": "Represents an event notification sent to a webhook endpoint.  \nIncludes the event payload, retry information, and all received responses.\n",
            "required": [
              "teamId",
              "payload",
              "responses"
            ],
            "properties": {
              "teamId": {
                "$ref": "#/components/schemas/UUID",
                "description": "The unique identifier of the team that owns the webhook.",
                "readOnly": true
              },
              "payload": {
                "$ref": "#/components/schemas/WebhookEventPayload",
                "readOnly": true
              },
              "nextAttemptEarliestAt": {
                "type": "string",
                "format": "date-time",
                "description": "The earliest possible date and time at which the webhook delivery may be attempted.  \nThis applies to both the initial delivery and any subsequent retries.  \nDue to internal scheduling and rate limiting, the actual attempt may occur shortly after this time.\n",
                "readOnly": true
              },
              "successful": {
                "type": "boolean",
                "description": "Indicates whether the event was successfully delivered to the webhook endpoint.",
                "readOnly": true
              },
              "responses": {
                "type": "array",
                "description": "One or more responses received from the webhook endpoint.  \nMultiple entries may exist if the event has been retried.\n",
                "items": {
                  "$ref": "#/components/schemas/WebhookEndpointResponse"
                }
              }
            }
          }
        ]
      },
      "WebhookEventPayload": {
        "type": "object",
        "description": "Represents the payload of a webhook event, including metadata about the event, its type, and any associated data.",
        "required": [
          "id",
          "webhookId",
          "eventType",
          "occurredAt",
          "test",
          "attemptCount"
        ],
        "properties": {
          "id": {
            "$ref": "#/components/schemas/UUID",
            "description": "The unique identifier of the webhook event.  \nThis ID is stable across delivery attempts and can be used to ensure idempotent processing on the receiver side.\n\n**Example usage:**  \nTo avoid processing the same event multiple times, store received event IDs in a persistent store (e.g., database or cache).  \nIf an event arrives with an ID that has already been processed, you can safely ignore it.\n",
            "readOnly": true
          },
          "webhookId": {
            "$ref": "#/components/schemas/UUID",
            "description": "The unique identifier of the webhook to which this event was dispatched.",
            "readOnly": true
          },
          "eventType": {
            "$ref": "#/components/schemas/WebhookEventType",
            "readOnly": true
          },
          "occurredAt": {
            "type": "string",
            "format": "date-time",
            "description": "The date and time indicating when the event occurred.",
            "readOnly": true
          },
          "test": {
            "type": "boolean",
            "description": "Whether the event was a test event.",
            "readOnly": true
          },
          "attemptCount": {
            "type": "integer",
            "description": "The number of delivery attempts that have been made for this webhook event.",
            "readOnly": true
          },
          "data": {
            "$ref": "#/components/schemas/WebhookEventData",
            "readOnly": true
          }
        }
      },
      "WebhookEndpointResponse": {
        "type": "object",
        "description": "Represents the response received from a webhook endpoint.  \nThis object is also used when the event was not sent due to rate limiting or other failures.\n",
        "required": [
          "requestedAt",
          "responseTimeMillis",
          "statusCode"
        ],
        "properties": {
          "requestedAt": {
            "type": "string",
            "format": "date-time",
            "description": "The date and time when the request was sent to the webhook.",
            "readOnly": true
          },
          "responseTimeMillis": {
            "type": "integer",
            "description": "The time taken to receive a response, measured in milliseconds.",
            "readOnly": true
          },
          "statusCode": {
            "type": "integer",
            "description": "The HTTP status code returned by the webhook endpoint.  \nAll non-2xx status codes are considered unsuccessful.\n",
            "readOnly": true
          },
          "responseBody": {
            "type": "string",
            "description": "The response body returned from the webhook endpoint, truncated to 100 characters.",
            "readOnly": true
          },
          "errorCode": {
            "type": "string",
            "description": "A machine-readable error code describing the failure, if applicable.",
            "readOnly": true
          },
          "errorMessage": {
            "type": "string",
            "description": "A human-readable error message associated with the `errorCode`, if present.",
            "readOnly": true
          },
          "responseRetryAt": {
            "type": "string",
            "format": "date-time",
            "description": "If the status code is `429` and a retry header (e.g. `Retry-After`) is present and parsed, this field indicates when a retry may be attempted.\n",
            "readOnly": true
          },
          "responseHeaders": {
            "type": "object",
            "additionalProperties": {
              "type": "string"
            },
            "description": "A map of selected response headers returned by the endpoint, truncated to 50 characters each.  \nOnly stored for unsuccessful responses to provide troubleshooting context.\n",
            "readOnly": true
          }
        }
      },
      "Error": {
        "description": "Represents an error response returned by the API. Provides details such as the error code, status, and any associated validation errors.\n",
        "type": "object",
        "required": [
          "timestamp",
          "requestId",
          "requestPath",
          "errorCode",
          "message",
          "statusCode"
        ],
        "properties": {
          "timestamp": {
            "description": "The date and time indicating when the error occurred.",
            "readOnly": true,
            "type": "string",
            "format": "date-time"
          },
          "requestId": {
            "description": "The unique identifier for the request that caused the error.",
            "readOnly": true,
            "type": "string",
            "format": "uuid"
          },
          "requestPath": {
            "description": "The API path that was accessed when the error occurred.",
            "readOnly": true,
            "type": "string"
          },
          "errorCode": {
            "description": "A code representing the specific error.",
            "readOnly": true,
            "type": "string"
          },
          "errorCodeEnum": {
            "description": "If present, the `errorCode` corresponds to one of Pixop’s documented error codes.",
            "readOnly": true,
            "$ref": "#/components/schemas/ErrorCodeEnum"
          },
          "message": {
            "description": "A human-readable message explaining the error.",
            "readOnly": true,
            "type": "string",
            "examples": [
              "Invalid input"
            ]
          },
          "statusCode": {
            "description": "The HTTP status code associated with the error.",
            "readOnly": true,
            "type": "integer",
            "examples": [
              400
            ]
          },
          "validationErrors": {
            "description": "A list of validation errors, if any.",
            "readOnly": true,
            "type": "array",
            "x-nullable": true,
            "default": null,
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            }
          },
          "errorDetails": {
            "description": "Additional details about the error, if available.",
            "readOnly": true,
            "additionalProperties": true
          }
        }
      },
      "ErrorField": {
        "description": "The field in the request that caused the error.",
        "readOnly": true,
        "type": "string",
        "examples": [
          "name"
        ]
      },
      "ValidationError": {
        "description": "Represents a validation error for a specific field in the request. Provides details about the field, the invalid value, and the error message.",
        "type": "object",
        "properties": {
          "field": {
            "$ref": "#/components/schemas/ErrorField"
          },
          "value": {
            "description": "The invalid value provided for the field.",
            "readOnly": true,
            "type": "string",
            "examples": [
              48
            ]
          },
          "message": {
            "description": "A human-readable message explaining the validation error.",
            "readOnly": true,
            "type": "string",
            "examples": [
              "size must be between 1 and 47"
            ]
          }
        }
      },
      "ErrorCodeEnum": {
        "type": "string",
        "description": "Enumerates the known error codes returned by the API.\nNot all possible codes are listed here, and additional codes may be introduced in the future.\nWhen present, these values correspond to well-defined application or HTTP errors.\n",
        "enum": [
          "UNKNOWN",
          "TOO_MANY_REQUESTS",
          "INVALID_CREDENTIALS",
          "ACCOUNT_LOCKED",
          "ACCOUNT_DISABLED",
          "ACCOUNT_EXPIRED",
          "MISSING_API_KEY",
          "INVALID_API_KEY",
          "ACCESS_DENIED",
          "RESOURCE_NOT_FOUND",
          "TEAM_NOT_FOUND",
          "DEFAULT_TEAM_NOT_API_ENABLED",
          "INVALID_INPUT",
          "FORBIDDEN",
          "VALIDATION_ERROR",
          "WEBHOOK_NOT_ACTIVE",
          "TOO_MANY_WEBHOOK_TEST_EVENTS",
          "CONTAINER_IS_NOT_SUPPORTED_FOR_SELECTED_CODEC",
          "INSUFFICIENT_PROJECTED_BALANCE_ERROR",
          "PROJECT_WITH_VIDEOS_CANNOT_BE_DELETED",
          "ACTIVE_API_KEY_CANNOT_BE_DELETED",
          "VIDEO_IN_OPERATION_NOT_FAILED",
          "VIDEO_OUT_OPERATION_NOT_FAILED",
          "VIDEO_ALREADY_BEING_COPIED_TO_OUTPUT_LOCATION",
          "ONGOING_COPY_TO_OUTPUT_NEEDS_TO_BE_RESTARTED_OR_ABANDONED",
          "BUCKET_NOT_FOUND",
          "KEY_NOT_FOUND",
          "HEAD_BUCKET_ERROR",
          "HEAD_OBJECT_ERROR",
          "RESOLVE_OBJECT_METADATA_ERROR",
          "CONTENT_RANGE_HEADER_INVALID",
          "CONTENT_NOT_PARTIAL_ERROR",
          "PARSE_CONTENT_TYPE_ERROR",
          "NO_CONTENT",
          "OBJECT_ALREADY_EXISTS",
          "CONFLICTING_DERIVED_VIDEO_IDS",
          "MAXIMUM_AMOUNT_OF_ACTIVE_API_KEYS_REACHED",
          "MAXIMUM_AMOUNT_OF_ACTIVE_WEBHOOKS_REACHED",
          "INVALID_REQUEST_BODY",
          "MISSING_REQUEST_BODY",
          "TARGET_RESOLUTION_OUT_OF_ALLOWED_RANGE",
          "TARGET_RESOLUTION_CANNOT_BE_LOWER_THAN_CALCULATED_ASPECT_RATIO_RESOLUTION",
          "INVALID_START_POSITION",
          "INVALID_END_POSITION",
          "INVALID_DATE_TIME_RANGE",
          "MISSING_CUSTOM_RESOLUTION",
          "INVALID_INPUT_COLOR_CONVERSION",
          "INVALID_OUTPUT_COLOR_CONVERSION",
          "UNSUPPORTED_CONTENT_TYPE",
          "CHECKSUM_MISMATCH",
          "VIDEO_IN_RESTART_CHECKSUM_MISMATCH",
          "INVALID_HTTPS_URL",
          "UNEXPECTED_CONTENT_RANGE",
          "VIDEO_PROCESSING_NOT_DONE",
          "WEBHOOK_RATE_LIMIT_EXCEEDED",
          "VIDEO_NOT_FULLY_INGESTED",
          "VIDEO_COMPARISON_CONFLICT",
          "APPRAISAL_BILLING_OUT_DATED",
          "AWS_MARKETPLACE_ACCESS_NOT_AVAILABLE",
          "TEAM_NOT_BILLED_THROUGH_AWS_MARKETPLACE",
          "BAD_REQUEST",
          "UNAUTHORIZED",
          "NOT_FOUND",
          "CONFLICT",
          "INTERNAL_SERVER_ERROR"
        ],
        "x-enumDescriptions": {
          "UNKNOWN": "Unknown error",
          "TOO_MANY_REQUESTS": "Too many requests",
          "INVALID_CREDENTIALS": "Invalid credentials",
          "ACCOUNT_LOCKED": "Account is locked",
          "ACCOUNT_DISABLED": "Account is disabled or API key is not active",
          "ACCOUNT_EXPIRED": "Account has expired",
          "MISSING_API_KEY": "Missing API key",
          "INVALID_API_KEY": "Invalid API key",
          "ACCESS_DENIED": "Access denied",
          "RESOURCE_NOT_FOUND": "Resource not found",
          "TEAM_NOT_FOUND": "Team not found. Either the team does not exist, is not apiEnabled, or the authenticated ApiUser does not have access to it.",
          "DEFAULT_TEAM_NOT_API_ENABLED": "Default team not API enabled",
          "INVALID_INPUT": "Invalid input",
          "FORBIDDEN": "Unauthorized",
          "VALIDATION_ERROR": "Validation error",
          "WEBHOOK_NOT_ACTIVE": "Webhook not active",
          "TOO_MANY_WEBHOOK_TEST_EVENTS": "Too many webhook test events",
          "CONTAINER_IS_NOT_SUPPORTED_FOR_SELECTED_CODEC": "Container is not supported for selected codec",
          "INSUFFICIENT_PROJECTED_BALANCE_ERROR": "Insufficient projected balance",
          "PROJECT_WITH_VIDEOS_CANNOT_BE_DELETED": "Project with videos cannot be deleted",
          "ACTIVE_API_KEY_CANNOT_BE_DELETED": "Active API key cannot be deleted",
          "VIDEO_IN_OPERATION_NOT_FAILED": "Video-in operation not failed",
          "VIDEO_OUT_OPERATION_NOT_FAILED": "Video-out operation not failed",
          "VIDEO_ALREADY_BEING_COPIED_TO_OUTPUT_LOCATION": "Video is already being copied to an output location",
          "ONGOING_COPY_TO_OUTPUT_NEEDS_TO_BE_RESTARTED_OR_ABANDONED": "Video is already being copied to an output location. Needs to be restarted or abandoned.",
          "BUCKET_NOT_FOUND": "Bucket not found",
          "KEY_NOT_FOUND": "The given key does not exist in the bucket",
          "HEAD_BUCKET_ERROR": "Error in HeadBucket",
          "HEAD_OBJECT_ERROR": "Error in HeadObject",
          "RESOLVE_OBJECT_METADATA_ERROR": "Error resolving object metadata",
          "CONTENT_RANGE_HEADER_INVALID": "Content-Range header invalid or not found",
          "CONTENT_NOT_PARTIAL_ERROR": "Partial content not received",
          "PARSE_CONTENT_TYPE_ERROR": "Error parsing content type",
          "NO_CONTENT": "No content",
          "OBJECT_ALREADY_EXISTS": "Object already exists",
          "CONFLICTING_DERIVED_VIDEO_IDS": "Conflicting derived video IDs",
          "MAXIMUM_AMOUNT_OF_ACTIVE_API_KEYS_REACHED": "Maximum amount of active API keys reached",
          "MAXIMUM_AMOUNT_OF_ACTIVE_WEBHOOKS_REACHED": "Maximum amount of active webhooks reached",
          "INVALID_REQUEST_BODY": "Invalid request body",
          "MISSING_REQUEST_BODY": "Missing request body",
          "TARGET_RESOLUTION_OUT_OF_ALLOWED_RANGE": "Target resolution out of allowed range",
          "TARGET_RESOLUTION_CANNOT_BE_LOWER_THAN_CALCULATED_ASPECT_RATIO_RESOLUTION": "Target resolution cannot be lower than calculated aspect ratio resolution",
          "INVALID_START_POSITION": "Invalid start position",
          "INVALID_END_POSITION": "Invalid end position",
          "INVALID_DATE_TIME_RANGE": "Invalid date time range",
          "MISSING_CUSTOM_RESOLUTION": "Width and height must be provided when tag and aspectRatioTag are not",
          "INVALID_INPUT_COLOR_CONVERSION": "Invalid input color conversion",
          "INVALID_OUTPUT_COLOR_CONVERSION": "Invalid output color conversion",
          "UNSUPPORTED_CONTENT_TYPE": "Unsupported content type",
          "CHECKSUM_MISMATCH": "Checksum mismatch",
          "VIDEO_IN_RESTART_CHECKSUM_MISMATCH": "Cannot restart a VideoInOperation that failed due to checksum mismatch without also setting skipChecksumValidation to true",
          "INVALID_HTTPS_URL": "Invalid HTTPS URL",
          "UNEXPECTED_CONTENT_RANGE": "Unexpected content range",
          "VIDEO_PROCESSING_NOT_DONE": "Video processing not done",
          "WEBHOOK_RATE_LIMIT_EXCEEDED": "Webhook rate limit exceeded",
          "VIDEO_NOT_FULLY_INGESTED": "Video not fully ingested",
          "VIDEO_COMPARISON_CONFLICT": "Video comparison conflict.",
          "APPRAISAL_BILLING_OUT_DATED": "Appraisal billing out of date.",
          "AWS_MARKETPLACE_ACCESS_NOT_AVAILABLE": "AWS Marketplace access not available.",
          "TEAM_NOT_BILLED_THROUGH_AWS_MARKETPLACE": "Team not billed through AWS Marketplace.",
          "BAD_REQUEST": "Standard HTTP 400 Bad Request",
          "UNAUTHORIZED": "Standard HTTP 401 Unauthorized",
          "NOT_FOUND": "Standard HTTP 404 Not Found",
          "CONFLICT": "Standard HTTP 409 Conflict",
          "INTERNAL_SERVER_ERROR": "Standard HTTP 500 Internal Server Error"
        }
      },
      "PageNumber": {
        "description": "The current page number in the paginated result set. Starts at 0.",
        "type": "integer",
        "format": "int32",
        "default": 0,
        "minimum": 0,
        "examples": [
          0
        ]
      },
      "PageSize": {
        "description": "The number of items per page in a paginated result set.",
        "type": "integer",
        "format": "int32",
        "default": 10,
        "minimum": 1,
        "maximum": 100,
        "examples": [
          10
        ]
      },
      "Page": {
        "description": "Represents the pagination details for a result set.",
        "type": "object",
        "required": [
          "pageNumber",
          "pageSize",
          "numberOfElements",
          "totalPages",
          "totalElements"
        ],
        "properties": {
          "pageNumber": {
            "$ref": "#/components/schemas/PageNumber"
          },
          "pageSize": {
            "$ref": "#/components/schemas/PageSize"
          },
          "numberOfElements": {
            "description": "The number of items on the current page.",
            "readOnly": true,
            "type": "integer",
            "format": "int32",
            "minimum": 0
          },
          "totalPages": {
            "description": "The total number of pages available for the resource.",
            "readOnly": true,
            "type": "integer",
            "format": "int32",
            "minimum": 0
          },
          "totalElements": {
            "description": "The total number of items available for the resource.",
            "readOnly": true,
            "type": "integer",
            "format": "int64",
            "minimum": 0
          }
        }
      },
      "WebhookEventsPage": {
        "allOf": [
          {
            "$ref": "#/components/schemas/Page"
          },
          {
            "type": "object",
            "description": "Represents a paginated list of webhook events.",
            "required": [
              "items"
            ],
            "properties": {
              "items": {
                "type": "array",
                "description": "The list of webhook events for the current page.",
                "items": {
                  "$ref": "#/components/schemas/WebhookEvent"
                }
              }
            }
          }
        ]
      },
      "SortDirectionEnum": {
        "description": "Specifies the direction in which to sort the results.\n- `ASC`: ascending\n- `DESC`: descending\n",
        "type": "string",
        "enum": [
          "ASC",
          "DESC"
        ],
        "default": "ASC"
      },
      "SortByBaseEnum": {
        "description": "Specifies the field by which to sort the results.\n- `createdAt`: Sort by creation date.\n- `updatedAt`: Sort by last updated date.\n",
        "type": "string",
        "enum": [
          "createdAt",
          "updatedAt"
        ],
        "default": "createdAt"
      },
      "FilterModeEnum": {
        "description": "Defines the mode of filtering applied to results. Default is `INCLUDE`.",
        "type": "string",
        "enum": [
          "INCLUDE",
          "EXCLUDE",
          "ONLY"
        ],
        "default": "INCLUDE"
      }
    },
    "parameters": {
      "FilterByTeamId": {
        "name": "teamId",
        "in": "query",
        "description": "Filters results by the specified team ID.",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/UUID"
        }
      },
      "FilterSuccessfulMode": {
        "name": "successfulMode",
        "in": "query",
        "description": "Filters results based on the successful mode:\n- `INCLUDE`: Includes successful events in the result.\n- `EXCLUDE`: Excludes successful events from the result.\n- `ONLY`: Only returns successful events in the result.\n",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/FilterModeEnum"
        }
      },
      "FilterTestMode": {
        "name": "testMode",
        "in": "query",
        "description": "Filters results based on the test mode:\n- `INCLUDE`: Includes test events in the result.\n- `EXCLUDE`: Excludes test events from the result.\n- `ONLY`: Only returns test events in the result.\n",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/FilterModeEnum"
        }
      },
      "FilterByOccurredAtFrom": {
        "name": "occurredAtFrom",
        "in": "query",
        "description": "Filters results by the occurredAt date and time.  \nIncludes only items where the occurredAt value is greater than or equal to the specified date-time (inclusive).\n",
        "required": false,
        "schema": {
          "type": "string",
          "format": "date-time"
        }
      },
      "FilterByOccurredAtUntil": {
        "name": "occurredAtUntil",
        "in": "query",
        "description": "Filters results by the occurredAt date and time.  \nIncludes only items where the occurredAt value is strictly less than the specified date-time (exclusive).\n",
        "required": false,
        "schema": {
          "type": "string",
          "format": "date-time"
        }
      },
      "PageNumberParam": {
        "name": "pageNumber",
        "in": "query",
        "description": "Specifies the current page number, starting at 0.",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/PageNumber"
        }
      },
      "PageSizeParam": {
        "name": "pageSize",
        "in": "query",
        "description": "Specifies the number of items per page.",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/PageSize"
        }
      },
      "SortByBaseParam": {
        "name": "sortBy",
        "in": "query",
        "description": "Specifies the field to sort the results by.",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/SortByBaseEnum"
        }
      },
      "SortDirectionParam": {
        "name": "sortDirection",
        "in": "query",
        "description": "Specifies the sort direction for the results:\n- `ASC`: ascending order.\n- `DESC`: descending order.\n",
        "required": false,
        "schema": {
          "$ref": "#/components/schemas/SortDirectionEnum"
        }
      }
    },
    "responses": {
      "WebhookEventsPageResponse": {
        "description": "Successfully retrieved the paginated list of webhook events.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/WebhookEventsPage"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "BadRequest": {
        "description": "Invalid request. Inspect the details of the error for more information.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "Unauthorized": {
        "description": "Authentication failed. Missing or invalid `X-API-Key` or basic authentication credentials.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "WWW-Authenticate": {
            "description": "The authentication method that should be used to gain access to the resource.",
            "schema": {
              "type": "string"
            }
          },
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "Forbidden": {
        "description": "Access denied. You do not have the necessary permissions to access this resource.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "TooManyRequests": {
        "description": "Too Many Requests. The rate limit for this resource has been exceeded.",
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          },
          "X-RateLimit-Retry-After": {
            "$ref": "#/components/headers/X-RateLimit-Retry-After"
          }
        },
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "InternalServerError": {
        "description": "An unexpected error occurred on the server.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      }
    },
    "headers": {
      "X-RateLimit-Limit": {
        "description": "The maximum number of requests allowed per minute.",
        "schema": {
          "type": "integer"
        }
      },
      "X-RateLimit-Remaining": {
        "description": "The number of requests remaining in the current rate limit window.",
        "schema": {
          "type": "integer"
        }
      },
      "X-RateLimit-Reset": {
        "description": "The number of seconds until the current rate limit window resets.",
        "schema": {
          "type": "integer"
        }
      },
      "X-RateLimit-Retry-After": {
        "description": "The number of seconds to wait before retrying a request that failed due to rate limits.",
        "schema": {
          "type": "integer"
        }
      }
    },
    "securitySchemes": {
      "api_key": {
        "type": "apiKey",
        "name": "X-API-Key",
        "in": "header",
        "description": "API key authentication using the `X-API-Key` header. \nProvide the API key as part of the request headers:\n  - `X-API-Key: <your-api-key>`\nExample:\n  - `X-API-Key: gTF1d6iQKyu8gzXO4pNCt10WlTjhKzrWtUm1wwTGuMA`\n"
      }
    }
  }
}
```