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

# Cancel Application

POST https://api.fortresstech.io/v1/applications/{applicationId}/cancel
Content-Type: application/json

Defined, not yet publishedCORA asks Fortress to cancel an application; Fortress performs the cancellation. This is CORA's only
application-level action. CORA calls it in two situations from the Nudging flow:- CADENCE\_EXPIRED: the applicant has gone more than 7 days without interaction after the last touchpoint.
- APPLICANT\_REQUESTED: the applicant replied (message.received) and the intent of the reply is to cancel
  or end the process.In both cases CORA sends the final message first (Send message, Fern), then calls this endpoint.
After the cancellation Fortress sends application.completed with status CANCELED, like any final status,
and CORA stops all work on the application and cancels pending touchpoints. Only a Fortress user can
reverse a cancellation.Fortress is still aligning with Fission Labs (CORA) how CORA handles a household where one adult never responds.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.

Reference: https://developer.fortresstech.io/api-reference/applications/cancel-application

## Authentication

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

## Request

### Path parameters

- `applicationId` (string, required) — The application.

### Body (application/json)

This endpoint expects an ApplicationCancelRequest.

- `reason` (enum, required) — CADENCE_EXPIRED: more than 7 days without interaction after the last touchpoint. APPLICANT_REQUESTED: the applicant asked to cancel.
  - Allowed values: `CADENCE_EXPIRED`, `APPLICANT_REQUESTED`

## Response

### 204

Application cancelled. A repeated call for an application already cancelled by CORA also returns 204.

## Errors

### 400 Bad Request Error

reason is missing or not one of the allowed values.

- `any`

### 401 Unauthorized Error

Missing or invalid x-api-key.

- `any`

### 404 Not Found Error

Application not found, or not in the API key's organization.

- `any`

### 409 Conflict Error

Not cancelled: Fortress refused the request. The application already has another final status, or a manual compliance review is open. CORA must handle it: stop, re-read the bundle and continue from the state Fortress returns.

- `code` (enum, required)
  - Allowed values: `APPLICATION_ALREADY_FINAL`, `COMPLIANCE_REVIEW_OPEN`
- `message` (string, optional)

## Examples

### Nudging expired

**Request**

```json
{
  "reason": "CADENCE_EXPIRED"
}
```

**SDK Code**

```python Nudging expired
import requests

url = "https://api.fortresstech.io/v1/applications/applicationId/cancel"

payload = { "reason": "CADENCE_EXPIRED" }
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Nudging expired
const url = 'https://api.fortresstech.io/v1/applications/applicationId/cancel';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"reason":"CADENCE_EXPIRED"}'
};

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

```go Nudging expired
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/applications/applicationId/cancel"

	payload := strings.NewReader("{\n  \"reason\": \"CADENCE_EXPIRED\"\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 Nudging expired
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/applications/applicationId/cancel")

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  \"reason\": \"CADENCE_EXPIRED\"\n}"

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

```java Nudging expired
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/applications/applicationId/cancel")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"reason\": \"CADENCE_EXPIRED\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/applications/applicationId/cancel', [
  'body' => '{
  "reason": "CADENCE_EXPIRED"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Nudging expired
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/applications/applicationId/cancel");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"reason\": \"CADENCE_EXPIRED\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Nudging expired
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["reason": "CADENCE_EXPIRED"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/applications/applicationId/cancel")! 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()
```

### Applicant asked to cancel

**Request**

```json
{
  "reason": "APPLICANT_REQUESTED"
}
```

**SDK Code**

```python Applicant asked to cancel
import requests

url = "https://api.fortresstech.io/v1/applications/applicationId/cancel"

payload = { "reason": "APPLICANT_REQUESTED" }
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Applicant asked to cancel
const url = 'https://api.fortresstech.io/v1/applications/applicationId/cancel';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"reason":"APPLICANT_REQUESTED"}'
};

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

```go Applicant asked to cancel
package main

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

func main() {

	url := "https://api.fortresstech.io/v1/applications/applicationId/cancel"

	payload := strings.NewReader("{\n  \"reason\": \"APPLICANT_REQUESTED\"\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 Applicant asked to cancel
require 'uri'
require 'net/http'

url = URI("https://api.fortresstech.io/v1/applications/applicationId/cancel")

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  \"reason\": \"APPLICANT_REQUESTED\"\n}"

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

```java Applicant asked to cancel
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.fortresstech.io/v1/applications/applicationId/cancel")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"reason\": \"APPLICANT_REQUESTED\"\n}")
  .asString();
```

```php Applicant asked to cancel
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.fortresstech.io/v1/applications/applicationId/cancel', [
  'body' => '{
  "reason": "APPLICANT_REQUESTED"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Applicant asked to cancel
using RestSharp;

var client = new RestClient("https://api.fortresstech.io/v1/applications/applicationId/cancel");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"reason\": \"APPLICANT_REQUESTED\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Applicant asked to cancel
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["reason": "APPLICANT_REQUESTED"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fortresstech.io/v1/applications/applicationId/cancel")! 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()
```