> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.fortresstech.io/api-reference/webhooks/trigger-webhook-event/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.fortresstech.io/_mcp/server.

# Trigger a CORA event

POST https://api.fortresstech.io/v1/webhooks/trigger
Content-Type: application/json

Defined, not yet publishedSends you an example delivery of a CORA event on demand, so you can test your receiver before the real
flow sends you that event.The request names the `organizationId` and the `propertyId`; both are required. Fortress checks that
your API key owns them before sending anything.Fortress takes the documented example payload of the requested event, gives it a fresh eventId and
occurredAt, and POSTs it to every active webhook subscription of the property you name with partner
key `cora` that lists the requested eventType in its eventTypes. Subscriptions of that property that do
not list the event type, and those of other properties or organizations, do not receive it. Each delivery is signed with that subscription's signing secret and uses the normal
[event envelope](/webhooks/webhooks#the-event-envelope) and
[X-Fortress-\* headers](/webhooks/webhooks#delivery-headers), so your signature verification runs
exactly as it will in production. Fortress makes one attempt per subscription and does not retry.The response lists each subscription and the HTTP status your receiver answered with, or `failed` when
no response was received or Fortress could not sign the delivery. The call returns once every delivery
has finished: deliveries run in parallel, and the whole call is bounded by the gateway's limit of about
29 seconds, so keep your receiver fast.The payloads are examples, not real data. The ids in them do not point to records in your organization,
so do not act on them (for example, do not read the application or write document results for it).
This includes `data.organizationId` and `data.propertyId`: they are the documented example values, not
the ones in your request. The event pages describe `organizationId` as always your own organization, so
if your receiver checks it, verify the signature first and do not reject a test delivery on that check.This route is defined for the CORA integration and is not delivered yet. Fortress does not serve it
until it moves to Available. Authenticate with the `x-api-key` header; the key needs the `webhooks`
permission with `create`. An all-organizations key works, as long as the property belongs to the
organization you pass.

Reference: https://developer.fortresstech.io/api-reference/webhooks/trigger-webhook-event

## Authentication

- `x-api-key` header (required) — API Key authentication via header

## Request

### Body (application/json)

This endpoint expects a WebhookTriggerRequest.

- `eventType` (enum, required) — The CORA event to send. Fortress sends that event's documented example payload. Any other value returns 400.
  - Allowed values: `application.signed`, `requirement.upload_received`, `requirement.upload_removed`, `compliance_review.opened`, `compliance_review.closed`, `application.completed`, `agent.state_changed`
- `organizationId` (string, required) — The organization whose property receives the example. The API key must own this organization, otherwise the call returns 404.
- `propertyId` (string, required) — The property whose `cora` subscriptions that list `eventType` receive the example. It must belong to `organizationId` and the API key must own it, otherwise the call returns 404.

## Response

### 200

Example sent. One entry per active `cora` subscription of the property that lists the event type, with the HTTP status your receiver answered with, or `failed` when no response was received or Fortress could not sign the delivery.

- `eventId` (string, required) — The eventId of the example event. Fresh on every call; the same value is sent as eventId in the envelope and in the X-Fortress-Event-Id header.
- `deliveries` (list of WebhookTriggerDelivery, required) — One entry per active `cora` subscription of the property in the request that lists the event type.

## Errors

### 400 Bad Request Error

eventType, organizationId or propertyId is missing or invalid (the ids must be UUIDs), eventType is not one of the CORA events listed in the request schema, or Fortress has no example payload for that event yet (`No example payload for <eventType> yet`).

- `any`

### 401 Unauthorized Error

Missing or invalid x-api-key.

- `any`

### 403 Forbidden Error

The API key does not have the `webhooks` permission with `create`.

- `any`

### 404 Not Found Error

Two cases, told apart by `code`: - `NOT_FOUND`: the organization or property does not exist or is not owned by your API key. The answer is the same whether it is missing or belongs to someone else. - `NO_SUBSCRIPTION`: none of the property's active webhook subscriptions with partner key `cora` lists the requested event type.

- `code` (enum, required) — `NOT_FOUND`: the organization or property does not exist or is not owned by the API key (the answer is the same for both, so ids of other customers are never confirmed). `NO_SUBSCRIPTION`: none of the property's active webhook subscriptions with partner key `cora` lists the requested event type.
  - Allowed values: `NOT_FOUND`, `NO_SUBSCRIPTION`
- `message` (string, required) — Human-readable explanation.

### 502 Bad Gateway Error

Bad gateway. Fortress could not validate the API key or reach the backend. Retry later.

- `any`

## Types

### WebhookTriggerDelivery

- `subscriptionId` (string, required) — The webhook subscription the example was sent to.
- `status` (WebhookTriggerDeliveryStatus, required) — The HTTP status code your receiver answered with, or `failed` when no response was received (timeout, connection refused, DNS or TLS error) or Fortress could not sign the delivery (its signing secret could not be read; nothing was sent). One attempt only: Fortress does not retry an example delivery.

### WebhookTriggerDeliveryStatus

The HTTP status code your receiver answered with, or `failed` when no response was received (timeout, connection refused, DNS or TLS error) or Fortress could not sign the delivery (its signing secret could not be read; nothing was sent). One attempt only: Fortress does not retry an example delivery.

## Examples

### Receiver acknowledged

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python Receiver acknowledged
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Receiver acknowledged
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Receiver acknowledged
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Receiver acknowledged
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Receiver acknowledged
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Receiver acknowledged
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Receiver acknowledged
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### Two subscriptions, one receiver unreachable

**Response**

```json
{
  "eventId": "7c4e2a9b-1d6f-4a8e-b3c5-9f0d2e1a4b6c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 204
    },
    {
      "subscriptionId": "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "status": "failed"
    }
  ]
}
```

**SDK Code**

```python Two subscriptions, one receiver unreachable
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Two subscriptions, one receiver unreachable
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Two subscriptions, one receiver unreachable
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Two subscriptions, one receiver unreachable
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Two subscriptions, one receiver unreachable
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Two subscriptions, one receiver unreachable
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Two subscriptions, one receiver unreachable
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Two subscriptions, one receiver unreachable
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### Receiver rejected the signature

**Response**

```json
{
  "eventId": "9e8d7c6b-5a4f-4e3d-9c2b-1a0f9e8d7c6b",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 400
    }
  ]
}
```

**SDK Code**

```python Receiver rejected the signature
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Receiver rejected the signature
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Receiver rejected the signature
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Receiver rejected the signature
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Receiver rejected the signature
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Receiver rejected the signature
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Receiver rejected the signature
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Receiver rejected the signature
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### application.signed

**Request**

```json
{
  "eventType": "application.signed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python application.signed
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "application.signed",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript application.signed
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"application.signed","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go application.signed
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"application.signed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby application.signed
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"application.signed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java application.signed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"application.signed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "application.signed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp application.signed
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"application.signed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift application.signed
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "application.signed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### requirement.upload_received

**Request**

```json
{
  "eventType": "requirement.upload_received",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python requirement.upload_received
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "requirement.upload_received",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript requirement.upload_received
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"requirement.upload_received","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go requirement.upload_received
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"requirement.upload_received\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby requirement.upload_received
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"requirement.upload_received\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java requirement.upload_received
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"requirement.upload_received\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "requirement.upload_received",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp requirement.upload_received
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"requirement.upload_received\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift requirement.upload_received
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "requirement.upload_received",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### requirement.upload_removed

**Request**

```json
{
  "eventType": "requirement.upload_removed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python requirement.upload_removed
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "requirement.upload_removed",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript requirement.upload_removed
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"requirement.upload_removed","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go requirement.upload_removed
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"requirement.upload_removed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby requirement.upload_removed
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"requirement.upload_removed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java requirement.upload_removed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"requirement.upload_removed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "requirement.upload_removed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp requirement.upload_removed
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"requirement.upload_removed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift requirement.upload_removed
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "requirement.upload_removed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### compliance_review.opened

**Request**

```json
{
  "eventType": "compliance_review.opened",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python compliance_review.opened
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "compliance_review.opened",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript compliance_review.opened
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"compliance_review.opened","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go compliance_review.opened
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"compliance_review.opened\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby compliance_review.opened
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"compliance_review.opened\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java compliance_review.opened
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"compliance_review.opened\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "compliance_review.opened",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp compliance_review.opened
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"compliance_review.opened\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift compliance_review.opened
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "compliance_review.opened",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### compliance_review.closed

**Request**

```json
{
  "eventType": "compliance_review.closed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python compliance_review.closed
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "compliance_review.closed",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript compliance_review.closed
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"compliance_review.closed","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go compliance_review.closed
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"compliance_review.closed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby compliance_review.closed
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"compliance_review.closed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java compliance_review.closed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"compliance_review.closed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "compliance_review.closed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp compliance_review.closed
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"compliance_review.closed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift compliance_review.closed
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "compliance_review.closed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### application.completed

**Request**

```json
{
  "eventType": "application.completed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python application.completed
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "application.completed",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript application.completed
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"application.completed","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go application.completed
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"application.completed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby application.completed
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"application.completed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java application.completed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"application.completed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "application.completed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp application.completed
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"application.completed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift application.completed
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "application.completed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

### agent.state_changed

**Request**

```json
{
  "eventType": "agent.state_changed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
```

**Response**

```json
{
  "eventId": "3b1f6c2e-8d4a-4f7b-9c0e-5a2d1e6f7b8c",
  "deliveries": [
    {
      "subscriptionId": "6f2a9c1d-4b7e-4e3a-8f5d-2c1b0a9e8d7f",
      "status": 200
    }
  ]
}
```

**SDK Code**

```python agent.state_changed
import requests

url = "https://api.fortresstech.io/v1/webhooks/trigger"

payload = {
    "eventType": "agent.state_changed",
    "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
    "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript agent.state_changed
const url = 'https://api.fortresstech.io/v1/webhooks/trigger';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"eventType":"agent.state_changed","organizationId":"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d","propertyId":"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"}'
};

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

```go agent.state_changed
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/webhooks/trigger"

	payload := strings.NewReader("{\n  \"eventType\": \"agent.state_changed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby agent.state_changed
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/webhooks/trigger")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"eventType\": \"agent.state_changed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}"

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

```java agent.state_changed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/webhooks/trigger")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"eventType\": \"agent.state_changed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/webhooks/trigger', [
  'body' => '{
  "eventType": "agent.state_changed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp agent.state_changed
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/webhooks/trigger");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"eventType\": \"agent.state_changed\",\n  \"organizationId\": \"1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d\",\n  \"propertyId\": \"3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift agent.state_changed
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "eventType": "agent.state_changed",
  "organizationId": "1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d",
  "propertyId": "3a1e2b4c-5d6f-4a7b-8c9d-0e1f2a3b4c5d"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/webhooks/trigger")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```