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

# Query audit log events

GET https://api.synthesia.io/v2/auditLogs/events

Retrieve paginated audit log events for a workspace or an organization.
Exactly one of workspaceId or organizationId must be provided.

Supports filtering by date range (Unix timestamps), multiple actions, multiple actor IDs, and target ID.
Any combination of filters can be applied together.

**Array parameters use comma-separated values:**
- Multiple actions: `?actions=billing.credits.consumed,dubbing.project.created`
- Multiple actors: `?actorIds=user-123,user-456`

Example queries:
- Latest events: `GET /v2/auditLogs/events?workspaceId=12345678-1234-1234-1234-123456789abc&limit=50`
- Filtered by action and date:
  `GET /v2/auditLogs/events?workspaceId=12345678-1234-1234-1234-123456789abc`
  `&actions=billing.credits.consumed&startDate=1704067200&endDate=1706745599`
- Multiple filters:
  `GET /v2/auditLogs/events?workspaceId=12345678-1234-1234-1234-123456789abc`
  `&actions=billing.credits.consumed,dubbing.project.created&actorIds=user-123,user-456`

This endpoint is rate-limited and usage is tracked against your API quota.


Reference: https://developers.synthesia.io/docs/video-api-reference/audit-logs/get-audit-log-events

## Authentication

- `Authorization` header (required) — API Key authentication via header

## Request

### Query parameters

- `workspaceId` (string, optional) — Workspace UUID to filter events by (mutually exclusive with organizationId)
- `organizationId` (string, optional) — Organization UUID to filter events by (mutually exclusive with workspaceId)
- `actions` (string, optional) — Comma-separated list of actions to filter by (e.g. "billing.credits.consumed,dubbing.project.created")
- `actorIds` (string, optional) — Comma-separated list of actor IDs to filter by (e.g. "user-123,user-456")
- `targetId` (string, optional) — Filter events by target ID
- `startDate` (integer, optional) — Filter events created on or after this Unix timestamp (seconds since epoch)
- `endDate` (integer, optional) — Filter events created before this Unix timestamp (seconds since epoch)
- `cursor` (string, optional) — Opaque cursor for pagination
- `limit` (integer, optional, default: 50) — Number of events per page (max 200)

## Response

### 200

Paginated list of audit events

- `events` (list of AuditLogEvent, required) — List of audit log events
- `hasMore` (boolean, required) — Whether there are more events to fetch
- `nextCursor` (string, optional, nullable) — Opaque cursor for fetching the next page. Pass as cursor parameter.

## Errors

### 400 Bad Request Error

Invalid query parameters

- `error` (string, required)
- `context` (string, optional)

### 403 Forbidden Error

Forbidden - Wrong API key or Public API access disabled

- `error` (string, required)
- `context` (string, optional)

### 404 Not Found Error

Workspace or organization not found

- `error` (string, required)
- `context` (string, optional)

### 429 Too Many Requests Error

Rate limit exceeded

- `error` (string, required)
- `context` (string, optional)

## Types

### AuditLogEvent

Single audit log event. Represents one audit event with full details including actor, target, context, and domain-specific details. Example response: \{ "id": "256eb609-72cb-4d42-a7a3-59a65d4e6726", "action": "user.authentication.login", "status": "success", "actor": \{ "type": "user", "id": "93d3f26c-8bb1-4759-b0c7-eef01cb0321b", "name": "local user", "email": "[dev\_user@synthesia.io](mailto:dev_user@synthesia.io)" }, "target": \{ "type": "user", "id": "93d3f26c-8bb1-4759-b0c7-eef01cb0321b", "name": "local user" }, "context": \{ "workspaceId": "b93d1427-06d8-412a-b158-6280e68b54d5", "organizationId": null, "ipAddress": null }, "details": \{ "authMethod": "username\_password", "isImpersonation": false, "emailVerified": true, "emailDomain": "synthesia.io", "company": "Synthesia" }, "metadata": \{ "createdAt": "2025-10-05T06:58:28.321Z", "processedAt": "2025-10-05T06:58:28.322Z" } }

- `id` (string, required)
- `action` (string, required)
- `status` (string, required)
- `actor` (Actor, required) — Actor (who performed the action) information.
- `target` (Target, required) — Target (what was acted upon) information.
- `context` (Context, required) — Event context (workspace, organization, IP address).
- `details` (AuditLogEventDetails, required)
- `metadata` (Metadata, required) — Event metadata (timestamps).

### Actor

Actor (who performed the action) information.

- `type` (enum, required) — Types of actors that can perform actions. USER: A human user (authenticated via username/password, social login, or SAML SSO) SYSTEM: An automated system process (e.g., "billing_system", "moderation_system") SERVICE: An internal service (e.g., "rendering_service", "dubbing_service")
  - Allowed values: `user`, `system`, `service`
- `id` (string, required)
- `name` (string, optional, nullable)
- `email` (string, optional, nullable)

### Target

Target (what was acted upon) information.

- `type` (enum, required) — Types of entities that can be acted upon. WORKSPACE: A workspace entity VIDEO: A video entity USER: A user entity (can be same as Actor in self-service actions like login/profile updates) ORGANIZATION: An organization entity ASSET: An asset entity (avatars, images, etc.)
  - Allowed values: `workspace`, `video`, `user`, `organization`, `asset`
- `id` (string, required)
- `name` (string, optional, nullable)

### Context

Event context (workspace, organization, IP address).

- `workspaceId` (string, optional, nullable)
- `organizationId` (string, optional, nullable)
- `ipAddress` (string, optional, nullable)

### AuditLogEventDetails

### Metadata

Event metadata (timestamps).

- `createdAt` (datetime, required)
- `processedAt` (datetime, optional, nullable)

## Examples

**Response**

```json
{
  "events": [
    {
      "id": "string",
      "action": "string",
      "status": "string",
      "actor": {
        "type": "user",
        "id": "string",
        "name": "string",
        "email": "string"
      },
      "target": {
        "type": "workspace",
        "id": "string",
        "name": "string"
      },
      "context": {
        "workspaceId": "string",
        "organizationId": "string",
        "ipAddress": "string"
      },
      "details": {},
      "metadata": {
        "createdAt": "2024-01-15T09:30:00Z",
        "processedAt": "2024-01-15T09:30:00Z"
      }
    }
  ],
  "hasMore": true,
  "nextCursor": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.synthesia.io/v2/auditLogs/events"

querystring = {"actions":"billing.credits.consumed,dubbing.project.created","actorIds":"user-123,user-456","endDate":"1706745599","startDate":"1704067200"}

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

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

print(response.json())
```

```javascript
const url = 'https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200';
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
package main

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

func main() {

	url := "https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200"

	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
require 'uri'
require 'net/http'

url = URI("https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200")

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
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.synthesia.io/v2/auditLogs/events?actions=billing.credits.consumed%2Cdubbing.project.created&actorIds=user-123%2Cuser-456&endDate=1706745599&startDate=1704067200")! 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()
```