> This page is for version v1 (default).
> For other versions, use one of these documentation indexes:
> - v1 (default): https://docs.plextera.com/v-1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.plextera.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.plextera.com/_mcp/server.

# List events

GET https://api.plextera.com/api/public/v1/events

Returns immutable events for the event types your workspace subscribes to. Event types you have no subscription for are not listed.

Within those types, delivery state does not filter the list. An event whose subscription was paused at the time, or whose workflow filter did not match, has no delivery and is still returned with `deliverySummary.total` of `0` - that is how you see what your webhook setup missed.
With `subscriptionId`, only events delivered to that subscription are returned and `deliverySummary` is scoped to it.


Reference: https://docs.plextera.com/api/api-reference/event-subscriptions/list-events

## Authentication

- `Authorization` header (required) — Use the API key format: `api-key <token>`.

## Request

### Query parameters

- `page` (integer, optional, default: 0) — Zero-based page index. Defaults to 0.
- `size` (integer, optional, default: 50) — Page size between 1 and 100. Defaults to 50.
- `eventType` (enum, optional) — Filter by one event type. An event type without a subscription returns no events.
  - Allowed values: `document-insights.extraction.completed`, `document-insights.extraction.failed`, `document-insights.extraction.rejected`, `workflow.run.completed`, `workflow.run.failed`
- `subscriptionId` (string, optional) — Return only events that have at least one delivery to this subscription. Manual resends do not duplicate an event in the list.
- `from` (datetime, optional) — Return events created at or after this UTC ISO-8601 timestamp (inclusive).
- `to` (datetime, optional) — Return events created at or before this UTC ISO-8601 timestamp (inclusive).
- `sort` (enum, optional) — Sort by createdAt in `asc` or `desc` order. Defaults to `desc`.
  - Allowed values: `asc`, `desc`

## Response

### 200

One page of immutable events with aggregate delivery counts.

- `data` (list of PublicEvent, required) — Items on the requested page.
- `pageInfo` (PageInfo, required) — Paging details for this result set.

## Errors

### 400 Bad Request Error

INVALID_REQUEST — The request is malformed: unreadable JSON, an invalid parameter value, or a bad multipart body.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 401 Unauthorized Error

UNAUTHORIZED — The API key is missing, malformed, or revoked.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 403 Forbidden Error

FORBIDDEN — The API key is valid but not allowed to perform this operation.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 405 Method Not Allowed Error

METHOD_NOT_ALLOWED — The HTTP method is not supported for this path.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 406 Not Acceptable Error

NOT_ACCEPTABLE — The requested response media type is not supported.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 429 Too Many Requests Error

RATE_LIMITED — Too many requests in a short window. 429 responses are enforced at the network edge; the body may be plain text instead of this envelope, so rely on the status code and the Retry-After header.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

### 500 Internal Server Error

INTERNAL_ERROR — Unexpected failure inside Plextera. Retry with backoff; contact support with the requestId if it persists.

- `error` (ApiError, optional) — Machine-readable error details shared by every error response.

## Types

### PublicEvent

Immutable product event with aggregate delivery counts.

- `id` (string, required) — Stable event identifier. Matches `eventId` in the payload and the `X-Plextera-Event-Id` header.
- `eventType` (enum, required) — Product event type.
  - Allowed values: `document-insights.extraction.completed`, `document-insights.extraction.failed`, `document-insights.extraction.rejected`, `workflow.run.completed`, `workflow.run.failed`
- `occurredAt` (datetime, required) — UTC timestamp when the product event occurred.
- `apiVersion` (string, required) — Webhook payload contract version.
- `deliverySummary` (EventDeliverySummary, required) — Current delivery counts, including manual resends. On List events, `subscriptionId` scopes these counts to that subscription. Automatic retry attempts remain part of their original delivery.
- `createdAt` (datetime, required) — UTC timestamp when Plextera recorded the event.

### PageInfo

Paging details returned by every list endpoint.

- `page` (integer, optional) — Zero-based index of the returned page.
- `size` (integer, optional) — Requested page size.
- `totalItems` (long, optional) — Total number of items matching the query.
- `totalPages` (integer, optional) — Total number of pages for the requested size.

### ApiError

Machine-readable error details shared by every error response.

- `code` (string, optional) — Stable machine-readable error code. Branch your handling on this, not on `message`.
- `message` (string, optional) — Human-readable explanation. Wording may change; do not parse it.
- `requestId` (string, optional) — Unique request identifier, also returned in the X-Request-Id response header. Include it in support requests.
- `retryable` (boolean, optional) — True when retrying the same request later may succeed.
- `details` (list of ApiErrorDetail, optional) — Field-level validation issues. Present only for VALIDATION_FAILED.

### EventDeliverySummary

Delivery counts for one event. Counts are scoped to `subscriptionId` when List events uses that filter; otherwise they cover all subscriptions and resends.

- `total` (long, required) — Total deliveries created for the event.
- `pending` (long, required) — Deliveries queued or currently being sent.
- `retrying` (long, required) — Deliveries waiting for an automatic retry.
- `delivered` (long, required) — Deliveries that received a 2xx response.
- `failed` (long, required) — Deliveries that reached terminal failure.

### ApiErrorDetail

Field-level validation issue.

- `field` (string, optional) — Name of the invalid request field.
- `issue` (string, optional) — What is wrong with the field value.

## Examples

**Response**

```json
{
  "data": [
    {
      "id": "evt_01JYA3W9G05X4D2K8M6P1R3T7V",
      "eventType": "document-insights.extraction.completed",
      "occurredAt": "2026-04-07T10:22:00Z",
      "apiVersion": "v1",
      "deliverySummary": {
        "total": 2,
        "pending": 0,
        "retrying": 0,
        "delivered": 1,
        "failed": 1
      },
      "createdAt": "2026-04-07T10:22:01Z"
    }
  ],
  "pageInfo": {
    "page": 0,
    "size": 50,
    "totalItems": 1,
    "totalPages": 1
  }
}
```

**SDK Code**

```python Events page
import requests

url = "https://api.plextera.com/api/public/v1/events"

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Events page
const url = 'https://api.plextera.com/api/public/v1/events';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Events page
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.plextera.com/api/public/v1/events"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Events page
require 'uri'
require 'net/http'

url = URI("https://api.plextera.com/api/public/v1/events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Events page
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.plextera.com/api/public/v1/events")
  .header("Authorization", "<apiKey>")
  .asString();
```

```php Events page
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.plextera.com/api/public/v1/events', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Events page
using RestSharp;

var client = new RestClient("https://api.plextera.com/api/public/v1/events");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Events page
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.plextera.com/api/public/v1/events")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```